Delen via

Algemene klassen en methoden

  • Artikel

Generics introduceert het concept van typeparameters voor .NET. Met generics kunt u klassen en methoden ontwerpen die de specificatie van een of meer typeparameters uitstellen totdat u de klasse of methode in uw code gebruikt. Met behulp van een algemene typeparameter Tkunt u bijvoorbeeld één klasse schrijven die andere clientcode kan gebruiken zonder de kosten of het risico van runtimecasts of boksbewerkingen te maken, zoals hier wordt weergegeven:

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

Algemene klassen en methoden combineren herbruikbaarheid, typeveiligheid en efficiëntie op een manier die hun niet-genrische tegenhangers niet kunnen. Algemene typeparameters worden vervangen door de typeargumenten tijdens de compilatie. In het voorgaande voorbeeld vervangt T de compiler door int. Generics worden het vaakst gebruikt met verzamelingen en de methoden die hierop werken. De System.Collections.Generic naamruimte bevat verschillende algemene verzamelingsklassen. De niet-genrische verzamelingen, zoals ArrayList niet aanbevolen en worden alleen onderhouden voor compatibiliteitsdoeleinden. Zie Generics in .NET voor meer informatie.

U kunt ook aangepaste algemene typen en methoden maken om uw eigen gegeneraliseerde oplossingen en ontwerppatronen te bieden die typeveilig en efficiënt zijn. In het volgende codevoorbeeld ziet u een eenvoudige algemene klasse voor gekoppelde lijsten voor demonstratiedoeleinden. (In de meeste gevallen moet u de List<T> klasse van .NET gebruiken in plaats van uw eigen klasse te maken.) De typeparameter T wordt gebruikt op verschillende locaties waar normaal gesproken een concreet type wordt gebruikt om het type item aan te geven dat in de lijst is opgeslagen:

  • Als het type methodeparameter in de AddHead methode.
  • Als retourtype van de Data eigenschap in de geneste Node klasse.
  • Als het type privélid data in de geneste klasse.

T is beschikbaar voor de geneste Node klasse. Wanneer GenericList<T> wordt geïnstantieerd met een concreet type, bijvoorbeeld als een GenericList<int>, wordt elk exemplaar T vervangen door 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;
        }
    }
}

In het volgende codevoorbeeld ziet u hoe clientcode gebruikmaakt van de algemene GenericList<T> klasse om een lijst met gehele getallen te maken. Als u het typeargument wijzigt, maakt de volgende code lijsten met tekenreeksen of een ander aangepast 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");
    }
}

Notitie

Algemene typen zijn niet beperkt tot klassen. In de voorgaande voorbeelden worden typen gebruikt class , maar u kunt algemene interface typen en struct typen definiëren, inclusief record typen.

Overzicht van generics

  • Gebruik algemene typen om het hergebruik van code, typeveiligheid en prestaties te maximaliseren.
  • Het meest voorkomende gebruik van generics is het maken van verzamelingsklassen.
  • De .NET-klassebibliotheek bevat verschillende algemene verzamelingsklassen in de System.Collections.Generic naamruimte. De algemene verzamelingen moeten waar mogelijk worden gebruikt in plaats van klassen zoals ArrayList in de System.Collections naamruimte.
  • U kunt uw eigen algemene interfaces, klassen, methoden, gebeurtenissen en gemachtigden maken.
  • Algemene klassen kunnen worden beperkt om toegang tot methoden voor bepaalde gegevenstypen in te schakelen.
  • U kunt tijdens runtime informatie verkrijgen over de typen die worden gebruikt in een algemeen gegevenstype door reflectie te gebruiken.

C#-taalspecificatie

Zie de C#-taalspecificatie voor meer informatie.

Zie ook