Einführung in Generika (C#-Programmierhandbuch)

Generische Klassen und Methoden kombinieren Wiederverwendbarkeit, Typsicherheit und Effizienz auf eine Weise, wie es für ihre nicht generischen Äquivalente unmöglich ist. Generika werden am häufigsten bei Auflistungen und den Methoden zu ihrer Bearbeitung verwendet. Version 2.0 der .NET Framework-Klassenbibliothek stellt den neuen Namespace System.Collections.Generic bereit, der mehrere neue, auf Generika basierende Auflistungsklassen enthält. Alle Anwendungen, die mit .NET Framework 2.0 oder höher arbeiten, sollten an Stelle ihrer älteren nicht generischen Entsprechungen (z. B. ArrayList) die neuen generischen Auflistungsklassen verwenden. Weitere Informationen finden Sie unter Generika in der .NET Framework-Klassenbibliothek (C#-Programmierhandbuch).

Natürlich können Sie auch benutzerdefinierte generische Typen und Methoden erstellen, um eigene typsichere und effiziente Lösungen und Entwurfsmuster bereitzustellen. Im folgenden Codebeispiel wird zu Demonstrationszwecken eine einfache generische Klasse mit verknüpfter Liste gezeigt. (In den meisten Fällen ist es ratsam, die List-Klasse aus der .NET Framework-Klassenbibliothek zu verwenden, anstatt eine eigene Klasse zu schreiben.) Der Typparameter T wird an mehreren Stellen verwendet, an denen der Typ des in der Liste gespeicherten Elements normalerweise durch einen konkreten Typ angegeben wird. Er wird auf folgende Arten verwendet:

• Als Typ eines Methodenparameters in der AddHead-Methode.

• Als Rückgabetyp der öffentlichen GetNext-Methode und der Data-Eigenschaft in der geschachtelten Node-Klasse.

• Als Typ der privaten Memberdaten in der geschachtelten Klasse.

Beachten Sie, dass T in der geschachtelten Node-Klasse verfügbar ist. Wenn GenericList<T> mit einem konkreten Typ instanziiert wird (beispielsweise als GenericList<int>), wird jedes Vorkommen von T durch int ersetzt.

// 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;
        }
    }
}

Im folgenden Codebeispiel wird veranschaulicht, wie in Clientcode mithilfe der generischen GenericList<T>-Klasse eine Liste mit ganzen Zahlen erstellt wird. Allein durch Änderung des Typarguments kann der folgende Code auf einfache Weise für die Erstellung von Zeichenfolgenlisten oder Listen beliebiger benutzerdefinierter Typen angepasst werden:

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");
    }
}

Siehe auch

Referenz

Generika (C#-Programmierhandbuch)

System.Collections.Generic

Konzepte

C#-Programmierhandbuch