La parola chiave "dinamica" C# 4.0 rende ridondante la Generics?

Question

Sono molto entusiasta delle funzionalità dinamiche in C# (C#4 dynamic keyword - why not?), soprattutto perché in certe parti della libreria del mio codice uso molta riflessione.

La mia domanda è duplice:

1. significa "dinamico" sostituire Generics, come nel caso qui di seguito? Metodo

Generics:

public static void Do_Something_If_Object_Not_Null<SomeType>(SomeType ObjToTest) { 

     //test object is not null, regardless of its Type 
     if (!EqualityComparer<SomeType>.Default.Equals(ObjToTest, default(SomeType))) { 
      //do something 
     } 
    } 

metodo dinamico (??):

public static void Do_Something_If_Object_Not_Null(dynamic ObjToTest) { 

     //test object is not null, regardless of its Type?? but how? 
     if (ObjToTest != null) { 
      //do something 
     } 
    } 

2. fa "dinamico" ora consentire metodi per restituire tipi anonimi, come nel caso di seguito ?:

public static List<dynamic> ReturnAnonymousType() { 
     return MyDataContext.SomeEntities.Entity.Select(e => e.Property1, e.Property2).ToList(); 
    } 

fresco, evviva

EDIT:

aver pensato attraverso la mia domanda un po 'di più, e alla luce delle risposte, vedo ho completamente incasinato la principale domanda generica/dinamico. Sono davvero completamente diversi. Quindi sì, grazie per tutte le informazioni.

E il punto 2?

Answer 1

dynamic potrebbe semplificare un numero limitato di scenari di riflessione (in cui si conosce il nome-utente in attacco, ma non v'è alcuna interfaccia) - in particolare, potrebbe aiutare con gli operatori generici (although other answers exist) - ma a parte la gli operatori generici escogitano, c'è un piccolo crossover con i generici.

I generici consentono di conoscere (in fase di compilazione) il tipo con cui si sta lavorando - al contrario, dynamic non corrisponde al tipo . In particolare, i generici consentono di specificare e provare un numero di condizioni su un tipo - ad esempio, potrebbe implementare un'interfaccia o disporre di un costruttore pubblico senza parametri. dynamic non è d'aiuto: non supporta le interfacce e, peggio che semplicemente non preoccuparsi delle interfacce, significa che non possiamo nemmeno vedere le implementazioni di interfaccia esplicita con dynamic.

Inoltre, dynamic è davvero un caso speciale di object, quindi la boxe entra in gioco, ma con una certa vendetta.

In realtà, si dovrebbe limitare l'uso di dynamic a pochi casi:

• interoperabilità COM
• DLR interoperabilità
• forse qualche anatra luce digitando
• forse qualche generica operatori

Per tutti gli altri casi, generici e C# regolari sono la strada da percorrere.

Answer 2

Per rispondere alla prima domanda, i generici vengono risolti in fase di compilazione, tipi dinamici in fase di esecuzione. Quindi c'è una netta differenza nella sicurezza e nella velocità del tipo.

Answer 3

Classi dinamiche e generiche sono concetti completamente diversi. Con i generici definisci i tipi al momento della compilazione. Non cambiano, non sono dinamici. Basta mettere un "segnaposto" su qualche classe o metodo per far sì che il codice chiamante definisca il tipo.

I metodi dinamici sono definiti in fase di esecuzione. Non hai la sicurezza del tipo in fase di compilazione lì. La classe dinamica è simile come se si abbiano riferimenti a oggetti e metodi di chiamata con i relativi nomi di stringhe usando la reflection.

Answer 4

Risposta alla seconda domanda: è possibile restituire tipi anonimi in C# 3.0. Trasmetti il ​​tipo all'oggetto, restituiscilo e usa reflection per accedere ai suoi membri. La parola chiave dinamica è solo zucchero sintattico per questo.

Answer 5

Per rispondere alla tua domanda. No.

• Generics ti dà "algoritmo di riuso" - si scrive codice indipendente da un tipo di dati. la parola chiave dinamica non fa nulla relativo a questo. Definisco List<T> e quindi posso usarlo per l'elenco di stringhe, int, ecc ...
• Tipo sicurezza: L'intero tempo di compilazione verifica il dibattito. Le variabili dinamiche non ti avviseranno con avvisi/errori in fase di compilazione nel caso in cui commettessi un errore, ma esploderanno in fase di runtime se manca il metodo che stai tentando di invocare. Discussione statica vs digitazione dinamica
• Prestazioni: Generics migliora le prestazioni per algoritmi/codice utilizzando i tipi di valore di un ordine di grandezza significativo.Previene l'intero ciclo di box-unboxing che ci è costato pre-Generics. La dinamica non fa nulla anche per questo.

Che la parola dynamic darebbe voi è

• semplice codice (quando si interoperabilità con Excel consente di dire ..) Non è necessario specificare il nome delle classi o il modello a oggetti . Se invochi i metodi corretti, il runtime si prenderà cura di richiamare tale metodo se esiste nell'oggetto in quel momento. Il compilatore ti consente di andare via anche se il metodo non è definito. Tuttavia, ciò implica che sarà più lento rispetto a una chiamata al metodo con compilazione verificata/a tipizzazione statica poiché il CLR dovrebbe eseguire controlli prima di invocare un campo/metodo var dinamico.
• La variabile dinamica può contenere diversi tipi di oggetti in diversi momenti - Non sei legato a una famiglia o a un tipo specifico di oggetti.