Samlinger er et viktig konsept i OOP, og full støtte for samlinger i C# er et av de beste i språket.
Hvorfor bruke generiske sett?
Før C# 2.0 kunne samlinger implementeres på to hovedmåter:
a. Bruk ArrayList
Å legge objekter direkte inn i ArrayList er intuitivt, men siden elementene i samlingen er av typen Objekt, må du gjøre en kjedelig typekonvertering hver gang du bruker den.
b. Bruk egendefinerte samlingsklasser
En vanlig praksis er å arve en egendefinert klasse fra CollectionBase-abstraktklassen og implementere en sterk typesamling ved å kapsle inn IList-objektet. Denne metoden krever at man skriver en tilsvarende egendefinert klasse for hver samlingstype, noe som er mye arbeid. Fremveksten av generiske samlinger løser de ovennevnte problemene godt, og kun én kodelinje kan brukes til å lage et sett av en spesifisert type. Hva er generisk?
Generiske elementer er nye elementer i C# 2.0 (kalt maler i C++) som hovedsakelig brukes til å løse en rekke lignende problemer. Denne mekanismen gjør det mulig å sende klassenavnet som et argument til den generiske typen, og det tilsvarende objektet genereres. Det kan være bedre å tenke på generiske (inkludert klasser, grensesnitt, metoder, delegater osv.) som maler, der variantdelen erstattes av klassenavnet som sendes som et argument, noe som resulterer i en ny typedefinisjon. Generisk er et relativt stort tema, og jeg vil ikke analysere det i detalj her, og de som er interessert kan konsultere relevant informasjon. Hvordan lager jeg en generisk kolleksjon?
List generisk klasse under System.Collections.Generic <T>navnerommet brukes til å lage samlinger, og syntaksen er som følger: [mw_shl_code=csharp, sant] List<T> ListOfT = ny List<T>(); [/mw_shl_code] "T" er typen som skal brukes, som kan være enkle typer, som streng, int eller brukerdefinerte typer. La oss se på et konkret eksempel.
Person-klassen er definert som følger: [mw_shl_code=csharp, true]klasse Person
{
privat streng_name; Navn
privat _age; Alder
Opprett et Person-objekt
offentlig person (strengnavn, int alder)
{
this._name= Navn;
this._age = Alder;
}
Navn
offentlig strengnavn
{
få { return _name; }
}
Alder
offentlig alder
{
få { returner _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 ser, forenkler generiske samlinger implementeringskoden for samlinger betydelig, slik at du enkelt kan lage samlinger av spesifiserte typer. Ikke bare det, men generiske samlinger gir også kraftigere funksjoner, la oss se på sortering og søk i dem. Sortering av generiske samlinger
Sortering baseres på sammenligning, og for å sortere må du først sammenligne. For eksempel, hvis det er to tall, 1 og 2, må vi for å sortere dem først sammenligne disse to tallene og sortere dem etter sammenligningsresultatene. Hvis du vil sammenligne objekter, er situasjonen litt mer komplisert, for eksempel hvis du sammenligner Person-objekter, kan du sammenligne etter navn eller alder, noe som krever at du fastsetter sammenligningsreglene. Et objekt kan ha flere sammenligningsregler, men bare én standardregel, som plasseres i klassen som definerer objektet. Standard sammenligningsregler er definert i CompareTo-metoden, som tilhører IComparable <T>generisk grensesnitt. Se koden nedenfor: [mw_shl_code=csharp,true]-klasse Person: IComparable<Person>
{
Sammenlign etter alder
offentlig int CompareTo(Person p)
{
Returner dette. Alder - p.Alder;
}
}[/mw_shl_code] Parameterne til CompareTo-metoden er et annet objekt av samme type som skal sammenlignes med, returverdien er int-typen, hvis returverdien er større enn 0, betyr det at det første objektet er større enn det andre objektet, hvis returverdien er mindre enn 0, betyr det at det første objektet er mindre enn det andre objektet, og hvis det returnerer 0, er de to objektene like.
Etter å ha definert standard sammenligningsregler, kan du sortere samlingen ved hjelp av sorteringsmetoden uten parametere, som følger: [mw_shl_code=csharp,true]// Sorter samlingen etter standardreglene
personer. Sort();
//输出所有人姓名
foreach (Person p i personer)
{
Console.WriteLine(p.Name); Utgangsrekkefølgen er "Li Si", "Zhang San" og "Wang Wu"
}[/mw_shl_code] I praksis er det ofte nødvendig å sortere samlingen etter en rekke forskjellige regler, noe som krever definisjon av andre sammenligningsregler, som kan defineres i Compere-metoden, som tilhører IComparers <T>generiske grensesnitt, se følgende kode: [mw_shl_code=csharp,true]-klasse NameComparer : IComparer<Person>
{
Lagringssekvenserinstanser
offentlig statisk NameComparer Default = ny NameComparer();
Sammenlign etter navn
offentlig int Sammenlign (Person p1, Person p2)
{
return System.Collections.Comparer.Default.Compare(p1. Navn, s. 2. Navn);
}
}[/mw_shl_code] Parameterne i Compare-metoden er to objekter av samme type som skal sammenlignes, og returverdien er av typen int, mens reglene for behandling av returverdier er de samme som i CompareTo-metoden. Comparer.Default returnerer et innebygd Comparer-objekt for å sammenligne to objekter av samme type. Slik sorterer du samlingen med denne nydefinerte komparatoren: [mw_shl_code=csharp,true]//Sorter samlingen etter navn
personer. sorter(NameComparer.Default);
//输出所有人姓名
foreach (Person p i personer)
{
Console.WriteLine(p.Name); Utgangsrekkefølgen er "Li Si", "Wang Wu" og "Zhang San"
}[/mw_shl_code] Du kan også sortere samlingen ved å delegere, først og fremst definere en metode delegaten skal kalle for å lagre sammenligningsreglene, og du kan bruke en statisk metode. Se koden nedenfor: [mw_shl_code=csharp,true]klasse PersonSammenligning
{
Sammenlign etter navn
offentlig statisk int Navn (Person p1, Person p2)
{
return System.Collections.Comparer.Default.Compare(p1. Navn, s. 2. Navn);
}
}[/mw_shl_code] Parameterne i metoden er to objekter av samme type som skal sammenlignes, returverdien er av typen int, og regelen for behandling av returverdi er den samme som for CompareTo-metoden.Sorter deretter samlingen via det innebygde generiske delegatsystemet. Sammenligning<T>: [mw_shl_code=csharp, sant] System.Sammenligning<Person> NavnSammenligning = nytt System.Sammenligning<Person>(PersonComparison.Name);
personer. Sorter(NavnSammenligning);
//输出所有人姓名
foreach (Person p i personer)
{
Console.WriteLine(p.Name); Utgangsrekkefølgen er "Li Si", "Wang Wu" og "Zhang San"
}[/mw_shl_code] Det kan sees at de to sistnevnte metodene kan sortere samlingen etter de spesifiserte reglene, men forfatteren foretrekker å bruke delegasjonsmetoden, og kan vurdere å legge ulike sammenligningsregler i en klasse og deretter kalle dem fleksibelt. Søk etter generiske samlinger
Søk er å finne gjenstander som oppfyller spesifikke betingelser fra samlingen, og flere søkebetingelser kan defineres og kalles etter behov. Først, definer søkekriteriene som følger: [mw_shl_code=csharp, true]klasse Personpredikat
{
Finn middelaldrende personer (over 40)
offentlig statisk bool MidAge (Person p)
{
hvis (p.Alder >= 40)
returner sann;
ellers
returner falsk;
}
}[/mw_shl_code] Søkkriteriene ovenfor plasseres i en statisk metode med en boolsk returtype, og elementer i samlingen som oppfyller visse betingelser returnerer sann, ellers falsk.Søk deretter i samlingen via det innebygde generiske delegatsystemet.Predicate<T>: [mw_shl_code=csharp, sant] System.Predikat<Person> MidAgePredikat = nytt System.Predikat<Person>(PersonPredikat.MidAge);
List<Person> MidAgePersons = personer. FindAll(MidAgePredicate);
//输出所有的中年人姓名
foreach (Person p i MidAgePersons)
{
Console.WriteLine(p.Name); Utgang "Wang Wu"
}[/mw_shl_code] Utvidelse av generiske samlinger
Hva om du vil ha navnene på alle personene i samlingen, adskilt med et komma?
Med tanke på at funksjonaliteten en enkelt klasse kan gi er begrenset, er det naturlig å tenke <T>på å utvide List-klassen, som også er en klasse og derfor kan utvides ved arv. Se koden nedenfor: [mw_shl_code=csharp, true]// Definer Persons-samlingsklassen
Klasse Personer : Liste<Person>
{
Få navnene på alle i samlingen
offentlig streng GetAllNames()
{
hvis (dette. Antall == 0)
return "";
streng val = "";
foreach (Person p i denne)
{
val += p.Name + ",";
}
Kom tilbake, Val. Substring(0, val. Lengde - 1);
}
}
//创建并填充Persons集合
Personer PersonCol = nye personer();
PersonCol.Add (s. 1);
PersonCol.Add (s. 2);
PersonCol.Add (s. 3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Utgivelse "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Sammendrag:
Denne artikkelen fokuserer på bruken av generiske i C# 2.0 for å implementere samlinger, samt for å utvide samlingsfunksjonen, og riktig bruk av generiske samlinger kan redusere mye duplisering av arbeid og betydelig forbedre utviklingseffektiviteten. Faktisk er mengder bare en typisk anvendelse av generiske typer, og hvis du vil vite mer om generika, kan du konsultere andre relevante materialer. Håper denne artikkelen var nyttig for deg :-)
| 
Publisert på 11.11.2014 08:56:04
|
|
|
Publisert på 24.11.2014 11:48:29
