Le collezioni sono un concetto importante nell'OOP, e il pieno supporto per le collezioni in C# è uno dei migliori del linguaggio.
Perché usare set generici?
Prima di C# 2.0, le collezioni potevano essere implementate in due modi principali:
a. Usa ArrayList
Mettere oggetti direttamente nell'ArrayList è intuitivo, ma poiché gli elementi nella collezione sono di tipo Object, devi fare una noiosa conversione di tipo ogni volta che la usi.
b. Utilizzare classi di raccolta personalizzate
Una pratica comune è ereditare una classe personalizzata dalla classe astratta CollectionBase e implementare una strong type collection incapsulando l'oggetto IList. Questo metodo richiede di scrivere una classe personalizzata corrispondente per ogni tipo di collezione, il che è molto lavoro. L'emergere di collezioni generiche risolve bene i problemi sopra descritti, e una sola riga di codice può essere utilizzata per creare un insieme di un tipo specificato. Cosa è il generico?
I generici sono nuovi elementi in C# 2.0 (chiamati template in C++) che vengono utilizzati principalmente per risolvere una serie di problemi simili. Questo meccanismo permette di passare il nome della classe come argomento al tipo generico e di generare l'oggetto corrispondente. Potrebbe essere meglio pensare ai generici (inclusi classi, interfacce, metodi, delegati, ecc.) come template, dove la parte variante viene sostituita dal nome della classe passato come argomento, portando a una nuova definizione di tipo. Il generico è un argomento relativamente ampio e non lo analizzerò in dettaglio qui, e chi è interessato può consultare le informazioni rilevanti. Come posso creare una collezione generica?
La classe generica List sotto il namespace System.Collections.Generic <T>viene utilizzata per creare collezioni, e la sintassi è la seguente: [mw_shl_code=cliccio,vero] <T> List ListOfT = nuova lista<T>(); [/mw_shl_code] La "T" è il tipo da utilizzare, che può essere di tipi semplici, come stringa, int o tipi definiti dall'utente. Vediamo un esempio specifico.
La classe Persona è definita come segue: [mw_shl_code=csharp,true] classe Persona
{
_name di corda privata; Nome
Private Int _age; Età
Crea un oggetto Persona
Persona pubblica (nome stringa, int età)
{
this._name= Nome;
this._age = Età;
}
Nome
Nome della corda pubblica
{
get { return _name; }
}
Età
pubblico int Età
{
get { return _age; }
}
}
//创建Person对象
Persona p1 = nuova persona ("Zhang San", 30);
Persona p2 = nuova persona ("Li Si", 20);
Persona p3 = nuova persona ("Wang Wu", 50);
//创建类型为Person的对象集合
Persone della Lista<Person> = nuova Lista<Person>();
//将Person对象放入集合
persone. Aggiunge (p1);
persone. Aggiunge (p2);
persone. Add(p3);
//输出第2个人的姓名
Console.Write(persons[1]. Nome); [/mw_shl_code] Come puoi vedere, le collezioni generiche semplificano notevolmente il codice di implementazione delle collezioni, attraverso il quale puoi facilmente creare collezioni di tipi specificati. Non solo, ma le collezioni generiche offrono anche funzioni più potenti, diamo un'occhiata all'ordinamento e alla ricerca in esse. Ordinamento delle collezioni generiche
L'ordinamento si basa sul confronto, e per ordinare devi prima confrontare. Ad esempio, se ci sono due numeri 1 e 2, per ordinarli, dobbiamo prima confrontare questi due numeri e ordinarli in base ai risultati del confronto. Se vuoi confrontare oggetti, la situazione è un po' più complicata, ad esempio, se confronti oggetti Persona, puoi confrontare per nome o per età, il che richiede di determinare le regole di confronto. Un oggetto può avere più regole di confronto, ma una sola regola predefinita, che viene posta nella classe che definisce l'oggetto. Le regole di confronto predefinite sono definite nel metodo CompareTo, che appartiene all'interfaccia generica IComparable<T>. Vedi il codice qui sotto: [mw_shl_code=sharp,true]classe Persona :IComparabile<Person>
{
Confronta per età
public int CompareTo(Persona p)
{
Restituisci questo. Età - p.Age;
}
}[/mw_shl_code] I parametri del metodo CompareTo sono un altro oggetto dello stesso tipo con cui confrontarsi, il valore di ritorno è di tipo int; se il valore di ritorno è maggiore di 0, significa che il primo oggetto è maggiore del secondo; se il valore di ritorno è inferiore a 0, significa che il primo oggetto è minore del secondo, e se restituisce 0, i due oggetti sono uguali.
Dopo aver definito le regole di confronto predefinite, puoi ordinare la collezione usando il metodo Sort senza parametri, come segue: [mw_shl_code=csharp,true]// Ordina la collezione secondo le regole predefinite
persone. Sort();
//输出所有人姓名
foreach (Persona p in persone)
{
Console.WriteLine(p.Name); L'ordine di uscita è "Li Si", "Zhang San" e "Wang Wu"
}[/mw_shl_code] In pratica, spesso è necessario ordinare la collezione secondo una varietà di regole diverse, il che richiede la definizione di altre regole di confronto, che possono essere definite nel metodo Compare, che appartiene <T>all'interfaccia generica IComparer; si veda il seguente codice: [mw_shl_code=csharp,true]classe NameComparer : IComparer<Person>
{
Istanze di sequencer di memoria
pubblico statico NameComparer Default = nuovo NameComparer();
Confronta per nome
public int Confronta (Persona p1, Persona p2)
{
return System.Collections.Comparer.Default.Compare(p1. Nome, p2. Nome);
}
}[/mw_shl_code] I parametri del metodo Compare sono due oggetti dello stesso tipo da confrontare, e il valore di ritorno è di tipo int, mentre le regole di elaborazione dei valori di ritorno sono le stesse del metodo CompareTo. Comparer.Default restituisce un oggetto Comparer integrato per confrontare due oggetti dello stesso tipo. Ecco come ordinare la collezione con questo confrontatore appena definito: [mw_shl_code=csharp,true]//Ordina la collezione per nome
persone. Ordin(NameComparer.Default);
//输出所有人姓名
foreach (Persona p in persone)
{
Console.WriteLine(p.Name); L'ordine di uscita è "Li Si", "Wang Wu" e "Zhang San"
}[/mw_shl_code] Puoi anche ordinare la collezione delegando, innanzitutto, definire un metodo che il delegato chiama per memorizzare le regole di confronto, e puoi usare un metodo statico. Vedi il codice qui sotto: [mw_shl_code=clipeto,vero]classe Confronto Persona
{
Confronta per nome
pubblico static int Nome(Persona p1, Persona p2)
{
return System.Collections.Comparer.Default.Compare(p1. Nome, p2. Nome);
}
}[/mw_shl_code] I parametri del metodo sono due oggetti dello stesso tipo da confrontare, il valore di ritorno è di tipo int, e la regola di elaborazione dei valori di ritorno è la stessa di quella del metodo CompareTo.Poi ordina la collezione tramite il sistema delegato generico integrato. <T>Confronto: [mw_shl_code=cliccio,vero] <Person> NomeConfrontoSistema.Confronto = nuovo <Person>Sistema.Confronto(PersonComparison.Name);
persone. Ordinamento (ConfrontoNome);
//输出所有人姓名
foreach (Persona p in persone)
{
Console.WriteLine(p.Name); L'ordine di uscita è "Li Si", "Wang Wu" e "Zhang San"
}[/mw_shl_code] Si può vedere che questi ultimi due metodi possono ordinare la collezione secondo le regole specificate, ma l'autore preferisce usare il metodo di delega e può considerare di inserire varie regole di confronto in una classe e poi chiamarle in modo flessibile. Cerca collezioni generiche
La ricerca serve a trovare elementi che soddisfano condizioni specifiche dalla collezione, e possono essere definite e chiamate più condizioni di ricerca secondo necessità. Per prima cosa, definisci i criteri di ricerca come segue: [mw_shl_code=clipeto,true]classe PredicatoPersona
{
Trova persone di mezza età (over 40)
bool statico pubblico Mezza Età (Persona p)
{
se (p.Età >= 40)
ritorno vero;
altrimenti
return false;
}
}[/mw_shl_code] I criteri di ricerca sopra indicati sono inseriti in un metodo statico con un tipo di ritorno booleano, e gli elementi nella collezione che soddisfano determinate condizioni restituiscono veri, altrimenti falsi.Poi cerca nella collezione tramite il sistema delegato generico integrato. Predicato<T>: [mw_shl_code=cliccio,vero] System.Predicate<Person> MidAgePredicate = nuovo <Person>System.Predicate(PersonPredicate.MidAge);
Elenco<Person> Persone di Mezza Età = persone. FindAll(MidAgePredicate);
//输出所有的中年人姓名
foreach (Persona p in MidAgePersons)
{
Console.WriteLine(p.Name); Output "Wang Wu"
}[/mw_shl_code] Estensione delle collezioni generiche
E se volessi ottenere i nomi di tutte le persone nel set, separati da una virgola?
Considerando che la funzionalità che una singola classe può fornire è limitata, è naturale pensare <T>di estendere la classe List, che è anch'essa una classe e quindi può essere estesa tramite ereditarietà. Vedi il codice qui sotto: [mw_shl_code=csharp,true]// Definisci la classe di collezione Persone
Classe Persone : Elenco<Person>
{
Raccogli i nomi di tutti nella collezione
stringa pubblica GetAllNames()
{
se (questo. Count == 0)
ritorno "";
stringa val = "";
foreach (Persona p in questo)
{
val += p.Name + ",";
}
Torna Val. Substring(0, val. Lunghezza - 1);
}
}
//创建并填充Persons集合
Persone PersonCol = nuove persone();
PersonCol.Add(p1);
PersonCol.Add(p2);
PersonCol.Add(p3);
//输出所有人姓名
Console.Write(PersonCol.GetAllNames()); Output "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Sommario:
Questo articolo si concentra sull'uso dei generici in C# 2.0 per implementare le collezioni, nonché per estendere la funzione di raccolta, e il corretto utilizzo delle collezioni generiche può ridurre molta duplicazione di lavoro e migliorare notevolmente l'efficienza dello sviluppo. In effetti, i set sono solo un'applicazione tipica dei generici, e se vuoi saperne di più sui generici, puoi consultare altri materiali rilevanti. Spero che questo articolo ti sia stato utile :-)
| 
Pubblicato su 11/11/2014 08:56:04
|
|
|
Pubblicato su 24/11/2014 11:48:29
