Samlinger er et vigtigt begreb i OOP, og fuld understøttelse af samlinger i C# er et af sprogets bedste muligheder.
Hvorfor bruge generiske sæt?
Før C# 2.0 kunne samlinger implementeres på to hovedmåder:
a. Brug ArrayList
At lægge objekter direkte i ArrayList er intuitivt, men da genstandene i samlingen er af typen Objekt, skal du lave en besværlig typekonvertering hver gang, du bruger den.
b. Brug brugerdefinerede samlingsklasser
En almindelig praksis er at arve en brugerdefineret klasse fra CollectionBase-abstraktklassen og implementere en stærk typesamling ved at indkapsle IList-objektet. Denne metode kræver, at man skriver en tilsvarende brugerdefineret klasse for hver samlingstype, hvilket er meget arbejde. Fremkomsten af generiske samlinger løser ovenstående problemer godt, og kun én linje kode kan bruges til at skabe et sæt af en specificeret type. Hvad er generisk?
Generiske elementer er nye elementer i C# 2.0 (kaldet skabeloner i C++), som hovedsageligt bruges til at løse en række lignende problemer. Denne mekanisme tillader, at klassenavnet kan sendes som et argument til den generiske type, og det tilsvarende objekt genereres. Det kan være bedre at betragte generiske (herunder klasser, grænseflader, metoder, delegerede osv.) som skabeloner, hvor variantdelen erstattes af klassenavnet som et argument, hvilket resulterer i en ny typedefinition. Generisk er et relativt stort emne, og jeg vil ikke analysere det i detaljer her, og dem, der er interesserede, kan konsultere relevant information. Hvordan opretter jeg en generisk samling?
Listen generiske klasse under System.Collections.Generic <T>navneområdet bruges til at oprette samlinger, og syntaksen er som følger: [mw_shl_code=csharp, sandt] List<T> ListOfT = ny List<T>(); [/mw_shl_code] "T" er typen, der skal bruges, og som kan være simple typer, såsom streng, int eller brugerdefinerede typer. Lad os se på et konkret eksempel.
Person-klassen defineres som følger: [mw_shl_code=csharp, true]klasse Person
{
privat streng _name; Navn
privat intelligens _age; Alder
Opret et Person-objekt
offentlig person (strengnavn, alder)
{
this._name= Navn;
this._age = Alder;
}
Navn
offentlig strengnavn
{
get { return _name; }
}
Alder
offentlig int Alder
{
get { return _age; }
}
}
//创建Person对象
Person p1 = ny person ("Zhang San", 30);
Person p2 = ny person ("Li Si", 20);
Person p3 = ny person ("Wang Wu", 50);
//创建类型为Person的对象集合
Listepersoner<Person> = ny Liste<Person>();
//将Person对象放入集合
personer. Add(p1);
personer. Add(p2);
personer. Add(p3);
//输出第2个人的姓名
Console.Write(persons[1]. Navn); [/mw_shl_code] Som du kan se, forenkler generiske samlinger implementeringskoden for samlinger betydeligt, hvorigennem du nemt kan oprette samlinger af bestemte typer. Ikke nok med det, men generiske samlinger tilbyder også mere kraftfulde funktioner, lad os se på sorteringen og søgningen i dem. Sortering af generiske samlinger
Sortering er baseret på sammenligning, og for at sortere skal du først sammenligne. For eksempel, hvis der er to tal 1 og 2, skal vi først sammenligne disse to tal og sortere dem efter sammenligningsresultaterne for at sortere dem. Hvis du vil sammenligne objekter, er situationen lidt mere kompliceret; for eksempel hvis du sammenligner Personobjekter, kan du sammenligne efter navn eller alder, hvilket kræver, at du fastlægger sammenligningsreglerne. Et objekt kan have flere sammenligningsregler, men kun én standardregel, som placeres i den klasse, der definerer objektet. Standardsammenligningsreglerne er defineret i CompareTo-metoden, som hører til IComparable <T>generiske interface. Se koden nedenfor: [mw_shl_code=csharp, true]klasse Person: IComparable<Person>
{
Sammenlign efter alder
offentlig int CompareTo(Person p)
{
Returnér dette. Alder - p.Alder;
}
}[/mw_shl_code] Parametrene i CompareTo-metoden er et andet objekt af samme type, der skal sammenlignes med, returværdien er int-typen, hvis returværdien er større end 0, betyder det, at det første objekt er større end det andet objekt, hvis returværdien er mindre end 0, betyder det, at det første objekt er mindre end det andet objekt, og hvis det returnerer 0, er de to objekter ens.
Efter at have defineret standardsammenligningsreglerne kan du sortere samlingen ved hjælp af Sort-metoden uden parametre, som følger: [mw_shl_code=csharp,true]// Sorter samlingen efter standardreglerne
personer. Sort();
//输出所有人姓名
foreach (Person p i personer)
{
Console.WriteLine(p.Name); Rækkefølgen er "Li Si", "Zhang San" og "Wang Wu"
}[/mw_shl_code] I praksis er det ofte nødvendigt at sortere samlingen efter en række forskellige regler, hvilket kræver definition af andre sammenligningsregler, som kan defineres i Compere-metoden, der hører til IComparers <T>generiske interface, se venligst følgende kode: [mw_shl_code=csharp,true]-klasse NavnKomparer : IComparer<Person>
{
Lagersekvenser-instanser
offentlig statisk NameComparer Default = ny NameComparer();
Sammenlign efter navn
offentlig int Sammenlign (Person p1, Person p2)
{
return System.Collections.Comparer.Default.Compare(p1. Navn, s. 2. Navn);
}
}[/mw_shl_code] Parametrene for Compare-metoden er to objekter af samme type, der skal sammenlignes, og returværdien er af typen int, mens reglerne for behandling af returværdier er de samme som i CompareTo-metoden. Comparer.Default returnerer et indbygget Comparer-objekt til sammenligning af to objekter af samme type. Sådan sorterer du samlingen med denne nydefinerede komparator: [mw_shl_code=csharp,true]//Sorter samlingen efter navn
personer. Sort(NameComparer.Default);
//输出所有人姓名
foreach (Person p i personer)
{
Console.WriteLine(p.Name); Rækkefølgen på output er "Li Si", "Wang Wu" og "Zhang San"
}[/mw_shl_code] Du kan også sortere samlingen ved først og fremmest at definere en metode, som delegaten skal kalde for at gemme sammenligningsreglerne, og du kan bruge en statisk metode. Se koden nedenfor: [mw_shl_code=csharp,true]klasse PersonSammenligning
{
Sammenlign efter navn
offentlig statisk int Navn (Person p1, Person p2)
{
return System.Collections.Comparer.Default.Compare(p1. Navn, s. 2. Navn);
}
}[/mw_shl_code] Parametrene for metoden er to objekter af samme type, der skal sammenlignes, returværdien er af typen int, og reglen for behandling af returværdi er den samme som for CompareTo-metoden.Sorter derefter samlingen via det indbyggede generiske delegeresystem. Sammenligning<T>: [mw_shl_code=csharp, sandt] <Person> System.SammenligningsnavnSammenligning = nyt System.Sammenligning<Person>(PersonComparison.Name);
personer. Sort(NavnSammenligning);
//输出所有人姓名
foreach (Person p i personer)
{
Console.WriteLine(p.Name); Rækkefølgen på output er "Li Si", "Wang Wu" og "Zhang San"
}[/mw_shl_code] Det kan ses, at de to sidstnævnte metoder kan sortere samlingen efter de specificerede regler, men forfatteren foretrækker at bruge delegeringsmetoden og kan overveje at placere forskellige sammenligningsregler i en klasse og derefter kalde dem fleksibelt. Søg efter generiske samlinger
Søgning er at finde genstande, der opfylder specifikke betingelser fra samlingen, og flere søgebetingelser kan defineres og kaldes efter behov. Først defineres søgekriterierne som følger: [mw_shl_code=csharp, true]klasse PersonPredikat
{
Find midaldrende personer (over 40)
offentlig statisk bool MidAge (Person p)
{
hvis (p.Alder >= 40)
returner sand;
ellers
return false;
}
}[/mw_shl_code] Ovenstående søgekriterier placeres i en statisk metode med en boolesk returtype, og elementer i samlingen, der opfylder visse betingelser, returnerer sand, ellers falsk.Søg derefter i samlingen via det indbyggede generiske delegatsystem. Prædikat<T>: [mw_shl_code=csharp, sandt] System.Prædikat<Person> MidAgePredikat = nyt System.Prædikat<Person>(PersonPrædikat.MidAge);
List<Person> MidAgePersons = personer. FindAll(MidAgePredicate);
//输出所有的中年人姓名
foreach (Person p i MidAgePersons)
{
Console.WriteLine(p.Name); Output "Wang Wu"
}[/mw_shl_code] Udvidelse af generiske samlinger
Hvad hvis du vil have navnene på alle personerne i sættet, adskilt af et komma?
I betragtning af at funktionaliteten, som en enkelt klasse kan levere, er begrænset, er det naturligt at tænke <T>på at udvide List-klassen, som også er en klasse og derfor kan udvides ved arv. Se koden nedenfor: [mw_shl_code=csharp,true]// Definér Persons-samlingsklassen
Klassepersoner : Liste<Person>
{
Få navnene på alle i samlingen
offentlig streng GetAllNames()
{
hvis (dette. Antal == 0)
return "";
streng val = "";
foreach (Person p i denne)
{
val += p.Name + ",";
}
Returner Val. Substring(0, val. Længde - 1);
}
}
//创建并填充Persons集合
Personer PersonCol = nye personer();
PersonCol.Add(s.1);
PersonCol.Add(p2);
PersonCol.Add (s3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Output "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Resumé:
Denne artikel fokuserer på brugen af generiske i C# 2.0 til at implementere samlinger samt udvide samlingsfunktionen, og korrekt brug af generiske samlinger kan reducere meget dobbeltarbejde og i høj grad forbedre udviklingseffektiviteten. Faktisk er mængder bare en typisk anvendelse af generiske typer, og hvis du vil vide mere om generiske, kan du konsultere andre relevante materialer. Håber denne artikel var nyttig for dig :-)
| 
Opslået på 11/11/2014 08.56.04
|
|
|
Opslået på 24/11/2014 11.48.29
