Rozhodl jsem se, že si pořádně prostuduju genericitu se všemi jejími možnostmi a narazil jsem na pojem typového odvozování, kdy je kompilátor schopný odvodit, typy použitých argumentů. A obecně chápu, o co jde, ale nemůžu rozlousknout jeden konkrétní případ. Mohl by mi někdo prosím vysvětlit nějak polopaticky jednotlivé řádky v metodě main, jakým způsobem došlo k odvození?

Oznacme si ty definice metody F jako A a B, tedy A = static void F<T>(int x, T y), B = static void F<T>(T x, long y). Kompilator se pak snazi najit “nejlepsiho kandidata” ktery musi byt jednoznacny. Muj postup kdyz chci zjistit ktere pretizeni pouzije je nasledujici (netvrdim ze je korektni, nejsem az takovy matematicky fajnsmekr abych to overoval :

1) Prvni faze se snazi najit vhodne pretizeni “topologicky”, tzn. Bezi zprava doleva a kontroluje typy parametru, rozlisuje se take jestli je typovy parametr explicitne definovan nebo jestli si za nej kompilator muze dosadit co chce
2) Druha faze (pokud je potreba jeste dale rozsoudit kandidaty) uz budi zdani jiste vlastni inteligence kompilatoru (coz prave muze obcas zmast). Kompilator vychazi ze znalosti ciselnych rozsahu primitivnich typu a muze z toho vyvodit optimalizace ktere mohou rozsoudit patovou situaci z prvni faze


Ted k tomu prikladu po radcich:

1) Prvni faze hleda F(int, int) ptz obe hodnoty v parametru jsou int (kdyz napises takhle ve visual studiu cislo, implicitne se bere jako int, pokud se do intu vleze atd). To najde beze zbytku v metode A, kandidat B ma mensi “rank” ptz by se u nej musel pretypovat int na long, tudiz A je vitez
2) Tady uz vstupuje do hry i faze 2. Vybere se B ptz kompilator “zna” ciselne rozsahy vestavenych ciselnych typu a vsimne si ze 324 je mimo rozsah byte (0-255). Od zacatku: kompilator hleda F(int, int), metoda A je F(int, byte), B je F(byte, long). Kompilator by nemel vyuzit ani jednu metodu a zahlasit ze nemuze najit vhodneho kandidata a to proto ze int nejde na byte pretypovat, coz by musel udelat v obou pripadech. Nestane se tak ptz vidi ze kdyz pouzije B bude pretypovavat hodnotu 5 z int na byte coz “jde” (a pak jeste z int na long coz je implicitni). To umoznuje fakt ze kompilator zna ciselny rozsah byte a tedy vi ktere hodnoty se do nej bezpecne vejdou.
3) To same co prvni radek (tudiz specifikovat <int> je pro hodnoty 5 a 324 redundatni)
4) Prvni faze rychle selze. Druha take, nelze skrze rozsahy usoudit na lepsiho kandidata: A je F(int, double), B je F(double, long). Z int existuje implicitni konverze jak na double, tak na long, double i long pojmou 5 a 324 beze ztraty tudiz oba kandidati maji stejny “rank” a musi rozhodnout programator ptz cilove pretizeni musi byt jednoznacne nalezeno
5) Hleda se F(int, long). Prvni faze zjisti idealni dosazeni A ktere bude F(int, long), B pak bude take F(int, long). Druha faze uz nepomuze (z pohledu kompilatoru je to jako bys mel v projektu dve pretizeni se stejnou signaturou).


Uff, to je zase wall-of-text

Teda nevim jestli ti to pomuze , snad to nekdo dokaze vysvetlit jednoduseji, jinak oficialni dokumentace je tady
http://msdn.microsoft.com/en-us/library/bb308966.aspx

sekce 26.3.3

Zjednodusene vysvetleni : jde o implicitni konverze.

324 (literal) je implicitne konvertovatelne do libovolneho numerickeho typu (krome byte) => v pripade implicitnich konverzi se kompilator nemuze rozhodnout mezi jejimi variantami.

Krome pripadu, kde mas predpis int, T:long nebo T:int, long, tam se nemuze kompilator nikdy rozhodnout.