Collecties zijn een belangrijk concept in OOP, en volledige ondersteuning voor collecties in C# is een van de beste van de taal.
Waarom generieke sets gebruiken?
Voor C# 2.0 konden collecties op twee hoofdmanieren worden geïmplementeerd:
a. Gebruik ArrayList
Objecten direct in de ArrayList plaatsen is intuïtief, maar omdat de items in de collectie het type Object zijn, moet je elke keer dat je het gebruikt een tijdrovende typeconversie doen.
b. Gebruik aangepaste verzamelingsklassen
Een veelgebruikte praktijk is om een aangepaste klasse van de abstracte klasse CollectionBase te erven en een sterke typecollectie te implementeren door het IList-object te encapsuleren. Deze methode vereist het schrijven van een bijbehorende aangepaste klasse voor elk verzamelingstype, wat veel werk is. Het ontstaan van generieke collecties lost bovenstaande problemen goed op, en slechts één regel code kan worden gebruikt om een set van een gespecificeerd type te maken. Wat is generiek?
Generieke elementen zijn nieuwe elementen in C# 2.0 (templates genoemd in C++) die voornamelijk worden gebruikt om een reeks vergelijkbare problemen op te lossen. Dit mechanisme maakt het mogelijk om de klassenaam als argument aan het generieke type te geven en het bijbehorende object te genereren. Het kan beter zijn om generieke (inclusief klassen, interfaces, methoden, delegates, enz.) als templates te beschouwen, waarbij het variantgedeelte wordt vervangen door de klassenaam die als argument wordt doorgegeven, wat resulteert in een nieuwe typedefinitie. Generiek is een relatief groot onderwerp, en ik zal het hier niet in detail analyseren; wie geïnteresseerd is, kan de relevante informatie raadplegen. Hoe maak ik een generieke collectie?
De generieke klasse List onder de naamruimte System.Collections.Generic <T>wordt gebruikt om collecties te maken, en de syntaxis is als volgt: [mw_shl_code=csharp, waar] List<T> ListOfT = nieuwe List<T>(); [/mw_shl_code] De "T" is het type dat gebruikt moet worden, wat eenvoudige types kan zijn, zoals string, int of door de gebruiker gedefinieerde types. Laten we naar een specifiek voorbeeld kijken.
De Person-klasse wordt als volgt gedefinieerd: [mw_shl_code=csharp, true]klasse Persoon
{
privé snaar_name; Naam
privé-int _age; Leeftijd
Maak een Persoon-object aan
publieke persoon (snaarnaam, int leeftijd)
{
this._name= Naam;
this._age = Leeftijd;
}
Naam
publieke string Naam
{
get { return _name; }
}
Leeftijd
publieke int Leeftijd
{
get { return _age; }
}
}
//创建Person对象
Persoon p1 = nieuwe persoon ("Zhang San", 30);
Persoon p2 = nieuwe persoon ("Li Si", 20);
Persoon p3 = nieuwe persoon ("Wang Wu", 50);
//创建类型为Person的对象集合
Lijstpersonen<Person> = nieuwe Lijst<Person>();
//将Person对象放入集合
personen. Add(p1);
personen. Add(p2);
personen. Add(p3);
//输出第2个人的姓名
Console.Write(personen[1]. naam); [/mw_shl_code] Zoals je ziet, vereenvoudigen generieke collecties de implementatiecode van collecties aanzienlijk, waarmee je eenvoudig collecties van gespecificeerde types kunt maken. Niet alleen dat, maar generieke collecties bieden ook krachtigere functies; laten we eens kijken naar het sorteren en zoeken erin. Sortering van generieke collecties
Sorteren is gebaseerd op vergelijking, en om te sorteren moet je eerst vergelijken. Als er bijvoorbeeld twee getallen 1 en 2 zijn, moeten we om ze te sorteren eerst deze twee getallen vergelijken en sorteren volgens de vergelijkingsresultaten. Als je objecten wilt vergelijken, is de situatie iets ingewikkelder; bijvoorbeeld, als je Persoon-objecten vergelijkt, kun je vergelijken op naam of leeftijd, wat vereist dat je de vergelijkingsregels bepaalt. Een object kan meerdere vergelijkingsregels hebben, maar slechts één standaardregel, die wordt geplaatst in de klasse die het object definieert. De standaard vergelijkingsregels zijn gedefinieerd in de CompareTo-methode, die behoort tot de IComparable <T>generieke interface. Zie de code hieronder: [mw_shl_code=csharp,true]klasse Persoon: IComparable<Person>
{
Vergelijk op leeftijd
publieke int Vergelijk Ten Opzichte (Persoon p)
{
Breng dit terug. Leeftijd - p.Leeftijd;
}
}[/mw_shl_code] De parameters van de CompareTo-methode zijn een ander object van hetzelfde type waarmee vergeleken moet worden; de returnwaarde is van het type int; als de returnwaarde groter is dan 0, betekent dit dat het eerste object groter is dan het tweede object, als de returnwaarde kleiner is dan 0, betekent dit dat het eerste object kleiner is dan het tweede object, en als het 0 teruggeeft, zijn de twee objecten gelijk.
Na het definiëren van de standaardvergelijkingsregels kun je de collectie sorteren met de Sort-methode zonder parameters, als volgt: [mw_shl_code=csharp,true]// Sorteer de collectie volgens de standaardregels
personen. Sort();
//输出所有人姓名
foreach (Persoon p in personen)
{
Console.WriteLine(p.Name); De uitvoervolgorde is "Li Si", "Zhang San" en "Wang Wu"
}[/mw_shl_code] In de praktijk is het vaak nodig om de verzameling te sorteren volgens verschillende regels, wat de definitie van andere vergelijkingsregels vereist, die kunnen worden gedefinieerd in de Comple-methode, die behoort tot de IComparer <T>generieke interface, zie de volgende code: [mw_shl_code=csharp,true]klasse NameComparer : IComparer<Person>
{
Opslagsequencer-instanties
publieke statische NameComparer Default = nieuwe NameComparer();
Vergelijk op naam
publieke int Vergelijk (Persoon p1, Persoon p2)
{
return System.Collections.Comparer.Default.Compare(p1. Naam, p2. naam);
}
}[/mw_shl_code] De parameters van de Compare-methode zijn twee objecten van hetzelfde type die vergeleken moeten worden, en de retourwaarde is van type int, terwijl de regels voor de verwerking van retourwaarden hetzelfde zijn als die van de CompareTo-methode. Comparer.Default geeft een ingebouwd Comparer-object terug voor het vergelijken van twee objecten van hetzelfde type. Zo sorteer je de collectie met deze nieuw gedefinieerde comparator: [mw_shl_code=csharp,true]//Sorteer de collectie op naam
personen. Sort(NameComparer.Default);
//输出所有人姓名
foreach (Persoon p in personen)
{
Console.WriteLine(p.Name); De uitvoervolgorde is "Li Si", "Wang Wu" en "Zhang San"
}[/mw_shl_code] Je kunt de collectie ook sorteren door te delegeren, allereerst, definieer een methode die de delegate kan aanroepen om de vergelijkingsregels op te slaan, en je kunt een statische methode gebruiken. Zie de code hieronder: [mw_shl_code=csharp,true]klasse PersonVergelijking
{
Vergelijk op naam
publieke statische int Naam (Persoon p1, Persoon p2)
{
return System.Collections.Comparer.Default.Compare(p1. Naam, p2. naam);
}
}[/mw_shl_code] De parameters van de methode zijn twee objecten van hetzelfde type die vergeleken moeten worden, de retourwaarde is van het type int, en de regel voor de verwerking van retourwaarden is dezelfde als die van de CompareTo-methode.Sorteer vervolgens de collectie via het ingebouwde generieke delegate-systeem. Vergelijking<T>: [mw_shl_code=csharp, waar] System.Vergelijking<Person> NaamVergelijking = nieuw Systeem.Vergelijking<Person>(PersonComparison.Name);
personen. Sorteren(NaamVergelijking);
//输出所有人姓名
foreach (Persoon p in personen)
{
Console.WriteLine(p.Name); De uitvoervolgorde is "Li Si", "Wang Wu" en "Zhang San"
}[/mw_shl_code] Hieruit blijkt dat de laatste twee methoden de verzameling kunnen sorteren volgens de gespecificeerde regels, maar de auteur geeft de voorkeur aan de delegatiemethode en kan overwegen verschillende vergelijkingsregels in een klasse te plaatsen en deze vervolgens flexibel aan te roepen. Zoek naar generieke collecties
Zoeken is om items te vinden die aan specifieke voorwaarden voldoen uit de collectie, en meerdere zoekvoorwaarden kunnen worden gedefinieerd en aangeroepen indien nodig. Definieer eerst de zoekcriteria als volgt: [mw_shl_code=csharp,true]klasse PersonPredicate
{
Vind mensen van middelbare leeftijd (ouder dan 40)
publieke statische bool MidAge (Persoon p)
{
als (p.Leeftijd >= 40)
return true;
anders
return false;
}
}[/mw_shl_code] De bovenstaande zoekcriteria worden geplaatst in een statische methode met een Booleaanse retourtype, en items in de collectie die aan bepaalde voorwaarden voldoen, geven waar, anders onwaar.Doorzoek vervolgens de collectie via het ingebouwde generieke delegate System. Predicaat<T>: [mw_shl_code=csharp, waar] System.Predicaat<Person> MidAgePredicaat = nieuw Systeem.Predicaat<Person>(PersonPredicaat.MidAge);
List<Person> MidAgePersonen = personen. FindAll(MidAgePredicaat);
//输出所有的中年人姓名
foreach (Persoon p in MidAgePersons)
{
Console.WriteLine(p.Name); Output "Wang Wu"
}[/mw_shl_code] Uitbreiding van generieke collecties
Wat als je de namen van alle mensen in de set wilt krijgen, gescheiden door een komma?
Aangezien de functionaliteit die een enkele klasse kan bieden beperkt is, is het logisch om <T>te denken aan het uitbreiden van de List-klasse, die ook een klasse is en daarom door overerving kan worden uitgebreid. Zie de code hieronder: [mw_shl_code=csharp,true]// Definieer de Persons-verzamelingsklasse
Klasse Personen: Lijst<Person>
{
Haal de namen van iedereen in de collectie
publieke string GetAllNames()
{
als (dit. Aantal == 0)
return "";
snaar val = "";
foreach (Persoon p in dit)
{
val += p.Name + ",";
}
Ga terug, Val. Substring(0, val. Lengte - 1);
}
}
//创建并填充Persons集合
Personen PersonCol = nieuwe personen();
PersonCol.Add (p1);
PersonCol.Add (p2);
PersonCol.Add (p3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Output "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Samenvatting:
Dit artikel richt zich op het gebruik van generieke collecties in C# 2.0 om collecties te implementeren, evenals om de verzamelfunctie uit te breiden, en het juiste gebruik van generieke collecties kan veel duplicatie verminderen en de ontwikkelingsefficiëntie aanzienlijk verbeteren. In feite zijn sets gewoon een typische toepassing van generieke middelen, en als je meer wilt weten over generieke producten, kun je andere relevante materialen raadplegen. Hopelijk was dit artikel nuttig voor je :-)
| 
Geplaatst op 11-11-2014 08:56:04
|
|
|
Geplaatst op 24-11-2014 11:48:29
