Eine kurze Analyse der Anwendung von generischen C#-Sammlungsinstanzen

Bevor wir generische C#-Sammlungen verstehen, verstehen wir, dass Sammlungen ein wichtiges Konzept in OOP sind und dass die umfassende Unterstützung für Sammlungen in C# eine der Essenzen der Sprache ist. C#-Generika sind ein neues Element in C# 2.0 (in C++ Vorlagen genannt), das hauptsächlich zur Lösung einer Reihe ähnlicher Probleme verwendet wird. Dieser Mechanismus ermöglicht die Übergabe eines Klassennamens als Parameter an einen generischen Typ und die Erzeugung des entsprechenden Objekts. Es ist möglicherweise besser, sich Generika (einschließlich Klassen, Schnittstellen, Methoden, Delegaten usw.) als Vorlagen vorzustellen. Der Variantenteil in der Vorlage wird durch den als Parameter übergebenen Klassennamen ersetzt, wodurch eine neue Typdefinition erhalten wird. Generika sind ein relativ umfangreiches Thema und werden hier nicht im Detail analysiert. Interessierte können entsprechende Informationen einsehen.

Die generische Sammlungsklasse von C# ist sehr praktisch und schnell zu verwenden. In diesem Aufsatz werde ich eine verknüpfte Liste verwenden, um das Verhalten der List﹤T﹥-Klasse in C# zu simulieren. Lassen Sie uns ohne weiteres einen Blick auf meinen Implementierungscode werfen. Kommentare wurden bereits in den Code geschrieben, daher ist kein zusätzlicher Code erforderlich wird hinzugefügt. Beschreibung:

using System.Collections;
class MyList﹤T﹥
{
PRivate MyListNode firstNode;//Erster Knoten
private int count;//C# generische Sammlung -Node count
public MyList()
{
this.firstNode = null;
this.count = 0;
}
//C# Generic Collection-Get Listenlänge
public int GetLength()
{
return this.count;
}
//Einen Knoten hinzufügen
public void AddElement(T data)
{
MyListNode first = this.firstNode;
if(first==null)
{
this.firstNode=new MyListNode(data);
this.count++;
return;
}
while (first.next != null)
{
first = first.next;
}
first.next = new MyListNode(data);
this.count++;
}
//Generische C#-Sammlung – einen Knoten löschen
public bool Remove(T data)
{
MyListNode first = this.firstNode;
if (first.data.Equals(data ))
{
this.firstNode = first.next;
this.count--;
return true;
}
while (first.next!=null)
{
if (first.next.data.Equals(data))
{
first.next = first.next.next;
this.count--;
return true;
}
}
return false;
}
//C# Generische Sammlung – Holen Sie sich das Sammlungselement am angegebenen Index
public T GetAtIndex(int ​​​​index)
{
int innercount = 1;
MyListNode first = this.firstNode;
if (index ﹥ count)
{
throw new Exception("Index out of limits");
}
; else
{
while (innercount ﹤ index)
{
first = first.next;
innercount++;
}
return first.data;
}
}
//Ein neues Element am angegebenen Index einfügen
public void InsertAtIndex(int ​​​​index,T data)
{
int innercount = 1;
MyListNode first = this.firstNode;
if (index ﹥ count)
{
throw new Exception("Index out of limits");
}
if (index == 1)
{
this.firstNode = new MyListNode(data);
this.firstNode.next = first;
}
else
{
while (innercount ﹤ index - 1)
{
first = first.next;
innercount++;
}
MyListNode newNode = new MyListNode(data);
newNode.next = first.next;
first.next = newNode ;
}
this.count++;
}
//C# Generische Sammlung – Löschen Sie das Sammlungselement am angegebenen Index
public void RemoveAtIndex(int ​​​​index)
{
int innercount = 1;
MyListNode first = this.firstNode;
if (index ﹥ count)
{
throw new Exception("Index out of limits");
}
if (index == 1)
{
this.firstNode = first.next;
}
else
{
while (innercount ﹤ index - 1)
{
First = First.next; 🎜> //C# Generic Collection – Alle Elemente in der Sammlung entfernen
public void RemoveAll()
{
this.firstNode = null;
this.count = 0;
}
//Um diese Sammlungsklasse zu implementieren, kann foreach verwendet werden, um
public IEnumerator GetEnumerator()
{
MyListNode first = this.firstNode;
while (first!= null)
zu durchlaufen {
> yield return first.data;
first = first.next;
}
}
//Internal node class
private class MyListNode
{
public T data { get ; set; }//Der Elementwert auf dem Knoten

public MyListNode { get; > {
this .data = nodeData;
this.next = null;
}
}
}

Im Folgenden wird die Verwendung dieser Simulationsklasse durch C#-Generika beschrieben Sammlung:

class Program
{
static void Main(string[] args)
{
MyList﹤string﹥ ml = new MyList﹤string﹥();
ml.AddElement("xu" );
ml.AddElement("jin");
ml.AddElement("lin");
ml.AddElement("love");
ml. AddElement("jasmine");
ml.InsertAtIndex(4, "fiercely");
ml.RemoveAtIndex(2);
ml.Remove("lin");
foreach (string s in ml)
{
Console.WriteLine(s);
}
}

Dies ist der grundlegende Inhalt der generischen C#-Sammlungsinstanzanwendung kann es verstehen und daraus lernen. C#-Sammlungen helfen.

Das Obige ist eine kurze Analyse der generischen C#-Sammlungsinstanzanwendung. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).