Generics (Guida per programmatori C#)Generics (C# Programming Guide)

I generics introducono il concetto di parametri di tipo in .NET, che rendono possibile la progettazione di classi e metodi che rinviano la specifica di uno o più tipi fino a quando la classe o il metodo non viene dichiarato e ne viene creata un'istanza dal codice client.Generics introduce the concept of type parameters to .NET, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code. Usando, ad esempio, un parametro di tipo generico T , è possibile scrivere una singola classe che può essere usata da un altro codice client senza sostenere il costo o il rischio di cast di runtime o di operazioni di conversione boxing, come illustrato di seguito:For example, by using a generic type parameter T, you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations, as shown here:

// Declare the generic class.
public class GenericList<T>
{
    public void Add(T input) { }
}
class TestGenericList
{
    private class ExampleClass { }
    static void Main()
    {
        // Declare a list of type int.
        GenericList<int> list1 = new GenericList<int>();
        list1.Add(1);

        // Declare a list of type string.
        GenericList<string> list2 = new GenericList<string>();
        list2.Add("");

        // Declare a list of type ExampleClass.
        GenericList<ExampleClass> list3 = new GenericList<ExampleClass>();
        list3.Add(new ExampleClass());
    }
}

Classi e metodi generici combinano riusabilità, indipendenza dai tipi ed efficienza in modo che non possano essere presenti controparti non generiche.Generic classes and methods combine reusability, type safety, and efficiency in a way that their non-generic counterparts cannot. I generics sono in genere usati con le raccolte e i metodi che operano su di essi.Generics are most frequently used with collections and the methods that operate on them. Lo System.Collections.Generic spazio dei nomi contiene diverse classi di raccolta basate su generiche.The System.Collections.Generic namespace contains several generic-based collection classes. Le raccolte non generiche, ad esempio, ArrayList non sono consigliate e vengono mantenute per motivi di compatibilità.The non-generic collections, such as ArrayList are not recommended and are maintained for compatibility purposes. Per altre informazioni, vedere Generics in .NET.For more information, see Generics in .NET.

Naturalmente, è anche possibile creare tipi e metodi generici personalizzati per offrire le proprie soluzioni e schemi progettuali generalizzati che sono indipendenti dai tipi ed efficienti.Of course, you can also create custom generic types and methods to provide your own generalized solutions and design patterns that are type-safe and efficient. Nell'esempio di codice riportato di seguito viene illustrata una classe di elenco collegato generica semplice a scopo dimostrativo.The following code example shows a simple generic linked-list class for demonstration purposes. Nella maggior parte dei casi, è consigliabile usare la List<T> classe fornita da .NET anziché crearne una personalizzata. Il parametro di tipo T viene usato in diverse posizioni in cui un tipo concreto viene normalmente usato per indicare il tipo di elemento archiviato nell'elenco.(In most cases, you should use the List<T> class provided by .NET instead of creating your own.) The type parameter T is used in several locations where a concrete type would ordinarily be used to indicate the type of the item stored in the list. In particolare, viene usato nei seguenti modi:It is used in the following ways:

  • Come tipo di un parametro del metodo nel metodo AddHead.As the type of a method parameter in the AddHead method.
  • Come tipo restituito della proprietà Data nella classe Node annidata.As the return type of the Data property in the nested Node class.
  • Come tipo del membro privato data nella classe annidata.As the type of the private member data in the nested class.

Si noti che T è disponibile per la Node classe annidata.Note that T is available to the nested Node class. Quando si crea un'istanza di GenericList<T> con un tipo concreto, ad esempio GenericList<int>, ogni occorrenza di T verrà sostituita con int.When GenericList<T> is instantiated with a concrete type, for example as a GenericList<int>, each occurrence of T will be replaced with int.

// type parameter T in angle brackets
public class GenericList<T>
{
    // The nested class is also generic on T.
    private class Node
    {
        // T used in non-generic constructor.
        public Node(T t)
        {
            next = null;
            data = t;
        }

        private Node next;
        public Node Next
        {
            get { return next; }
            set { next = value; }
        }

        // T as private member data type.
        private T data;

        // T as return type of property.
        public T Data
        {
            get { return data; }
            set { data = value; }
        }
    }

    private Node head;

    // constructor
    public GenericList()
    {
        head = null;
    }

    // T as method parameter type:
    public void AddHead(T t)
    {
        Node n = new Node(t);
        n.Next = head;
        head = n;
    }

    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;

        while (current != null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }
}

Nell'esempio di codice riportato di seguito viene illustrato come il codice client usa la classe generica GenericList<T> per creare un elenco di interi.The following code example shows how client code uses the generic GenericList<T> class to create a list of integers. Cambiando semplicemente l'argomento relativo al tipo, è possibile modificare il codice riportato di seguito per creare elenchi di stringhe o di qualsiasi altro tipo personalizzato:Simply by changing the type argument, the following code could easily be modified to create lists of strings or any other custom type:

class TestGenericList
{
    static void Main()
    {
        // int is the type argument
        GenericList<int> list = new GenericList<int>();

        for (int x = 0; x < 10; x++)
        {
            list.AddHead(x);
        }

        foreach (int i in list)
        {
            System.Console.Write(i + " ");
        }
        System.Console.WriteLine("\nDone");
    }
}

Cenni preliminari sui genericsGenerics overview

  • Usare i tipi generici per ottimizzare il riutilizzo del codice, l'indipendenza dai tipi e le prestazioni.Use generic types to maximize code reuse, type safety, and performance.
  • L'uso più comune dei generics consiste nel creare classi di raccolte.The most common use of generics is to create collection classes.
  • La libreria di classi .NET contiene varie classi di raccolte generiche nello System.Collections.Generic spazio dei nomi.The .NET class library contains several generic collection classes in the System.Collections.Generic namespace. Queste classi devono essere usate ogni volta che sia possibile al posto di classi come ArrayList nello spazio dei nomi System.Collections.These should be used whenever possible instead of classes such as ArrayList in the System.Collections namespace.
  • È possibile creare interfacce, classi, metodi, eventi e delegati generici.You can create your own generic interfaces, classes, methods, events, and delegates.
  • Le classi generiche possono essere limitate in modo da abilitare l'accesso ai metodi per particolari tipi di dati.Generic classes may be constrained to enable access to methods on particular data types.
  • Le informazioni sui tipi usati in un tipo di dati generico possono essere ottenute usando la reflection in fase di esecuzione.Information on the types that are used in a generic data type may be obtained at run-time by using reflection.

Specifiche del linguaggio C#C# language specification

Per ulteriori informazioni, vedere la specifica del linguaggio C#.For more information, see the C# Language Specification.

Vedere ancheSee also