În C#, deducerea tipurilor generice reprezintă capacitatea compilatorului de a deduce argumentele de tip pentru o metodă generică sau un tip generic, pe baza contextului în care sunt utilizate. Acest lucru înseamnă că nu trebuie să specificați explicit argumentele de tip, deoarece compilatorul poate deduce automat aceste informații. Să luăm un exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
PrinteazaValoare<int>(2);
PrinteazaValoare<decimal>(2.3M);
Console.ReadLine();
}
static void PrinteazaValoare<T>(T param)
{
Console.WriteLine("Valoarea este " + param);
}
}
}
|
Ați văzut acest exemplu anterior, în lecția în care v-am prezentat tipurile generice. Ceea ce nu ați știut este că putem rescrie acest exemplu astfel:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
PrinteazaValoare(2);
PrinteazaValoare(2.3M);
Console.ReadLine();
}
static void PrinteazaValoare<T>(T param)
{
Console.WriteLine("Valoarea este " + param);
}
}
}
|
Motivul pentru care pot apela metoda PrinteazaValoare() fără a specifica tipurile valorilor care sunt utilizate ca parametrii pentru apelul metodei generice este acela că în C#, compilatorul le poate deduce din valorile care au fost transmise. Deoarece în primul apel, metoda este apelată cu numărul 2, care este un int, compilatorul poate deduce că tipul generic T devine un int, astfel încât nu trebuie să îi spun din nou, explicit, prin specificarea sa între parantezele ascuțite. La fel și pentru cel de-al doilea apel, dacă valoarea transmisă parametrului a fost 2.3M, cu siguranță acea valoare este de tip decimal, nu este nevoie să o specific din nou, așa PrinteazaValoare<decimal>(2.3M);. De asemenea, acesta este motivul pentru care partea decimal este de o culoare mai închisă în Visual Studio, pentru a face mai vizibil faptul că nu este necesară, parametrul generic poate fi dedus.
Deci, deducerea tipurilor generice este o funcționalitate utilă din C#, care permite compilatorului să deducă automat argumentele de tip pentru o metodă sau un tip generic, pe baza contextului în care este utilizat. Acest lucru poate face codul mai concis și mai ușor de citit, deoarece nu este nevoie să specificați tipurile în toate cazurile.
Rețineți că inferența (deducerea) tipului funcționează prin examinarea tipurilor argumentelor transmise către o metodă generică, pentru a determina parametrul de tip al metodei. Acest lucru înseamnă că inferența poate fi utilizată doar în metode generice, nu și în clase generice. De exemplu, acest cod va produce o eroare de compilare:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
using
System;
namespace
BunaLume
{
class
OClasa<T>
{
public OClasa(T param) { }
}
class
Program
{
static void Main(string[] args)
{
OClasa oClasa = new OClasa(5);
Console.ReadLine();
}
}
}
|
În acest caz, sunt obligată să fiu specifică: OClasa<int> oClasa = new OClasa<int>(5), chiar dacă ar fi posibil pentru compilator să se uite și să vadă că am folosit numărul 5, și să încerce să deducă tipul de acolo.
Rețineți, cuvântul cheie var poate fi utilizat în combinație cu inferența de tip pentru a crea variabile fără a specifica explicit tipul lor. Atunci când se folosește cuvântul cheie var, compilatorul va deduce tipul variabilei în funcție de tipul expresiei utilizate pentru a o inițializa. În plus, inferența de tip nu funcționează întotdeauna cu anumite tipuri mai complexe, cum ar fi array-uri sau tipuri anonime.