A gyűjtemények fontos fogalmak az OOP-ban, és a teljes támogatás a C# gyűjteményekhez az egyik legjobb a nyelven.
Miért használunk generikus készleteket?
A C# 2.0 előtt a gyűjtemények két fő módon valósíthatók meg:
a. Használd a ArrayListet
Az objektumok közvetlenül a ArrayListbe helyezése intuitív, de mivel a gyűjtemény elemei Object típusúak, minden használatkor fárasztó típusváltást kell végezned.
b. Egyedi gyűjteményosztályokat használjunk
Egy gyakori gyakorlat, hogy egy egyedi osztályt örökölünk a CollectionBase absztrakt osztályból, és egy erős típus-gyűjteményt valósítanak meg az IList objektum kapszulázásával. Ez a módszer minden gyűjteménytípushoz egy megfelelő egyedi osztály megírását igényli, ami sok munkát igényel. Az általános gyűjtemények megjelenése jól megoldja a fent említett problémákat, és csak egy kódsor használható egy meghatározott típusú halmaz létrehozásához. Mi az a generikus?
Az általánosok új elemek a C# 2.0-ban (C++-ban sablonoknak nevezik), amelyeket főként hasonló problémák megoldására használnak. Ez a mechanizmus lehetővé teszi, hogy az osztálynevet argumentumként továbbítsák a generikus típusnak, és a megfelelő objektumot generálják. Talán jobb lehet az általános elemeket (beleértve az osztályokat, felületeket, metódusokat, delegáltákat stb.) sablonként kezelni, ahol a variáns részt az osztálynév váltja fel, amely argumentumként adt át, így új típusdefiníciót eredményez. A generikus viszonylag nagy téma, és itt nem fogom részletesen elemezni, és akik érdeklődnek, a releváns információkat is megtekinthetik. Hogyan hozhatok létre egy általános gyűjteményt?
A Lista generikus osztály a System.Collections.Generic névtér alatt <T>a gyűjtemények létrehozásához szolgál, és a szintaxis a következő: [mw_shl_code=csharp, igaz] <T> ListOfT = új List<T>(); [/mw_shl_code] A "T" a használt típus, amely lehet egyszerű típusok, például string, int vagy felhasználó által definiált típusok. Nézzünk egy konkrét példát.
A Person osztály a következőképpen definiálható: [mw_shl_code=csharp,true]osztály Személy
{
privát húros _name; Név
privát int _age; Életkor
Hozzon létre egy Person objektumot
nyilvános személy (string név, int életkor)
{
this._name= Név;
this._age = Életkor;
}
Név
public string Név
{
get { return _name; }
}
Életkor
public int Age
{
get { return _age; }
}
}
//创建Person对象
Személy p1 = új személy ("Zhang San", 30);
Személy p2 = új személy ("Li Si", 20);
Személy p3 = új személy ("Wang Wu", 50);
//创建类型为Person的对象集合
<Person> Személyek lista = új List<Person>();
//将Person对象放入集合
személyek. Add(p1);
személyek. Add(p2);
személyek. Add(p3);
//输出第2个人的姓名
Console.Write(személyek[1]. Név); [/mw_shl_code] Ahogy látható, az általános gyűjtemények jelentősen leegyszerűsítik a gyűjtemények megvalósítási kódját, amelyen keresztül könnyen létrehozhatsz meghatározott típusú gyűjteményeket. Ráadásul az általános gyűjtemények erősebb funkciókat is kínálnak, nézzük meg a sortolást és keresést bennük. Általános gyűjtemények rendezése
A rendezés összehasonlításon alapul, és a rendezéshez először összehasonlítani kell. Például, ha két szám van, 1 és 2, akkor a rendezésükhöz először össze kell hasonlítanunk ezeket a két számot, és az összehasonlító eredmények alapján kell rendeznünk. Ha tárgyakat akarsz összehasonlítani, a helyzet egy kicsit bonyolultabb, például ha összehasonlítod a Person objektumokat, név vagy életkor alapján is összehasonlíthatod, ami az összehasonlítási szabályokat kell meghatározni. Egy objektumnak több összehasonlítási szabálya is lehet, de csak egy alapértelmezett szabálya, amely az objektumot definiáló osztályba kerül. Az alapértelmezett összehasonlítási szabályokat a CompareTo metódus definiálja, amely az IComparable <T>általános interfészhez tartozik. Lásd az alábbi kódot: [mw_shl_code=csharp,true]osztály Személy :IComparable<Person>
{
Összehasonlítás életkor szerint
public int Összehasonlítás(Személy p)
{
Add vissza ezt. Életkor – p.Életkor;
}
}[/mw_shl_code] A CompareTo metódus paraméterei egy másik azonos típusú objektumot jelentenek, amelyekkel összehasonlítani kell, a visszaküldési érték int típus, ha a visszaküldési érték nagyobb, mint 0, az azt jelenti, hogy az első objektum nagyobb, mint a második objektum, ha a visszatérés értéke kisebb, mint 0, az első objektum kisebb, mint a második, és ha 0-t ad vissza, akkor a két objektum egyenlő.
Az alapértelmezett összehasonlítási szabályok meghatározása után a Sort metódóval paraméter nélkül rendezheti a gyűjteményt a következőképpen a következőként: [mw_shl_code=csharp,true]// A gyűjteményt az alapértelmezett szabályok szerint rendezzük
személyek. Sort();
//输出所有人姓名
foreach (személy p személyben)
{
Console.WriteLine(p.Name); A kiadási sorrend: "Li Si", "Zhang San" és "Wang Wu".
}[/mw_shl_code] A gyakorlatban gyakran szükséges a gyűjteményt különböző szabályok szerint rendezni, ami más összehasonlító szabályok meghatározását igényli, amelyeket az IComparer <T>általános interfészhez tartozó Compare módszer definiálhat, kérjük, lásd a következő kódot: [mw_shl_code=csharp,true]osztály Névösszehasonlító : IComparer<Person>
{
Tároló szekvencer példányok
public static NameComparer Default = new NameComparer();
Név szerint hasonlítsd össze
public int Összehasonlítás (Személy p1, Person p2)
{
return System.Collections.Comparer.Default.Compare(p1. Név, p2. Név);
}
}[/mw_shl_code] Az Compare metódus paraméterei két azonos típusú objektumból állnak, amelyeket össze kell hasonlítani, a visszaküldési érték int típusú, és a visszaküldési érték feldolgozási szabályai megegyeznek az CompareTo módszerével. A Comparer.Default egy beépített Comparer objektumot ad vissza, amely két azonos típusú objektum összehasonlításához. Íme, hogyan rendezheted a gyűjteményt ezzel az újonnan definiált összehasonlítóval: [mw_shl_code=csharp,true]//Rendezd a gyűjteményt név szerint
személyek. sort(NameComparer.Default);
//输出所有人姓名
foreach (személy p személyben)
{
Console.WriteLine(p.Name); A kiadási sorrend: "Li Si", "Wang Wu" és "Zhang San"
}[/mw_shl_code] A gyűjteményt úgy is rendezheted, hogy delegáld – először definiálhatsz egy metódust, amit a delegált hívhat az összehasonlító szabályok tárolására, és statikus metódust is használhatsz. Lásd az alábbi kódot: [mw_shl_code=csharp,true]osztály SzemélyÖsszehasonlítás
{
Név szerint hasonlítsd össze
public static int Név (Személy p1, Person p2)
{
return System.Collections.Comparer.Default.Compare(p1. Név, p2. Név);
}
}[/mw_shl_code] A metódus paraméterei két azonos típusú objektumból állnak, amelyeket össze kell hasonlítani: a visszaküldési érték int típusú, és a visszaküldési érték feldolgozási szabálya megegyezik a CompareTo módszerével.Ezután rendezd a gyűjteményt a beépített általános delegált rendszeren keresztül. <T>Összehasonlítás: [mw_shl_code=csharp, igaz] System.Comparison<Person> NameComparison = új System.Comparison<Person>(PersonComparison.Name);
személyek. Sort(NévÖsszehasonlítás);
//输出所有人姓名
foreach (személy p személyben)
{
Console.WriteLine(p.Name); A kiadási sorrend: "Li Si", "Wang Wu" és "Zhang San"
}[/mw_shl_code] Látható, hogy az utóbbi két módszer a meghatározott szabályok szerint rendezheti a gyűjteményt, de a szerző inkább az delegációs metódust használja, és fontolóra veheti, hogy különböző összehasonlító szabályokat helyez be egy osztályba, majd rugalmasan hívja őket. Általános gyűjtemények keresése
A keresés arra szolgál, hogy megtaláljuk azokat az elemeket, amelyek megfelelnek a gyűjteményből, és szükség szerint több keresési feltételt is definiálhatnak és hívhatnak. Először definiáljuk a keresési kritériumokat a következőként: [mw_shl_code=csharp,true]osztály Személypredikátum
{
Keress középkorúakat (40 év feletti)
nyilvános statikus bool Midage (személy p)
{
ha (p.Kor >= 40)
return true;
más
hamis;
}
}[/mw_shl_code] A fenti keresési kritériumokat statikus módszerben helyezik el egy Boole-visszatérési típussal, és a gyűjteményben lévő elemek, amelyek bizonyos feltételeket teljesítenek, igaz, egyébként hamisnak adják vissza.Ezután keresd a gyűjteményt a beépített általános delegált, a System.Predicate-en<T>: [mw_shl_code=csharp, igaz] System.Predikátum<Person> MidAgePredicate = új System.Predicate<Person>(SzemélyPredicate.MidAge);
<Person> MidAgePersons = személyek listája. FindAll (MidagePredicate);
//输出所有的中年人姓名
foreach (Személy p a MidAgePersons-ban)
{
Console.WriteLine(p.Name); Kimenet: "Wang Wu"
}[/mw_shl_code] Általános gyűjtemények bővítése
Mi van, ha szeretnéd megkapni a szettben szereplő összes személy nevét, egy vesszővel elválasztva?
Mivel egyetlen osztály által nyújtott funkciók korlátozottak, természetes a <T>Lista osztály bővítésére, amely szintén osztály, ezért örökléssel bővíthető. Lásd az alábbi kódot: [mw_shl_code=csharp,true]// Definiáljuk a Persons gyűjtemény osztályt
osztály Személyek: Lista<Person>
{
Szerezd meg a gyűjteményben szereplők nevét
public string GetAllNames()
{
ha (ez. Szám == 0)
return "";
hvor val = "";
foreach (P személy ebben)
{
val += p.Name + ",";
}
Vissza Val. Substring(0, val. Hossz - 1);
}
}
//创建并填充Persons集合
Persons PersonCol = új személyek();
PersonCol.Add(p1);
PersonCol.Add(p2);
PersonCol.Add(p3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Kimenet: "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Összefoglaló:
Ez a cikk a C# 2.0-ban a generikák alkalmazására fókuszál a gyűjtemények megvalósítására, valamint a gyűjteményi funkció bővítésére, és a generikus gyűjtemények megfelelő használata csökkentheti a munka sok duplikálását, és jelentősen javíthatja a fejlesztési hatékonyságot. Valójában a készletek csak egy tipikus alkalmazása a generikáknak, és ha többet szeretnél megtudni a generikákról, más releváns anyagokhoz is fordulhatsz. Remélem, ez a cikk hasznos volt neked :-)
| 
Közzétéve 2014. 11. 11. 8:56:04
|
|
|
Közzétéve 2014. 11. 24. 11:48:29
