Ormai o li conosciamo o ne abbiamo sentito parlare.
sono forse una delle novità più importanti introdotte da C# 2.0.
i Generics in poche parole permettono di parametrizzare, classi, interfacce, metodi, strutture e delegati, rispetto al tipo che manipoleranno.
ma cosa succede se dobbiamo invocare un metodo di un tipo passato come parametro?.
la prima soluzione, che siamo tutti abituati a utilizzare, è eseguire il casting nel tipo che esponga tale metodo

public class Dictionary<K,V>
{
public void Add(K key, V value)
{
...
if (((IComparable)key).CompareTo(x) < 0) {...}
...
}
}

pur funzionando perfettamente il precedente codice presenta alcuni inconvenienti, il primo più evidente è la neccesita del controllo dinamico dei tipi in runtime, "castare" ha un costo in termini di prestazioni, secondo incenveniente è la possibilità che si verifichino errori se il casting non dovesse andare a buon fine.per questo ci vengono in aiuto i vincoli ( Constraints ), ecco il solito codice riscritto perchè il tipo rispetti certi vincoli:

public class Dictionary<K,V> where K: IComparable
{
public void Add(K key, V value)
{
...
if (key.CompareTo(x) < 0) {...}
...
}
}

questo toglie la necessita del controlli runtime sui tipi, non che la necessità del casting.

onestamente devo riflettere su questa cosa:
in che casi dovrei preferire un Generic con i vincoli, rispetto al "classico" uso delle interfacce?.
le prestazione dei Generic sono migliori anche in questo caso?.(sembrerebbe di si)
difatto i vincoli (non si chiamerebbero così senno),limitano l'uso dei Generic, rendendo la classe parzialmente aperta.

fine delle cose serie (per me)
ne approfitto per farmi gi auguri di buon compleanno :), oggi entro ufficialmente negli enta.
sono passati 30 anni da quel lontano 1 settembre, il tempo scorre velocemente, non accetta ritardatari.
si può solo seguirlo, l'unici che non subiscono cambiamenti sono i "bollicini" che mi accompagnano dall'adolescenza, ormai sono compagni di viaggio.