Sammlungen sind ein wichtiges Konzept in der OOP, und die vollständige Unterstützung von Sammlungen in C# gehört zu den besten der Sprache.
Warum generische Sets verwenden?
Vor C# 2.0 konnten Sammlungen auf zwei Hauptarten implementiert werden:
a. ArrayList verwenden
Objekte direkt in die ArrayList einzufügen ist intuitiv, aber da die Objekte in der Sammlung vom Typ Objekt sind, muss man bei jeder Nutzung mühsame Typumrechnungen durchführen.
b. Verwenden Sie benutzerdefinierte Sammlungsklassen
Eine gängige Praxis ist es, eine benutzerdefinierte Klasse aus der abstrakten CollectionBase-Klasse zu erben und eine starke Typsammlung zu implementieren, indem das IList-Objekt gekapselt wird. Diese Methode erfordert das Schreiben einer entsprechenden benutzerdefinierten Klasse für jeden Sammlungstyp, was viel Arbeit ist. Das Entstehen generischer Sammlungen löst die oben genannten Probleme gut, und nur eine Codezeile kann verwendet werden, um eine Menge eines bestimmten Typs zu erstellen. Was ist generisch?
Generika sind neue Elemente in C# 2.0 (in C++ als Vorlagen bezeichnet), die hauptsächlich zur Lösung einer Reihe ähnlicher Probleme verwendet werden. Dieser Mechanismus erlaubt es, den Klassennamen als Argument an den generischen Typ weiterzugeben und das entsprechende Objekt zu erzeugen. Es ist vielleicht besser, generische Varianten (einschließlich Klassen, Schnittstellen, Methoden, Delegierte usw.) als Vorlagen zu betrachten, bei denen der Variantenteil durch den Klassennamen ersetzt wird, der als Argument weitergegeben wird, was zu einer neuen Typdefinition führt. Generisches Thema ist ein relativ großes Thema, und ich werde es hier nicht im Detail analysieren; Interessierte können die relevanten Informationen konsultieren. Wie erstelle ich eine generische Kollektion?
Die Generic Klasse List unter System.Collections.Generic <T>wird verwendet, um Sammlungen zu erstellen, und die Syntax ist wie folgt: [mw_shl_code=csharp, wahr] List<T> ListOfT = neue List<T>(); [/mw_shl_code] Das "T" ist der zu verwendende Typ, der einfache Typen wie String, int oder benutzerdefinierte Typen sein kann. Schauen wir uns ein konkretes Beispiel an.
Die Person-Klasse ist wie folgt definiert: [mw_shl_code=csharp, true]Klassenperson
{
private String-_name; Name
Private Int _age; Alter
Erstelle ein Person-Objekt
öffentliche Person (Stringname, Int Alter)
{
this._name= Name;
this._age = Alter;
}
Name
öffentlicher Stringname
{
get { return _name; }
}
Alter
öffentliches Int Alter
{
get { return _age; }
}
}
//创建Person对象
Person p1 = neue Person ("Zhang San", 30);
Person p2 = neue Person ("Li Si", 20);
Person p3 = neue Person ("Wang Wu", 50);
//创建类型为Person的对象集合
Listenpersonen<Person> = neue Liste<Person>();
//将Person对象放入集合
Personen. Add(p1);
Personen. Add(p2);
Personen. Add(p3);
//输出第2个人的姓名
Console.Write(persons[1]. Name); [/mw_shl_code] Wie Sie sehen, vereinfachen generische Sammlungen den Implementierungscode der Sammlungen erheblich, durch den man leicht Sammlungen bestimmter Typen erstellen kann. Nicht nur das, sondern generische Sammlungen bieten auch leistungsfähigere Funktionen – schauen wir uns die Sortierung und Suche darin an. Sortierung generischer Sammlungen
Das Sortieren basiert auf Vergleich, und um zu sortieren, muss man zuerst vergleichen. Wenn es zum Beispiel zwei Zahlen 1 und 2 gibt, müssen wir sie zunächst vergleichen und nach den Vergleichsergebnissen sortieren. Wenn du Objekte vergleichen willst, ist die Situation etwas komplizierter, zum Beispiel kannst du Person-Objekte nach Namen oder Alter vergleichen, was die Vergleichsregeln erfordert. Ein Objekt kann mehrere Vergleichsregeln haben, aber nur eine Standardregel, die in die Klasse gelegt wird, die das Objekt definiert. Die Standardvergleichsregeln sind in der CompareTo-Methode definiert, die zur <T>IComparable-generischen Schnittstelle gehört. Siehe den Code unten: [mw_shl_code=csharp, true]Klasse Person :IComparable<Person>
{
Altersvergleich
öffentliche int CompareTo(Person p)
{
Gib das zurück. Alter – p.Alter;
}
}[/mw_shl_code] Die Parameter der CompareTo-Methode sind ein weiteres Objekt desselben Typs, mit dem verglichen werden muss; der Rückgabewert ist vom Typ int; wenn der Rückgabewert größer als 0 ist, bedeutet das, dass das erste Objekt größer als das zweite Objekt ist, wenn der Rückgabewert kleiner als 0 ist, bedeutet das, dass das erste Objekt kleiner als das zweite Objekt ist, und wenn es 0 zurückgibt, sind die beiden Objekte gleich.
Nachdem Sie die Standardvergleichsregeln definiert haben, können Sie die Sammlung mit der Sort-Methode ohne Parameter wie folgt sortieren: [mw_shl_code=csharp, true]// Sortiere die Sammlung nach den Standardregeln
Personen. Sort();
//输出所有人姓名
foreach (Person p in Personen)
{
Console.WriteLine(p.Name); Die Ausgabereihenfolge lautet "Li Si", "Zhang San" und "Wang Wu"
}[/mw_shl_code] In der Praxis ist es oft notwendig, die Sammlung nach verschiedenen Regeln zu sortieren, was die Definition weiterer Vergleichsregeln erfordert, die in der Vergleichsmethode definiert werden können, welche zur generischen IComparer-Schnittstelle gehört<T>; siehe folgenden Code: [mw_shl_code=csharp,true]-Klasse NameComparer : IComparer<Person>
{
Speichersequenzer-Instanzen
öffentliche statische NameComparer Default = neuer NameComparer();
Vergleichen Sie den Namen
öffentliche Intelligenz Vergleich(Person P1, Person P2)
{
return System.Collections.Comparer.Default.Compare(p1. Name, S. 2. Name);
}
}[/mw_shl_code] Die Parameter der Compare-Methode sind zwei Objekte desselben Typs, die verglichen werden müssen, und der Rückgabewert ist vom Typ int, während die Rückgabe-Wertverarbeitungsregeln denen der CompareTo-Methode entsprechen. Comparer.Default liefert ein eingebautes Comparer-Objekt zurück, um zwei Objekte desselben Typs zu vergleichen. So sortierst du die Sammlung mit diesem neu definierten Komparator: [mw_shl_code=csharp, true]//Sortiere die Sammlung nach Namen
Personen. Sort(NameComparer.Default);
//输出所有人姓名
foreach (Person p in Personen)
{
Console.WriteLine(p.Name); Die Ausgabereihenfolge lautet "Li Si", "Wang Wu" und "Zhang San"
}[/mw_shl_code] Du kannst die Sammlung auch sortieren, indem du delegierst, zunächst eine Methode definieren, die der Delegate aufrufen soll, um die Vergleichsregeln zu speichern, und du kannst eine statische Methode verwenden. Siehe den Code unten: [mw_shl_code=csharp,true]Klasse PersonVergleich.
{
Vergleichen Sie den Namen
öffentliche statische Int Name (Person P1, Person P2)
{
return System.Collections.Comparer.Default.Compare(p1. Name, S. 2. Name);
}
}[/mw_shl_code] Die Parameter der Methode sind zwei Objekte desselben Typs, die verglichen werden müssen: Der Rückgabewert ist vom Typ int, und die Rückgabewertungsregel ist dieselbe wie die der CompareTo-Methode.Sortiere dann die Sammlung über das integrierte generische Delegiertensystem. Vergleich<T>: [mw_shl_code=csharp, wahr] System.Comparison<Person> NameComparison = neues System.Comparison<Person>(PersonComparison.Name);
Personen. Sort(NameComparison);
//输出所有人姓名
foreach (Person p in Personen)
{
Console.WriteLine(p.Name); Die Ausgabereihenfolge lautet "Li Si", "Wang Wu" und "Zhang San"
}[/mw_shl_code] Man sieht, dass die beiden letztgenannten Methoden die Sammlung nach den angegebenen Regeln sortieren können, aber der Autor bevorzugt die Delegationsmethode und kann verschiedene Vergleichsregeln in eine Klasse einfügen und diese dann flexibel aufrufen. Suche nach generischen Sammlungen
Suche dient dazu, Gegenstände zu finden, die bestimmte Bedingungen aus der Sammlung erfüllen, und mehrere Suchbedingungen können bei Bedarf definiert und aufgerufen werden. Definieren Sie zunächst die Suchkriterien wie folgt: [mw_shl_code=csharp,true]Klasse PersonPrädikat
{
Finden Sie Menschen mittleren Alters (über 40)
öffentliche statische Bool MidAge (Person p)
{
wenn (p.Alter >= 40)
Return true;
oder
return false;
}
}[/mw_shl_code] Die obigen Suchkriterien werden in einer statischen Methode mit Boolescher Rückgabeart platziert, und Einträge in der Sammlung, die bestimmte Bedingungen erfüllen, geben wahr, ansonsten falsch zurück.Durchsuchen Sie dann die Sammlung über das integrierte generische Delegiertensystem System. Prädikat<T>: [mw_shl_code=csharp, wahr] System.Prädikat<Person> MidAgePredikat = neues System.Prädikat<Person>(PersonPredikat.MidAge);
Liste<Person> MidAgePersonen = Personen. FindAll(MidAgePredikat);
//输出所有的中年人姓名
foreach (Person p in MidAgePersons)
{
Console.WriteLine(p.Name); Ausgabe "Wang Wu"
}[/mw_shl_code] Erweiterung generischer Sammlungen
Was ist, wenn du die Namen aller Personen im Set bekommen willst, getrennt durch ein Komma?
Da die Funktionalität, die eine einzelne Klasse bieten kann, begrenzt ist, ist es naheliegend, <T>die List-Klasse zu erweitern, die ebenfalls eine Klasse ist und daher durch Vererbung erweitert werden kann. Siehe den Code unten: [mw_shl_code=csharp, true]// Definiere die Personen-Sammlungsklasse
Klassenpersonen: Liste<Person>
{
Hol dir die Namen aller in der Sammlung
öffentliche Zeichenkette GetAllNames()
{
wenn (dies. Anzahl == 0)
return "";
Saite val = "";
foreach (Person p in diesem Teil)
{
val += p.Name + ",";
}
Bring Val zurück. Substring(0, Val. Länge - 1);
}
}
//创建并填充Persons集合
Personen PersonCol = neue Personen();
PersonCol.Add (S. 1);
PersonCol.Add (S. 2);
PersonCol.Add (S3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Ausgabe "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Zusammenfassung:
Dieser Artikel konzentriert sich auf die Verwendung von Generika in C# 2.0 zur Implementierung von Sammlungen sowie auf die Erweiterung der Sammlungsfunktion, und die korrekte Verwendung generischer Sammlungen kann viel Duplikarbeit reduzieren und die Entwicklungseffizienz erheblich verbessern. Tatsächlich sind Sets nur eine typische Anwendung von Generika, und wenn Sie mehr über Generika erfahren möchten, können Sie andere relevante Materialien konsultieren. Ich hoffe, dieser Artikel war für dich hilfreich :-)
| 
Veröffentlicht am 11.11.2014 08:56:04
|
|
|
Veröffentlicht am 24.11.2014 11:48:29
