Newsgroup: it.comp.lang.visual-basic
Titolo: Funzione che ritorni un generic : List (Of ...) desunta a runtime dal tipo di un PARAMARRAY

dunque, mi sto abbuffando in un'orgia futile 
nell'introspezione a run time (system reflections),
ma ammetto di scornarmi parecchio coi generics (la 
frustrazione viene da una certa assuefazione ai template del 
C++, che consentono una assai più sistematica 
parametrizzazione, mi pare).
Allora ho una funzione che ha come parametro un PARAMARRAY, 
è l'unico tipo di parametro che mi pare consenta ancora di 
passare tipi qualsiasi.
dopo un controllo per stabilire che sia di tipo ENUM (uso 
TypeOf e un confronto con [enum] scritto tra quadre, non ho 
ancora ben capito la sintassi), passo a enumerare nomi e 
valori con [Enum].GetNames() e GetTypes
Adesso però vorrei far ritornare alla funzione un valore di 
ritorno parametrizzato, che usi uno dei generics :
una List (Of stessso_tipo_del_valore_della_ENUM)
E' inteso che, essendo i valori delle enum comuqnue 
integral, facendo un widening cautelativo potrei ritornare un
List (Of Ulong) e starei tranquillo, ma vorrei poter 
generalizzare, e desumere il tipo corretto con cui 
personalizzare la List ritornata a partire dal tipo di dato 
Enum passato come argomento ...
Si accettano suggerimenti molto volentieri
ciao
Soviet
P.S. so che è pessimo costume voler replicare le 
funzionalità di un altro linguaggio ... ma òa tentazione di 
portarsi in borsa alcune abitudini è forte
riciao

 Si accettano suggerimenti molto volentieri
Mmm... temo di non aver capito la domanda.
Tento di rispondere ugualmente.
ParamArray _non_ ï¿œ un tipo. Serve per passare in sequenza un numero non noto a 
priori di elementi di un certo tipo. Lo definirei 'syntactic sugar', grossomodo 
equivalente a passare un'array ad una certa funzione (di qui il nome ParamArray, 
immagino).
Ma il _tipo_ di questi parametri lo decidi tu mettendo dopo il nome del 
parametro un 'As Tipo'. Se non specifichi un tipo e non hai warning del 
compilatore attivati, verrï¿œ assunto il tipo Object.
ParamArray quindi non ï¿œ un modo per passare quello che vuoi. Per passare quello 
che vuoi dichiara un parametro di tipo Object e sei a posto.
Allo stesso modo, dal punto di vista strettamente sintattico Enum non ï¿œ un tipo 
ma una parola chiave (ed ï¿œ quello il motivo per cui la devi mettere tra quadre).
Non capisco cosa intendi quando scrivi '... vorrei poter generalizzare, e 
desumere il tipo [...] a partire dal tipo di enum passato come argomento'.
L'argomento *ï¿œ* un enum. Se un parametro ï¿œ
	ParamArray parametro() As MiaEnumerazione
il tipo giï¿œ ce l'hai.
Se invece vuoi scrivere un metodo generico, cerca 'generic methods' con google.
In breve, un metodo generico (sorpresa sorpresa) *non saprï¿œ nulla* (con le 
dovute eccezioni) dei tipi con cui avrï¿œ a che fare.
Scriverai
	Public Function f(Of T) As List(Of T)
e il corpo del metodo saprï¿œ solo di avere a che fare con il tipo T.
-- 
S.

 e il corpo del metodo saprà solo di avere a che fare con il tipo T.
Si, fuochino. Mi può servire se trovo il modo di restringere 
un pò T alle sole Enum (e magari in futuro ad altri tipi 
affini tra loro).
Cmq ti ringrazio molto, per la pazienza e competenza.
E' un po' di tempo che non programmavo col Basic (o quel che 
è diventato .NET 3.5).
Ammetto che il primo impatto è stato di totale stupore ed 
entusiasmo. Pareva esserci tutto e prefabbricato, senza fatica.
Ora sto cominciando ad esitare. Ad es. ho infinite strutture 
da tradurre dal C++ con layout di dati a lunghezza fissa.
Ebbene, scopro che le stringhe fisse non possono più stare 
dentro le structure, che le matrici fisse idem. E che ci 
sono i loro bravi campi informativi obbrobbriosi (che 
secondo me è sinctactic shit :-)), tipo 
vbFixedStringAttribute o come cavolo si scrive.
Però poi nell'Help SOTTOLINEANO che i dati sono comunque 
variabili, che non implicano l'allocazione automatica di 
spazio fisso che deve essere fatto a mano e altrove.
E soprattutto non ho neppure capito se tale spazio risiede 
fisicamente dentro la structure monolitica (che può quindi 
essere serializzata a manina, come un tipico oggetto 
compatto flat), o se sono solo puntatori/reference ad 
oggetti sparsi altrove, cosa che per serializzare con 
efficienza mi diventerebbero un massacro.
Insomma ... non ho proprio capito quale esigenza abbia 
spinto a sacrificare tutti i dati a layout fisso.
Non gli stanno bene al CLR ? E allora ? Sta nella 
definizioen stessa di tipo utente che qualsiasi sistema 
prefabbricato non possa esserne pienamente aware
Boh ... sono perplesso.
Tradurre il codice C++ senza poter specchiare almeno la 
struttura dati sottostante pare da incubo. E non oso 
immaginare come diventerebbe far colloquiare un pezzo di DLL 
che rimarrebbe in C++ (tipo il motore che cripta/decripta 
dei dati, che non richiedendo interfacce grafiche lo non 
tradurrei per niente) con la parte front-end Visual Basic.
Avere dei dati diversi mi spaventa.
Ho leggiucchiato un poco di Marshalling ... ma ammetto di 
non averci capito molto. E' a un livello troppo 
alto-astratto, e mi tiene a distanza da una dannata matrice 
di byte :-)
Vabbè ... ti ho scocciato a sufficienza con un piagnisteo 
fuori luogo ... Scusami :-(
ciao
Soviet

 ... Scusami :-(
Maddai.
Purtroppo sul marshalling non ti so aiutare.
Comunque potresti giocherellare con gli attributi StructLayout e MarshalAs, mi 
pare che si possa avere una certa flessibilit� con le strutture.
Non ti so dire come vengano allocati i membri della struttura (se un po' qui e 
un po' l�) per� cos� a naso con StructLayout=Sequential, o qualcosa del genere, 
puoi ottenere determinate garanzie.
-- 
S.

 
MEGA-CUT
Mi sono salvato il tuo post perché immagino che dovrò 
studiarci sopra un bel po'.
Intanto ti ringrazio nuovamente, sei stato davvero 
disponibile e ricco di spunti molto interessanti.
Io di NET sono alquanto ignorante (usavo, ma parecchi anni 
fa, il VB 6 e varie api, vespe e calabroni di winzozz :-)).
Praticamente è ricominciare daccapo.
ciao
P.S.
ti sono debitore, anche se molto probabilmente senza poter 
ricambiare i consigli
Soviet

 Praticamente � ricominciare daccapo.
Eh s�, � tutto un'altro modo di programmare, soprattutto rispetto a VB6, che
di certo non era una esempio da imitare in quanto a design.
C'� parecchio da studiare, il framework � veramente enorme (e la versione 4
� imminente).
-- 
S.