Comprendere i generici C# molto meglio

Question

Ho esaminato alcuni esempi di codice utilizzando i generici C#. Perché e quando dovrei usarli?

Tutti gli esempi erano complessi. Ho bisogno di un esempio semplice e chiaro che mi faccia iniziare con i generici C#.

Answer 1

Un esempio molto semplice è la classe generica List<T>. Può contenere un numero di oggetti di qualsiasi tipo. Ad esempio, è possibile dichiarare un elenco di stringhe (new List<string>()) o un elenco di Animali (new List<Animal>()), perché è generico.

E se non potessi usare i farmaci generici? È possibile utilizzare la classe ArrayList, ma il lato negativo è che il tipo di contenuto è un object. Quindi, quando esegui un'iterazione sull'elenco, devi inserire ogni elemento nel suo tipo corretto (string o Animal) che è più codice e presenta una penalizzazione delle prestazioni. Inoltre, poiché un oggetto ArrayList contiene oggetti, non è sicuro dal tipo. Si potrebbe ancora aggiungere un Animal a un ArrayList di stringhe:

ArrayList arrayList = new ArrayList(); 
arrayList.Add(new Animal()); 
arrayList.Add(""); 

Così, quando l'iterazione un ArrayList che avrebbe dovuto controllare il tipo per assicurarsi che l'istanza è di un tipo specifico, che si traduce in codice poveri:

foreach (object o in arrayList) 
{ 
    if(o is Animal) 
    ((Animal)o).Speak(); 
} 

con un generico List<string>, questo non è semplicemente possibile:

List<string> stringList = new List<String>(); 
stringList.Add("Hello"); 
stringList.Add("Second String"); 
stringList.Add(new Animal()); // error! Animal cannot be cast to a string 

Answer 2

In poche parole, farmaci generici permettono di scrivere classi tha t lavorare con oggetti di qualsiasi tipo, ma senza dover trasmettere i dati a Object. Ci sono vantaggi di prestazioni per questo, ma rende anche il codice più leggibile, manutenibile e meno soggetto a errori.

È consigliabile utilizzare sempre generici anziché le classi di stile .NET 1.1 quando possibile.

Answer 3

Riassumendo altre risposte con una certa enfasi:

1) generici consentono di scrivere codice 'generico' (vale a dire, si lavorerà per più tipi). Se si desidera scrivere un comportamento "generico", che è necessario comportarsi per tipi di dati diversi, è sufficiente scrivere quel codice una sola volta. L'esempio di List è un grande esempio, è possibile bisogno di liste di forse clienti, prodotti, ordini, fornitori ... il tutto utilizzando lo stesso codice di un'istanza per ogni tipo di

// snippet 
List<Customer> customers = new List<Customer>(); 
Customer thisCustomer = new Customer(); 
customers.Add(thisCustomer); 

List<Order> orders = new List<Order>(); 
Order thatOrder = new Order(); 
orders.Add(thatOrder); 

// etc. 

2) Sorprendentemente, i generici ancora abilitare la sicurezza di tipo ! Quindi, se si tenta questo, avrete a ragione un errore:

// continued for snippet above 
Order anotherOrder = new Order(); 
customers.Add(anotherOrder); // FAIL! 

E si vorrebbe che, per essere un errore, in modo che in seguito il codice di elaborazione cliente non deve gestire un ordine fasullo mostrando in la lista dei clienti.

Answer 4

La duplicazione è la radice di tutti i mali. Un caso di duplicazione del codice si verifica quando è necessario eseguire la stessa operazione su diversi tipi di dati. I generici consentono di evitarlo consentendo di codificare attorno a un tipo 'generico' e in seguito di sostituirlo con tipi specifici.

L'altra soluzione a questo problema consiste nell'utilizzare le variabili di tipo "System.Object" a cui è possibile assegnare l'oggetto di qualsiasi tipo. Questo metodo prevede operazioni di boxing e unboxing tra valori e tipi di riferimento che colpiscono le prestazioni.Digitare anche casting impedisce al codice di essere pulito.

I generici sono supportati in MSIL e CLR che lo rendono molto efficace.

Si consiglia di leggere questi articoli su farmaci generici -

http://msdn.microsoft.com/en-us/library/512aeb7t(VS.80).aspx

http://msdn.microsoft.com/en-us/library/ms379564(VS.80).aspx#csharp_generics_topic1