Einführung in C # -Generics
Was ist das Konzept von Generics in C #? Mit einfachen Worten, es ist das Konzept, typunabhängige Klassen, Schnittstellen, Methoden, Delegaten, Eigenschaften usw. zu definieren. Dies bedeutet, dass Sie eine generische Klasse oder einen Methodenkörper definieren und den tatsächlichen Typ während des Aufrufs bereitstellen können.
Generics sind also wie Code-Templates. Mit ihnen können Sie einen typsicheren Codeblock schreiben, ohne sich auf einen bestimmten Datentyp zu beziehen. Der Typ Ihres Codes wird zur Kompilierungszeit während des Aufrufs für Ihre Klasse oder Methode festgelegt.
Syntax von Generika in C #
Betrachten wir die Syntax einer generischen Deklaration in C #. Es ist eine sehr einfache Syntax.
In der Regel kennzeichnet der Buchstabe "T" in der Groß- und Kleinschreibung in eckigen Klammern die Deklaration eines generischen Codes in C #. Dies ist jedoch nicht das Mandat. Jeder Buchstabe in Großbuchstaben in eckigen Klammern kann zur Bezeichnung eines generischen Codes verwendet werden.
Deklaration einer generischen Klasse:
public class MyGenericClass
Instanziieren einer generischen Klasse:
MyGenericClass = new MyGenericClass();
Deklarieren einer generischen abgeleiteten Klasse:
public class MyGenericDerivedClass : MyGenericBaseClass
Eine generische Methode deklarieren:
public T MyGenericMethod(T item);
Wie funktionieren Generika in C #?
Wenn Sie in C # einen generischen Code deklarieren, erstellt der Compiler eine diesem Code entsprechende Vorlage. Diese Vorlage wird auf alle Übersetzungsfehler mit Ausnahme der Typensicherheit überprüft. Der nächste Schritt kommt, wenn der generische Code in einem anderen Teil des Programms aufgerufen oder aufgerufen wird. Zum Zeitpunkt des Aufrufs geben Sie den Typ an, mit dem Ihr generischer Code kompiliert werden soll. Wenn der Compiler den Aufrufpunkt erreicht, fügt er den in der zuvor kompilierten Vorlage angegebenen Typ ein. Dies wird dann neu kompiliert, um die Typensicherheit zu überprüfen. Nach der Übergabe ist der Code zur Ausführung bereit.
Wir würden den kompilierten Code in den folgenden Beispielen sehen, um ein besseres Verständnis der generischen Vorlagen zu erhalten.
Beispiel für Generika in C #
Nachfolgend sind die verschiedenen Beispiele für C # -Generics aufgeführt:
Generika mit Klasse
Code:
using System;
using System.Collections.Generic;
public class GenericClass
(
List genericList;
public GenericClass()
(
genericList = new List();
)
public void AddToList(T item)
(
genericList.Add(item);
)
public void DisplayList()
(
foreach (var ele in genericList)
(
Console.Write("(0)\t", ele);
)
)
)
public class Program
(
public static void Main()
(
GenericClass intGenericObj = new GenericClass();
GenericClass stringGenericObj = new GenericClass();
intGenericObj.AddToList(28);
intGenericObj.AddToList(999);
intGenericObj.AddToList(0);
intGenericObj.AddToList(-123);
intGenericObj.AddToList(100);
stringGenericObj.AddToList("Hello");
stringGenericObj.AddToList("Bonjour");
stringGenericObj.AddToList("Ola");
stringGenericObj.AddToList("Ciao");
stringGenericObj.AddToList("Hallo");
intGenericObj.DisplayList();
Console.WriteLine("\n");
stringGenericObj.DisplayList();
))
Ausgabe:
Derselbe Code kann auch wie folgt umgeschrieben werden. Dies zeigt die Fähigkeit, eine generische Klasse zu definieren, die für mehrere Typen in einem einzelnen Objekt typsicher gemacht werden kann.
using System;
using System.Collections.Generic;
public class GenericClass
(
List genericList1;
List genericList2;
public GenericClass()
(
genericList1 = new List();
genericList2 = new List();
)
public void AddToList(T item1, U item2)
(
genericList1.Add(item1);
genericList2.Add(item2);
)
public void DisplayList()
(
foreach (var ele in this.genericList1)
(
Console.Write("(0)\t", ele);
)
Console.WriteLine("\n");
foreach (var ele in this.genericList2)
(
Console.Write("(0)\t", ele);
)
)
)
public class Program
(
public static void Main()
(
GenericClass genericObj = new GenericClass();
genericObj.AddToList(28, "Hello");
genericObj.AddToList(999, "Bonjour");
genericObj.AddToList(0, "Ola");
genericObj.AddToList(-123, "Ciao");
genericObj.AddToList(100, "Hallo");
genericObj.DisplayList();
)
)
Ausgabe:
Kompilierter Code:
Um eine Perspektive zu erhalten, wie der Datentyp in Generics aufgelöst wird, betrachten wir den kompilierten Code, der generiert wird, wenn wir die Klasse im obigen Beispiel mit Integer- und String-Typen instanziieren.
using System;
using System.Collections.Generic;
public class GenericClass
(
List genericList1;
List genericList2;
public GenericClass()
(
genericList1 = new List();
genericList2 = new List();
)
public void AddToList(int item1, string item2)
(
genericList1.Add(item1);
genericList2.Add(item2);
)
public void DisplayList()
(
foreach (var ele in this.genericList1)
(
Console.Write("(0)\t", ele);
)
Console.WriteLine("\n");
foreach (var ele in this.genericList2)
(
Console.Write("(0)\t", ele);
)
)
)
public class Program
(
public static void Main()
(
GenericClass genericObj = new GenericClass();
genericObj.AddToList(28, "Hello");
genericObj.AddToList(999, "Bonjour");
genericObj.AddToList(0, "Ola");
genericObj.AddToList(-123, "Ciao");
genericObj.AddToList(100, "Hallo");
genericObj.DisplayList();
)
)
Generika mit Methode
Code:
using System;
using System.Collections.Generic;
public class Program
(
public static void Main()
(
int() intArr = (12, 23, 43, 94, 35);
double() doubleArr = (12.3, 45.6, 98.7, 1.45, 82.653);
string() strArr = ("Hello", "Bonjour", "Ola", "Ciao", "Hallo");
Console.WriteLine("The largest integer in the array is (0)", findMax(intArr));
Console.WriteLine("The largest floating-point number in the array is (0)", findMax(doubleArr));
Console.WriteLine("The largest string in the array is (0)", findMax(strArr));
)
static T findMax(T() items)
where T : IComparable
(
T max = items(0);
int position = 0;
for (int i = 1; i < items.Length; i++)
(
if (items(i).CompareTo(max) > 0)
(
max = items(i);
position = i;
)
)
return max;
)
)
Ausgabe:
Der System.Collections.Generic-Namespace
Der System.Collections.Generic-Namespace in C # enthält Schnittstellen und Klassen, die die generischen Auflistungen definieren. Sie ermöglichen es den Programmierern, generische Sammlungen zu erstellen, die leistungsstärker und typstarker sind als die nicht generischen Sammlungen.
Dieser Namespace enthält Listen, Wörterbücher, verknüpfte Listen, Hashes, Schlüsselwertpaare, Stapel usw., die alle allgemeiner Natur sind. Die Programmierer können sie in ihren Code implementieren.
Bedeutung von C # -Generika
Im Folgenden wird die Bedeutung von C # -Generika wie folgt dargestellt:
- Generika ermöglichen die Wiederverwendbarkeit von Code: das Grundprinzip einer guten Programmierung. Sie müssen nicht für jeden erwarteten Datentyp den gleichen Code schreiben. Sie definieren einfach einen typunabhängigen Code und teilen dem Compiler mit, dass der tatsächliche Datentyp zum Zeitpunkt des Codeaufrufs bereitgestellt wird.
- Vermeiden Sie die Kosten für das Ein- und Auspacken: Natürlich kann die Verwendung von Generika durch die Objektklasse umgangen werden. Die folgenden zwei Codeteile sind in ihren Aufgaben gleichwertig.
Allgemeiner Code: public T MyFunc (T item);
Nicht generischer Code: öffentliches Objekt MyFunc (Objektelement)
Die Objektklasse ersetzt alle Klassen und daher kann der oben genannte nicht generische Code auch zum Generieren typunabhängiger Codevorlagen verwendet werden.
Es besteht jedoch eine große Leistungslücke zwischen den beiden Codes. Die Verwendung der Objektklasse verursacht zusätzliche Kosten für das Ein- und Auspacken der Datentypen. Generika beseitigen dies und sind somit leistungsfähiger.
Fazit
So haben wir gesehen, wie Generika ein Muss für Programmierer sind. Dies ist ein äußerst nützliches Konzept, nicht nur in C #, sondern in den meisten modernen Programmiersprachen.
Darüber hinaus wird dringend empfohlen, sich mit dem System.Collections.Generic-Namespace in C # vertraut zu machen. Um die Leistung von Generika zu verstehen, sollten Sie sich eingehend damit befassen, wie sich Boxing und Unboxing auf das Gedächtnis und die Ausführungszeit auswirken.
Empfohlene Artikel
Dies ist eine Anleitung zu C # -Generics. Hier diskutieren wir Wichtigkeit und Funktionsweise von Generika in C # zusammen mit verschiedenen Beispielen und der Implementierung von Code. Sie können auch unsere anderen Artikelvorschläge durchgehen, um mehr zu erfahren -
- Kopf-an-Kopf-Vergleich von C # oder Operator
- Überladen und Überschreiben in Java
- Was ist die Verwendung von Methodenüberladung?
- Wie funktioniert Sealed Class in C #?
- Typen und Fehlerbehandlung in JavaScript
- PL / SQL-Sammlungen | Syntax, Typen, Ausnahmen