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 item) { }
}

public class ExampleClass { }

class TestGenericList
{
    static void Main()
    {
        // Create a list of type int.
        GenericList<int> list1 = new();
        list1.Add(1);

        // Create a list of type string.
        GenericList<string> list2 = new();
        list2.Add("");

        // Create a list of type ExampleClass.
        GenericList<ExampleClass> list3 = new();
        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, and
    // holds a data item of type T.
    private class Node(T t)
    {
        // T as property type.
        public T Data { get; set; } = t;

        public Node? Next { get; set; }
    }

    // First item in the linked list
    private Node? head;

    // T as parameter type.
    public void AddHead(T t)
    {
        Node n = new(t);
        n.Next = head;
        head = n;
    }

    // T in method return type.
    public IEnumerator<T> GetEnumerator()
    {
        Node? current = head;

        while (current is not 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:

// A generic list of int.
GenericList<int> list = new();

// Add ten int values.
for (int x = 0; x < 10; x++)
{
    list.AddHead(x);
}

// Write them to the console.
foreach (int i in list)
{
    Console.WriteLine(i);
}

Console.WriteLine("Done");

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