Általános osztályok és metódusok

  • Cikk

A Generics bevezeti a típusparaméterek fogalmát a .NET-be. Az általánosak lehetővé teszik olyan osztályok és metódusok tervezését, amelyek egy vagy több típusparaméter specifikációját késleltetik, amíg az osztályt vagy metódust nem használja a kódban. Például egy általános típusparaméter Thasználatával egyetlen osztályt írhat, amelyet más ügyfélkódok használhatnak anélkül, hogy a futtatókörnyezeti leadások vagy a boxing műveletek költségei vagy kockázata merült volna fel, ahogy az itt látható:

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

Az általános osztályok és módszerek úgy kombinálják az újrafelhasználhatóságot, a típusbiztonságot és a hatékonyságot, hogy nemgeneratív társaik nem tudják. Az általános típusparamétereket a rendszer a fordítás során a típusargumentumokra cseréli. Az előző példában a fordító a következőre cseréli a következőt Tint: . Az általános generikus elemeket leggyakrabban a gyűjteményekhez és a rajtuk működő metódusokhoz használják. A System.Collections.Generic névtér több általános alapú gyűjteményosztályt tartalmaz. A nemgenerikus gyűjtemények, például ArrayList nem ajánlottak, és csak kompatibilitási célból vannak fenntartva. További információ: Generics in .NET.

Egyéni általános típusokat és metódusokat is létrehozhat, hogy saját, általánosított megoldásokat és tervezési mintákat biztosítson, amelyek típusbiztosak és hatékonyak. Az alábbi példakód egy egyszerű, általános csatolt listaosztályt mutat be bemutató célokra. (A legtöbb esetben a List<T> .NET által biztosított osztályt kell használnia a saját létrehozása helyett.) A típusparamétert T több helyen használják, ahol általában egy konkrét típust használnak a listában tárolt elem típusának jelzésére:

  • Metódusparaméter típusaként a AddHead metódusban.
  • A beágyazott Node osztály tulajdonságának Data visszatérési típusaként.
  • A beágyazott osztály magántagjának data típusaként.

T a beágyazott Node osztály számára érhető el. Amikor GenericList<T> egy konkrét típussal, például GenericList<int>egy konkrét típussal példányosítjuk, az egyes előfordulások T helyébe inta következő lép: .

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

Az alábbi példakód bemutatja, hogyan használja az ügyfélkód az általános GenericList<T> osztályt az egész számok listájának létrehozásához. Ha módosítja a típusargumentumot, a következő kód sztringlistákat hoz létre, vagy bármilyen más egyéni típust:

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

Feljegyzés

Az általános típusok nem korlátozódnak az osztályokra. Az előző példák típusokat használnak class , de általános interface és struct típusokat is definiálhat, beleértve a típusokat is record .

Általános szolgáltatások áttekintése

  • Általános típusokkal maximalizálhatja a kód újrafelhasználását, a típusbiztonságot és a teljesítményt.
  • Az általános eszközök leggyakoribb használata a gyűjteményosztályok létrehozása.
  • A .NET-osztálytár több általános gyűjteményosztályt tartalmaz a System.Collections.Generic névtérben. Az általános gyűjteményeket lehetőség szerint az olyan osztályok helyett kell használni, mint ArrayList például a System.Collections névtérben.
  • Létrehozhat saját általános felületeket, osztályokat, metódusokat, eseményeket és meghatalmazottakat.
  • Az általános osztályok korlátozhatók az egyes adattípusok metódusaihoz való hozzáférés engedélyezéséhez.
  • Az általános adattípusban használt típusokkal kapcsolatos információkat futtatáskor, tükröződés használatával szerezheti be.

C# nyelvspecifikáció

További információkért lásd a C# nyelvi specifikációját.

Lásd még