Utilizzando la parola chiave “params” per i parametri generici in C #

Mi sono imbattuto nel bellissimo Func delegato in C # .NET 4.5 oggi. Presumo che 16 fosse un luogo arbitrario da fermare (quali metodi hanno più di 16 parametri?) Ma mi ha fatto pensare: è ansible in C # specificare che un tipo generico può avere un numero qualsiasi di argomenti tipo? in un modo simile che la parola chiave params per i metodi consente un numero qualsiasi di argomenti per un metodo. Qualcosa come questo:

 public class MyInfiniteGenericType { ... } 

dove all’interno della class si può quindi accedere agli argomenti di tipo enumerando attraverso di essi o utilizzando T[index] nello stesso modo in cui i params consentono all’interno dei metodi.

Non l’ho mai usato personalmente, ma il delegato di Func sarebbe un posto perfetto per usarlo. Non ci sarebbe bisogno di 16 diversi tipi di Func!

Quindi la mia domanda è, questo può essere fatto in qualsiasi modo in C #, e se no è un’idea sciocca ?

è ansible in C # specificare che un tipo generico può avere un numero qualsiasi di argomenti tipo?

No, C # non ha niente del genere, ho paura.

Fondamentalmente Func e Func sono tipi completamente indipendenti per quanto riguarda il CLR, e non c’è niente come params per specificare più argomenti di tipo.

Per quanto riguarda la sua utilità: vedo casi in cui potrebbe essere utile, ma ho il sospetto che siano abbastanza rari da significare che la funzione non supera la soglia “beneficio / costo”. (Si noti che quasi certamente richiederebbe anche modifiche CLR).

C ++ 11 ha la caratteristica di cui stai essenzialmente parlando. Lo chiamano modelli variadici .

I generici C # non sono proprio come i modelli C ++, tuttavia, e renderebbero difficile creare la stessa cosa.

Nel caso C ++, i modelli vengono espansi in fase di compilazione in qualsiasi tipo di calcestruzzo utilizzato. Nel caso C #, la specifica del tipo avviene interamente in fase di esecuzione. E l’IL risultante avrebbe bisogno di supportare il numero di diversi tipi incontrati.

No, non è ansible avere un numero arbitrario di argomenti generici. Probabilmente è anche un’idea sciocca, perché i parametri di tipo generico non vengono risolti in fase di runtime, sono risolti in fase di compilazione e quindi iterare su di essi in quel modo non è affatto una cosa ovvia da fare.

Si potrebbe anche pensare che Tuple <,,,,,,,,> potrebbe essere un posto ovvio per questo, ma la soluzione è quando si esauriscono argomenti generici, si rende l’ultima una Tupla <,,,,> per i campi rimanenti.

No, questo non può essere fatto.

Non è così semplice come trattarlo come una serie di tipi (un concetto che nemmeno esiste in C #). Considerare Func : il numero di parametri di tipo deve essere uguale al numero di parametri del metodo Invoke del delegato. Ma come potrebbe il programmatore esprimere una tale relazione tra parametri di tipo e parametri regolari?

Tuttavia, questa caratteristica esiste in C ++ 11 – modelli variadici . Si noti che C ++ non consente l’accesso ai singoli parametri di tipo usando la syntax dell’array; al contrario, le funzioni solitamente separano il primo parametro di tipo dal resto, e usano le chiamate ricorsive per decomprimere il resto.

Mi sono appena trovato curioso di vedere se qualcun altro ha avuto un uso per questo. Ho appena scritto un compositore generico per build compositi da mixins assemblati usando Castle Dynamic Proxy.

Ho costruito il compositore per supportare due mix e stava per procedere a “copiare e incollare e regolare (bleh)” i due mixin compositore in 15 più varianti fino a un 17 composer di missaggio (simile a Func attraverso Func ). Ma poi ho pensato, non sarebbe bello se potessi semplicemente definire Composer !

Purtroppo, vado a copiare e incollare e ad aggiustare (l’attività che i farmaci generici ci aiutano ad evitare).