2009-08-18 2 views
6

Tipo C'è sempre un motivo per utilizzare Type parametri su farmaci generici, vale a dire:parametri vs. farmaci generici

// this... 
void Foo(Type T); 
// ...over this. 
void Foo<T>(); 

Mi sembra che i generici sono molto più utili in quanto forniscono vincoli generici e con C# 4.0, contravarience e covarience, così come probabilmente alcune altre caratteristiche che non conosco. Mi sembra che la forma generica abbia tutti i vantaggi, e nessun negativo che anche il primo non condivide. Quindi, ci sono dei casi in cui dovresti usare il primo invece?

risposta

8

Assolutamente: quando non si conosce il tipo fino al momento dell'esecuzione. Per esempio:

foreach (Type t in someAssembly.GetTypes()) 
{ 
    Foo(t); 
} 

facendo che quando Foo è generico è un dolore nel culo. È fattibile, ma doloroso.

Consente inoltre al parametro di essere null, che può essere utile in alcune situazioni.

+0

E 'anche molto più lento e costoso a che fare con i generici (tutte quelle chiamate di riflessione non può essere abbastanza) –

+2

Assolutamente - anche se il dolore è normalmente più importante per me :) –

0

Beh, in realtà non sono affatto gli stessi.

Con il secondo, hai effettivamente una classe del tipo in fase di compilazione (qualsiasi cosa sia stata passata da chiunque). Quindi puoi chiamare funzioni specifiche su di esso (diciamo se è tutto di una determinata interfaccia).

Nel tuo primo esempio, hai un oggetto di classe 'Tipo'. Quindi dovrai ancora determinare cosa è e fare un cast per fare qualcosa di utile con esso.

+0

Esattamente, la seconda forma ha tutto i vantaggi del controllo in fase di compilazione. Quindi dato che, tra le altre cose, volevo sapere se c'era sempre un motivo per usare il primo. Mi rendo conto che sono diversi, ma diversi non significano che una forma non esaurisce completamente il bisogno dell'altro. –

+0

Bene, il mio punto è che userete il primo per uno scopo completamente diverso rispetto al secondo. Non li useresti mai per la stessa cosa (cioè: chiamare metodi comuni o eseguire azioni 'generiche' su un dato tipo di classe). –

1
Foo(someVariable.GetType());  // allowed 

Foo<someVariable.GetType()>(); // illegal 
+0

Credo che fosse il punto di Jon. –