Obecné třídy a metody

  • Článek

Obecné typy představují koncept parametrů typu do .NET. Obecné typy umožňují navrhovat třídy a metody, které odvozují specifikaci jednoho nebo více parametrů typu, dokud v kódu nepoužijete třídu nebo metodu. Například pomocí parametru Tobecného typu můžete napsat jednu třídu, kterou může použít jiný kód klienta, aniž by se zabízly náklady nebo riziko operací přetypování za běhu nebo boxování, jak je znázorněno zde:

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

Obecné třídy a metody kombinují opakovaně použitelnost, bezpečnost typů a efektivitu způsobem, který jejich negenerické protějšky nemohou. Parametry obecného typu se během kompilace nahradí argumenty typu. V předchozím příkladu kompilátor nahradí T znakem int. Obecné typy se nejčastěji používají s kolekcemi a metodami, které s nimi pracují. Obor System.Collections.Generic názvů obsahuje několik obecných tříd kolekce. Negenerické kolekce, například ArrayList se nedoporučují a uchovávají se jenom pro účely kompatibility. Další informace naleznete v tématu Obecné typy v .NET.

Můžete také vytvořit vlastní obecné typy a metody, které poskytují vlastní generalizovaná řešení a vzory návrhu, které jsou typově bezpečné a efektivní. Následující příklad kódu ukazuje jednoduchou obecnou třídu propojeného seznamu pro demonstrační účely. (Ve většině případů byste měli místo vytváření vlastních prostředků použít List<T> třídu, kterou poskytuje .NET.) Parametr T typu se používá v několika umístěních, kde by byl obvykle použit konkrétní typ k označení typu položky uložené v seznamu:

  • Jako typ parametru metody v AddHead metodě.
  • Jako návratový Data typ vlastnosti ve vnořené Node třídě.
  • Jako typ soukromého člena data ve vnořené třídě.

T je k dispozici pro vnořenou Node třídu. Je-li GenericList<T> vytvořena instance s konkrétním typem, například jako , GenericList<int>každý výskyt T je nahrazen 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;
        }
    }
}

Následující příklad kódu ukazuje, jak klientský kód používá obecnou GenericList<T> třídu k vytvoření seznamu celých čísel. Pokud změníte argument typu, následující kód vytvoří seznamy řetězců nebo jiného vlastního typu:

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

Poznámka:

Obecné typy nejsou omezeny na třídy. Předchozí příklady používají class typy, ale můžete definovat obecné interface typy a struct typy včetně record typů.

Přehled obecných typů

  • Pomocí obecných typů můžete maximalizovat opakované použití kódu, bezpečnost typů a výkon.
  • Nejběžnějším použitím obecných typů je vytvoření tříd kolekce.
  • Knihovna tříd .NET obsahuje v oboru názvů několik obecných tříd System.Collections.Generic kolekce. Obecné kolekce by měly být použity, kdykoli je to možné, místo tříd, jako ArrayList je v System.Collections oboru názvů.
  • Můžete vytvořit vlastní obecná rozhraní, třídy, metody, události a delegáty.
  • Obecné třídy mohou být omezeny tak, aby umožňovaly přístup k metodám u konkrétních datových typů.
  • Informace o typech, které se používají v obecném datovém typu, můžete získat za běhu pomocí reflexe.

specifikace jazyka C#

Další informace najdete v tématu Specifikace jazyka C#.

Viz také