Il .NET Framework mette a disposizione a noi sviluppatori un ampio numero di collezioni di oggetti, o stutture dati, utili a salvare, leggere o effettuare una qualsiasi tipo di manipolazione su vari tipi di oggetti.
Queste le principali collezioni (presenti sotto il namespace System.Collections):
| ArrayList | un array di oggetti (qualsiasi tipo) di larghezza non definita a priori | | BitArray | un array di valori booleani (false per il valore binario 0 e true per il valore binario 1) | | Hashtable | una collezione di coppie chiave-valore | | Queue | una collezione di tipo "first-in, first-out" | | Stack | una collezione di tipo "last-in, first-out" | | DictionaryBase | una superclasse per implementare collezioni di coppie chiave-valore | | CollectionBase | una superclasse per implementare collezioni custom (o anche dette Strongly Typed Custom Collections) |
Oltre a questo tipo di oggetti, il framework ci da la possibilità di crearcene dei nostri, customizzati, ereditando o dalla classe DictionaryBase (per creare custom collection di coppie di chiave-valore) o dalla classe CollectionBase (per creare custom collection di oggetti custom predefiniti).
Nell'esempio di oggi vediamo appunto come creare una custom collection, contenente oggetti da noi definiti, ciclabile tranquillamente tramite cicli for o foreach e con metodi e proprietà utili ad effettuare le normali operazioni di aggiunta, ricerca e rimozione di oggetti.
La classe CollectionBase deriva direttamente dalla classe Object, ed implementa le interfacce IList, ICollection ed IEnumerable. Noi, quindi, per creare la nostra collezione dobbiamo implementare l'indexer (la proprietà che ci permette di recuperare un oggetto dalla collezione specificando il suo indice all'interno di due parentesi quadre), e questa lista di metodi:
| IList.Add() | aggiunge un oggetto alla collezione | | IList.Insert() | inserisce un oggetto in una posizione specificata della collezione | | IList.Remove() | rimuove un oggetto dalla collezione | | IList.Contains() | determina quando la collezione contiene o meno un oggetto | | IList.IndexOf() | determina l'indice specifico di un determinato oggetto della collezione | | ICollection.CopyTo() | copia gli elementi della collezione in un'array di quel tipo di elementi |
Tutto ciò, ppoggiandoci sulla proprietà List della classe CollectionBase.
using System;
using System.Collections;
namespace Peppe.Articoli.Collections
{
/// <summary>
/// Custom Collection ereditata da CollectionBase
/// </summary>
public class myCustomCollection : CollectionBase
{
//Costruttore
public myCustomCollection()
{}
//Proprietà
public myCustomItem this[int index]
{
get{return (myCustomItem)List[index];}
set{List[index] = value;}
}
//Metodi
public int Add(myCustomItem item)
{
return List.Add(item);
}
public void Insert(int index, myCustomItem item)
{
List.Insert(index, item);
}
public void Remove(myCustomItem item)
{
List.Remove(item);
}
public bool Contains(myCustomItem item)
{
return List.Contains(item);
}
public int IndexOf(myCustomItem item)
{
return List.IndexOf(item);
}
public void CopyTo(myCustomItem[] array, int index)
{
List.CopyTo(array, index);
}
}
}
Il nostro oggetto d'esempio, "myCustomItem", l'ho definito come segue, creando solamente una proprietà di tipo string, in modo tale da poter effettuare un minimo di test sulla collection.
using System;
namespace Peppe.Articoli.Collections
{
/// <summary>
/// Esempio oggetto Custom
/// </summary>
public class myCustomItem
{
//Fields
protected string myCustomField;
//Costruttore
public myCustomItem()
{
}
//Proprietà
public string myCustomProperty
{
get{return this.myCustomField;}
set{this.myCustomField = value;}
}
}
}
Una volta creata la nostra custom collection e il nostro oggetto custom, vediamo come utilizzarle in concreto. Nel file da scaricare troverete una Class Library contenente la collection ed una ConsoleApplication per testarne il funzionamento.
Creiamo un nuovo oggetto di tipo myCustomCollection
myCustomCollection coll = new myCustomCollection();
Poi creiamo due oggetti d'esempio, di tipo myCustomItem
myCustomItem item1 = new myCustomItem();
item1.myCustomProperty = "Pippo";
myCustomItem item2 = new myCustomItem();
item2.myCustomProperty = "Pluto";
e li aggiungiamo alla nostra collezione
coll.Add(item1);
coll.Add(item2);
per vedere, quindi, il contenuto della collection, possiamo scorrerla attraverso un ciclo foreach di questo tipo:
foreach(myCustomItem item in coll)
{
Console.WriteLine(item.myCustomProperty);
}
N.B.: questa possibilità ci è stata data dall'interfaccia IEnumerable.
Questo è giusto un esempio tecnico sull'argomento delle Custom Collection; il concetto può essere chiaramente applicato ad un qualsiasi tipo di soluzione. Per farvi un esempio, io ho usato questa tecnica per rappresentare la collezione degli elementi "item" presenti all'interno di un feed rss nella libreria dotRSS.
|
|
|