Una caratteristica molto interessante del framework è l'inferenza dei tipi, cioè la capacità del compilatore di capire quali sono i tipi da usare senza che il programmatore li dichiari esplicitamente. Questa caratteristica è stata notevolmente utilizzata nel framework 3.0, ma è presente anche nel 2.0.
Ad esempio:
class
FooClass
{
public
void Test() {
Foo<int, string>(10, "aaa");
Foo(10, "aaa");
Foo("bbb", 10);
}
void Foo<I, J>(I parA, J parB) {
Console.WriteLine("First method");
}
}
Nel metodo Test, le chiamate al metodo Foo sono tutte lecite. Nel primo caso vengono esplicitati i parametri di tipo, nel secondo il compilatore "conclude" che i tipi I e J sono rispettivamente int e string, mentre nel terzo caso I e J sono rispettivamente string e int. L'inferenza dei tipi rende meno prolisso il codice ma nasconde delle insidie.
Come più volte ha dimostrato Adrian nei suoi post, quando si lascia al compilatore l'interpretazione del nostro codice, non sempre le scelte intraprese sono quelle che noi ci aspetteremo. Ad esempio:
class
FooClass
{
public
void Test() {
Foo<int, string>(10, "aaa");
Foo(10, "aaa");
}
void Foo<I, J>(I parA, J parB) {
Console.WriteLine("First method");
}
void Foo<I, J>(int parA, string parB){
Console.WriteLine("Second method");
}
}
In questo caso l'output generato chiamando il metodo Test sarà:
First method
Second method
Quindi quando specifichiamo i parametri di tipo int e string il compilatore sceglie il primo dei due metodi, anche se a qualcuno sembrerebbe più logico il secondo. Se non specifichiamo i parametri di tipo, il compilatore sceglie il secondo dei metodi.