Klasy ogólne i metody

Typy ogólne wprowadza pojęcie parametrów typu do platformy .NET. Typy ogólne umożliwiają projektowanie klas i metod odroczenia specyfikacji co najmniej jednego parametru typu do momentu użycia klasy lub metody w kodzie. Na przykład przy użyciu ogólnego parametru Ttypu można napisać pojedynczą klasę, której może używać inny kod klienta bez ponoszenia kosztów lub ryzyka rzutowania środowiska uruchomieniowego lub operacji boksu, jak pokazano poniżej:

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

Klasy ogólne i metody łączą możliwość ponownego wykorzystania, bezpieczeństwo typów i wydajność w taki sposób, że ich niegeneryczne odpowiedniki nie mogą. Parametry typu ogólnego są zastępowane argumentami typu podczas kompilacji. W poprzednim przykładzie kompilator zastępuje element Tint. Typy ogólne są najczęściej używane z kolekcjami i metodami, które na nich działają. System.Collections.Generic Przestrzeń nazw zawiera kilka klas kolekcji opartych na rodzajach. Kolekcje niegeneryczne, takie jak ArrayList nie są zalecane i są przechowywane tylko w celach zgodności. Aby uzyskać więcej informacji, zobacz Generics in .NET (Typy ogólne na platformie .NET).

Można również utworzyć niestandardowe typy ogólne i metody, aby zapewnić własne uogólnione rozwiązania i wzorce projektowe, które są bezpieczne i wydajne. Poniższy przykład kodu przedstawia prostą ogólną klasę listy połączonej do celów demonstracyjnych. (W większości przypadków należy użyć klasy udostępnionej przez platformę List<T> .NET zamiast tworzyć własne). Parametr T typu jest używany w kilku lokalizacjach, w których typ betonowy zwykle będzie używany do wskazania typu elementu przechowywanego na liście:

• Jako typ parametru metody w metodzie AddHead .
• Jako zwracany Data typ właściwości w zagnieżdżonej Node klasie.
• Jako typ składowej prywatnej data w zagnieżdżonej klasie.

T jest dostępny dla klasy zagnieżdżonej Node . Gdy GenericList<T> wystąpienie jest tworzone przy użyciu konkretnego typu, na przykład jako GenericList<int>, każde wystąpienie T elementu jest zastępowane elementem 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;
        }
    }
}

Poniższy przykład kodu pokazuje, jak kod klienta używa klasy ogólnej GenericList<T> do utworzenia listy liczb całkowitych. Jeśli zmienisz argument typu, poniższy kod tworzy listy ciągów lub dowolnego innego typu niestandardowego:

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

Uwaga

Typy ogólne nie są ograniczone do klas. Powyższe przykłady używają class typów, ale można zdefiniować typy ogólne interface i struct typy, w tym record typy.

Omówienie typów ogólnych

• Użyj typów ogólnych, aby zmaksymalizować ponowne użycie kodu, bezpieczeństwo typów i wydajność.
• Najczęstszym zastosowaniem typów ogólnych jest tworzenie klas kolekcji.
• Biblioteka klas platformy .NET zawiera kilka ogólnych klas kolekcji w System.Collections.Generic przestrzeni nazw. Kolekcje ogólne powinny być używane zawsze, gdy jest to możliwe, zamiast klas, takich jak ArrayList w System.Collections przestrzeni nazw.
• Możesz utworzyć własne interfejsy ogólne, klasy, metody, zdarzenia i delegaty.
• Klasy ogólne można ograniczyć, aby umożliwić dostęp do metod dla określonych typów danych.
• Informacje w czasie wykonywania można uzyskać na typach używanych w typie danych ogólnych przy użyciu odbicia.

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#.

Zobacz też

• Typy ogólne na platformie .NET
• System.Collections.Generic