Che dire... una delle grandi novità del Framework 2 saranno i Generics che permettono di inserire nelle proprie classi oggetti senza definirne il tipo. Ne ho già parlato tempo fa consigliando dei link. Non voglio andare oltre.

Tra i vantaggi presenti utilizzando questo tipo di approccio allo sviluppo di classi è l'utilizzo di oggetti senza dover effettuare casting, boxing o quant'altro. Che sto a dì? Vediamo un esempio con la classe Hashtable:

Hashtable ht=new Hashtable();
ht[1]="a";
ht[2]="b";
ht[3]="c";
' Prendo la stringa presente
string s=ht[1].ToString();

Per poter prendere il valore presente nell'Hasthable abbiamo dovuto convertire il valore preso in stringa per non ottenere un errore. Dal Framework 2, è presente un oggetti Hashtable che permette l'utilizzo dei Generics. Il suo nome è "Dictionary" (confesso che mi sono già infatuato di questo oggetto!). Vediamo l'esempio qui sopra scritto con il nuovo oggetto:

Dictionary<int,string>ht=new Dictionary<int><int><int><int,string>();
ht[1]="a";
ht[2]="b";
ht[3]="c";
' Prendo la stringa presente
string s=ht[1];</int></int></int>

Ora possiamo prendere il valore dall'oggetto senza nessun tipo di conversione. Com'è possibile questo? Grazie alla possibilità di dichiarare tra le "<>" gli oggetti interessati per i nostri scopi.

Ok, comodo... ma prestazionalmente? Ecco dunque il mio dubbio del giorno: "Qual è la differenza di prestazioni tra le due tecniche? Vale la pena, oltre la comodità di non dover ogni volta convertire gli oggetti, di utilizzare i Generics?". Non ci rimane da fare che fare dei test a riguardo anche se, essendo solo nella versione beta 1, le prestazioni possono mutare sia in peggio che in meglio per i Generics.

Il mio test si basa nell'inserimento, come negli esempi qui sopra, di migliaia di oggetti in entrambi gli oggetti (Hashtable e Dictionary):

Hashtable collection1;
Dictionary<int,string> collection2;
collection1 = new Hashtable();
collection2 = new Dictionary<int><int><int><int,string>();
for (int i = 0; i < 100000; i++)
{
  collection1[i] = "a" + i.ToString();
  collection2[i] = "a" + i.ToString();
}</int></int></int>

Quindi il test si è basato sulla misurazione del tempo per iterare tra i dati inseriti inserendo il valore preso in una variabile dello stesso tipo dell'oggetto inserito; nel mio esempio, "string". Ecco il codice per l'Hashtable:

string dato;
for (int i = 0; i < collection1.Count; i++)
  dato = collection1[i].ToString();

E quello con il Dictionary e Generics:

string dato;
for (int i = 0; i < collection2.Count; i++)
  dato = collection2[i];

Notato che non c'è la conversione con il "ToString()"? Ok, ok, ma le prestazioni? Ecco il tempo che entrambe le tecniche hanno utilizzato per concludere il ciclo:

• Hashtable: 0,017905 s
• Dictionary (Generics): 0,006804 s

La metà del tempo con i Generics... Mica male... Pensando che i Generics hanno altri vantaggi che non si fermano alla comodità di non dover convertire gli oggetti...

La Juve dopo due giornate è prima in classifica.