C# - Generika

Generika erlauben Ihnen, die Spezifikation des Datentyps von Programmierelementen in einer Klasse oder einer Methode zu definieren, bis dieser tatsächlich im Programm verwendet wird. Mit anderen Worten, Generika ermöglichen es Ihnen, eine Klasse oder Methode zu schreiben, die mit jedem Datentyp arbeiten kann.

Sie schreiben die Spezifikationen für die Klasse oder die Methode mit Ersatzparametern für Datentypen. Wenn der Compiler auf einen Konstruktor für die Klasse oder einen Funktionsaufruf für die Methode trifft, generiert er Code zur Behandlung des spezifischen Datentyps. Ein einfaches Beispiel würde helfen, das Konzept zu verstehen −

Live-Demo

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) {
         
         //declaring an int array
         MyGenericArray<int> intArray = new MyGenericArray<int>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            intArray.setItem(c, c*5);
         }
         
         //retrieving the values
         for (int c = 0; c < 5; c++) {
            Console.Write(intArray.getItem(c) + " ");
         }
         
         Console.WriteLine();
         
         //declaring a character array
         MyGenericArray<char> charArray = new MyGenericArray<char>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            charArray.setItem(c, (char)(c+97));
         }
         
         //retrieving the values
         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 das folgende Ergebnis −

0 5 10 15 20
a b c d e

Merkmale von Generika

Generics ist eine Technik, die Ihre Programme auf folgende Weise bereichert −

• Es hilft Ihnen, die Wiederverwendung von Code, die Typsicherheit und die Leistung zu maximieren.

• Sie können generische Sammlungsklassen erstellen. Die .NET Framework-Klassenbibliothek enthält mehrere neue generische Sammlungsklassen in System.Collections.Generic Namensraum. Sie können diese generischen Sammlungsklassen anstelle der Sammlungsklassen in System.Collections verwenden Namensraum.

• Sie können Ihre eigenen generischen Schnittstellen, Klassen, Methoden, Ereignisse und Delegaten erstellen.

• Sie können generische Klassen erstellen, die eingeschränkt sind, um den Zugriff auf Methoden für bestimmte Datentypen zu ermöglichen.

• Sie können Informationen über die in einem generischen Datentyp verwendeten Typen zur Laufzeit durch Reflektion erhalten.

Generische Methoden

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

Live-Demo

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';
         
         //display values before swap:
         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);
         
         //call swap
         Swap<int>(ref a, ref b);
         Swap<char>(ref c, ref d);
         
         //display values after swap:
         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 das folgende 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 Delegaten

Sie können einen generischen Delegaten mit Typparametern definieren. Zum Beispiel −

delegate T NumberChanger<T>(T n);

Das folgende Beispiel zeigt die Verwendung dieses Delegaten −

Live-Demo

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) {
         //create delegate instances
         NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
         NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
         
         //calling the methods using the delegate objects
         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 das folgende Ergebnis −

Value of Num: 35
Value of Num: 175