C# Generics erklärt: Flexibler, typsicherer Code für jeden Datentyp

Was sind Generics in C#?

Generics ermöglichen es Ihnen, die Spezifikation des Datentyps von Programmierungselementen in einer Klasse oder Methode zu definieren, bis diese tatsächlich im Programm verwendet werden. Anders ausgedrückt: Generics erlauben es Ihnen, eine Klasse oder Methode zu schreiben, die mit jedem Datentyp funktionieren kann.

Sie schreiben die Spezifikationen für die Klasse oder Methode mit Ersatzparametern für Datentypen. Wenn der Compiler auf einen Konstruktor für die Klasse oder einen Funktionsaufruf für die Methode stößt, generiert er Code für den spezifischen Datentyp. Ein einfaches Beispiel veranschaulicht das Konzept:

using System;
using System.Collections.Generic;
namespace GenericApplication {
    public class MyGenericArray<T> {
        private T[] array;
        public MyGenericArray(int size) {
            array = new T[size + 1];
        }
        public T getItem(int index) {
            return array[index];
        }
        public void setItem(int index, T value) {
            array[index] = value;
        }
    }
    class Tester {
        static void Main(string[] args) {
            // int-Array deklarieren
            MyGenericArray<int> intArray = new MyGenericArray<int>(5);
            // Werte setzen
            for (int c = 0; c < 5; c++) {
                intArray.setItem(c, c * 5);
            }
            // Werte abrufen
            for (int c = 0; c < 5; c++) {
                Console.Write(intArray.getItem(c) + " ");
            }
            Console.WriteLine();
            // char-Array deklarieren
            MyGenericArray<char> charArray = new MyGenericArray<char>(5);
            // Werte setzen
            for (int c = 0; c < 5; c++) {
                charArray.setItem(c, (char)(c + 97));
            }
            // Werte abrufen
            for (int c = 0; c < 5; c++) {
                Console.Write(charArray.getItem(c) + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er folgendes Ergebnis:

0 5 10 15 20 a b c d e

Merkmale von Generics

Generics bereichern Ihre Programme auf folgende Weise:

• Maximale Wiederverwendbarkeit von Code, Typsicherheit und Performance.

• Erstellung generischer Auflistungsklassen. Die .NET Framework-Klassenbibliothek enthält mehrere neue generische Auflistungsklassen im System.Collections.Generic-Namespace, die statt der Klassen in System.Collections verwendet werden können.

• Erstellung eigener generischer Interfaces, Klassen, Methoden, Events und Delegates.

• Generische Klassen mit Constraints (Einschränkungen), um Zugriff auf Methoden bestimmter Datentypen zu ermöglichen.

• Laufzeitinformationen über die in einem generischen Datentyp verwendeten Typen durch Reflection.

Generische Methoden

Im vorherigen Beispiel haben wir eine generische Klasse verwendet; wir können auch eine generische Methode mit einem Typparameter deklarieren. Das folgende Programm veranschaulicht das Konzept:

using System;
using System.Collections.Generic;
namespace GenericMethodAppl {
    class Program {
        static void Swap<T>(ref T lhs, ref T rhs) {
            T temp;
            temp = lhs;
            lhs = rhs;
            rhs = temp;
        }
        static void Main(string[] args) {
            int a, b;
            char c, d;
            a = 10; b = 20;
            c = 'I'; d = 'V';
            // Werte vor dem Tausch anzeigen
            Console.WriteLine("Int values before calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values before calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);
            // Tausch aufrufen
            Swap<int>(ref a, ref b);
            Swap<char>(ref c, ref d);
            // Werte nach dem Tausch anzeigen
            Console.WriteLine("Int values after calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values after calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er folgendes Ergebnis:

Int values before calling swap: a = 10, b = 20
Char values before calling swap: c = I, d = V
Int values after calling swap: a = 20, b = 10
Char values after calling swap: c = V, d = I

Generische Delegates

Sie können einen generischen Delegate mit Typparametern definieren. Zum Beispiel:

delegate T NumberChanger<T>(T n);

Das folgende Beispiel zeigt die Verwendung dieses Delegates:

using System;
using System.Collections.Generic;
delegate T NumberChanger<T>(T n);
namespace GenericDelegateAppl {
    class TestDelegate {
        static int num = 10;
        public static int AddNum(int p) { num += p; return num; }
        public static int MultNum(int q) { num *= q; return num; }
        public static int getNum() { return num; }
        static void Main(string[] args) {
            NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
            NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
            nc1(25);
            Console.WriteLine("Value of Num: {0}", getNum());
            nc2(5);
            Console.WriteLine("Value of Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er folgendes Ergebnis:

Value of Num: 35
Value of Num: 175