I generici permettono di scrivere classi e metodi parametrizzati per tipo, fornendo sicurezza di tipo e riusabilità senza duplicazione di codice o cast. I vincoli restringono quali tipi un parametro generico può essere, consentendo l'uso sicuro dei loro membri. I generici sono pervasivi in C# (l'intera libreria delle collezioni li utilizza).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
I generici spostano gli errori di tipo da runtime (cast di object) a compile time, ed eliminano i cast — codice sicuro e riusabile.
public class Box<T> // a generic class
{
private T _value;
public void Set(T value) => _value = value;
public T Get() => _value;
}
var box = new Box<string>(); // T = string, type-safe
// generic method
public T Max<T>(T a, T b) where T : IComparable<T> // constraint (see below)
=> a.CompareTo(b) > 0 ? a : b;
where T : class // T must be a reference type
where T : struct // T must be a value type
where T : new() // T must have a parameterless constructor
where T : IComparable<T> // T must implement an interface (so you can call its members)
where T : BaseClass // T must derive from BaseClass
// example: constraint lets you call CompareTo safely
public T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint
I vincoli (where T : ...) limitano cosa T può essere, il che consente di usare in modo sicuro i membri di quel tipo (ad es. vincolare a IComparable<T> consente di chiamare CompareTo). Senza un vincolo, T potrebbe essere qualsiasi cosa, quindi non si possono presupporre membri.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
I generici sono fondamentali per C# — sono utilizzati in modo pervasivo (l'intera libreria delle collezioni, Task<T>, IEnumerable<T> e innumerevoli API sono generici), quindi comprenderli è essenziale per qualsiasi sviluppo in C#.
I generici risolvono un vero problema: scrivere codice riusabile che funzioni per più tipi mantenendo la sicurezza di tipo — l'alternativa (utilizzare object e fare cast) sacrifica la sicurezza in compile-time e richiede cast soggetti a errori, mentre duplicare il codice per tipo è difficile da mantenere.
I generici forniscono codice riusabile e type-safe senza cast e con controllo degli errori in compile-time. I vincoli (where T : ...) sono un complemento importante: limitano cosa un parametro di tipo può essere, il che sia consente l'uso sicuro dei membri del tipo (vincolare a un'interfaccia permette di chiamare i suoi metodi) che assicura l'uso corretto.
Comprendere le classi e i metodi generici, come funziona l'inferenza di tipo e i vincoli (class, struct, new(), vincoli di interfaccia/classe base) è necessario sia per utilizzare efficacemente le librerie .NET pesanti di generici che per scrivere i propri astrazione riusabili e type-safe.
Poiché i generici sono alla base delle collezioni di C# e di gran parte del framework, e poiché sono la chiave per il codice riusabile e type-safe, padroneggiare i generici e i vincoli è conoscenza centrale e frequentemente applicata per lo sviluppo C# efficace e un argomento comune che riflette la comprensione del design riusabile e type-safe.