Колекциите са важна концепция в ООП, а пълната поддръжка на колекции на C# е една от най-добрите в езика.
Защо да използвате генерични комплекти?
Преди C# 2.0 колекциите можеха да бъдат реализирани по два основни начина:
а. Използвайте ArrayList
Поставянето на обекти директно в ArrayList е интуитивно, но тъй като елементите в колекцията са от тип Object, трябва да правиш досадно конвертиране на типове всеки път, когато го използваш.
b. Използвайте персонализирани колекция класове
Честа практика е да се наследи персонализиран клас от абстрактния клас CollectionBase и да се реализира силна колекция от типове чрез капсулиране на обекта IList. Този метод изисква писане на съответния персонализиран клас за всеки тип колекция, което е много работа. Появата на общи колекции решава горните проблеми добре и само един ред код може да се използва за създаване на набор от определен тип. Какво е общо?
Генеричните елементи са нови елементи в C# 2.0 (наричани шаблони на C++), които основно се използват за решаване на серия от подобни проблеми. Този механизъм позволява името на класа да се предава като аргумент към генеричния тип и съответният обект да се генерира. Може би е по-добре да се мисли за общите (включително класове, интерфейси, методи, делегати и др.) като шаблони, при които вариантната част се заменя с името на класа, предавано като аргумент, което води до нова дефиниция на тип. Общото е сравнително голяма тема и няма да я анализирам подробно тук, а заинтересованите могат да се консултират с релевантната информация. Как да създам генерична колекция?
Общият клас List под пространството на имената System.Collections.Generic <T>се използва за създаване на колекции, а синтаксисът е следният: [mw_shl_code=Шарп, вярно] List<T> ListOfT = нов List<T>(); [/mw_shl_code] "T" е типът, който трябва да се използва, който може да бъде прости типове, като string, int или потребителски дефинирани типове. Нека разгледаме конкретен пример.
Класът Person се дефинира по следния начин: [mw_shl_code=csharp,true]клас Човек
{
частен струнен _name; Име
частен международен _age; Възраст
Създай обект Person
Публично лице (име на струна, интелигентна възраст)
{
this._name= Име;
this._age = Възраст;
}
Име
публичен низ Име
{
get { return _name; }
}
Възраст
публичен международен възраст
{
get { return _age; }
}
}
//创建Person对象
Лице p1 = нов човек ("Чжан Сан", 30);
Лице p2 = ново лице ("Ли Си", 20);
Лице p3 = ново лице ("Ван У", 50);
//创建类型为Person的对象集合
<Person> Лица в списъка = нов List<Person>();
//将Person对象放入集合
личности. Add(p1);
личности. Add(p2);
личности. Add(p3);
//输出第2个人的姓名
Console.Write(persons[1]. Име); [/mw_shl_code] Както виждате, общите колекции значително опростяват кода за имплементация, чрез който лесно можете да създавате колекции от определени типове. Освен това, генеричните колекции предоставят и по-мощни функции, нека разгледаме сортирането и търсенето в тях. Сортиране на генерични колекции
Сортирането се базира на сравнение, а за да сортирате, първо трябва да сравнявате. Например, ако има две числа 1 и 2, за да ги сортираме, първо трябва да ги сравним и да ги сортираме според резултатите от сравнението. Ако искате да сравнявате обекти, ситуацията е малко по-сложна, например, ако сравнявате обекти Person, можете да сравнявате по име или възраст, което изисква определяне на правилата за сравнение. Обект може да има няколко правила за сравнение, но само едно по подразбиране правило, което се поставя в класа, дефиниращ обекта. Стандартните правила за сравнение са дефинирани в метода CompareTo, който принадлежи на общия интерфейс IComparable<T>. Вижте кода по-долу: [mw_shl_code=csharp,true]клас Лице :IComparable<Person>
{
Сравнете по възраст
public int CompareTo(Лице p)
{
Върни това. Възраст - p.Age;
}
}[/mw_shl_code] Параметрите на метода CompareTo са друг обект от същия тип, с който трябва да се сравни, връщаната стойност е int тип, ако връщаната стойност е по-голяма от 0, това означава, че първият обект е по-голям от втория, ако връщаната стойност е по-малка от 0, това означава, че първият обект е по-малък от втория, а ако връща 0, двата обекта са равни.
След като дефинирате стандартните правила за сравнение, можете да сортирате колекцията чрез метода Sort без параметри, както следва: [mw_shl_code=csharp,true]// Сортирайте колекцията според стандартните правила
личности. Sort();
//输出所有人姓名
foreach (Лице p в лица)
{
Console.WriteLine(p.Name); Редът на изходите е "Li Si", "Zhang San" и "Wang Wu"
}[/mw_shl_code] На практика често е необходимо колекцията да се сортира според различни правила, което изисква дефиниране на други правила за сравнение, които могат да бъдат дефинирани в метода Comparer, който принадлежи към <T>общия интерфейс на IComparer, моля, вижте следния код: [mw_shl_code=csharp,true]class NameComparer : IComparer<Person>
{
Екземпляри на storage sequencer
публичен статичен NameComparer Default = нов NameComparer();
Сравнете по име
public int Compare(Лице p1, лице p2)
{
return System.Collections.Comparer.Default.Compare(p1. Име, стр. 2. Име);
}
}[/mw_shl_code] Параметрите на метода Compare са два обекта от един и същи тип, които трябва да се сравняват, а стойността на връщане е от тип int, а правилата за обработка на възвръщаемата стойност са същите като тези на метода CompareTo. Comparer.Default връща вграден Comparer обект за сравняване на два обекта от един и същи тип. Ето как да сортирате колекцията с този новодефиниран компаратор: [mw_shl_code=csharp,true]//Сортирай колекцията по име
личности. Sort(NameComparer.Default);
//输出所有人姓名
foreach (Лице p в лица)
{
Console.WriteLine(p.Name); Редът на изходите е "Li Si", "Wang Wu" и "Zhang San"
}[/mw_shl_code] Можеш също да сортираш колекцията, като делегираш, първо, дефинираш метод, който делегатът да извика, за да съхранява правилата за сравнение, и можеш да използваш статичен метод. Вижте кода по-долу: [mw_shl_code=csharp,true]клас PersonComparison
{
Сравнете по име
публичен статичен int Име (Лице p1, лице p2)
{
return System.Collections.Comparer.Default.Compare(p1. Име, стр. 2. Име);
}
}[/mw_shl_code] Параметрите на метода са два обекта от един и същи тип, които трябва да се сравняват, връщаната стойност е от тип int, а правилото за обработка на възвръщаемата стойност е същото като на метода CompareTo.След това сортирайте колекцията чрез вградения общ делегат System. <T>Сравнение: [mw_shl_code=Шарп, вярно] <Person> System.Comparison NameComparison = new System.Comparison<Person>(PersonComparison.Name);
личности. Sort(NameComparison);
//输出所有人姓名
foreach (Лице p в лица)
{
Console.WriteLine(p.Name); Редът на изходите е "Li Si", "Wang Wu" и "Zhang San"
}[/mw_shl_code] Вижда се, че последните два метода могат да сортират колекцията според зададените правила, но авторът предпочита да използва метода на делегиране и може да обмисли да постави различни правила за сравнение в клас и след това да ги извиква гъвкаво. Търсене на генерични колекции
Търсенето е за намиране на елементи, които отговарят на конкретни условия от колекцията, като множество условия за търсене могат да бъдат дефинирани и извикани при нужда. Първо, дефинирайте критериите за търсене по следния начин: [mw_shl_code=csharp,true]клас Личност Предикат
{
Намерете хора на средна възраст (над 40 години)
публичен статичен бул, MidAge(Лице p)
{
ако (п. Възраст >= 40)
върни се истински;
Друго
отговорът е фалшив;
}
}[/mw_shl_code] Горните критерии за търсене се поставят в статичен метод с булев тип връщане, а елементите в колекцията, които отговарят на определени условия, връщат истинско или иначе невярно.След това търсете колекцията чрез вградения общ делегат System.Предикат<T>: [mw_shl_code=Шарп, вярно] System.Предикат<Person> MidAge Предикат = нов System.Предикат <Person>(PersonПредикат.MidAge);
Списък<Person> MidAgePersons = лица. FindAll(Средна възрастова предикат);
//输出所有的中年人姓名
foreach (Лице p в MidAgePersons)
{
Console.WriteLine(p.Name); Изход "Wang Wu"
}[/mw_shl_code] Разширяване на генеричните колекции
Ами ако искате да получите имената на всички хора в комплекта, разделени със запетая?
Като се има предвид, че функционалността, която един клас може да предостави, е ограничена, е естествено да се <T>помисли за разширяване на класа List, който също е клас и следователно може да бъде разширен чрез наследяване. Вижте кода по-долу: [mw_shl_code=csharp,true]// Дефинирай класа на колекцията Persons
Клас Личности: Списък<Person>
{
Вземи имената на всички в колекцията
публичен низ GetAllNames()
{
ако (това. Брой == 0)
return "";
String val = "";
foreach (Лице p в това)
{
val += p.Name + ",";
}
Върни Вал. Substring(0, val. Дължина - 1);
}
}
//创建并填充Persons集合
Persons PersonCol = нови лица();
ПерсонПолковник Add(p1);
ПерсоналПолковник Add(стр. 2);
ПерсоналПолковник Add(стр. 3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Изход "Джан Сан, Ли Си, Уанг У"[/mw_shl_code] Резюме:
Тази статия се фокусира върху използването на генерични колекции в C# 2.0 за реализиране на колекции, както и за разширяване на функцията за колекция, а правилното използване на генерични колекции може да намали много дублиране на работата и значително да подобри ефективността на разработката. Всъщност множествата са просто типично приложение на генериците, и ако искате да научите повече за генериците, можете да се консултирате с други релевантни материали. Надявам се тази статия да ви е била полезна :-)
| 
Публикувано в 11.11.2014 г. 8:56:04 ч.
|
|
|
Публикувано в 24.11.2014 г. 11:48:29 ч.
