kodehoved

Generiske typer tillader, at vi kan definere en type med et eller flere typeparametre. En sådan type kaldes en generisk typedefinition. Den er en type i sig selv, men den er ikke så interessant, for vi kan ikke oprette instanser af den. For at kunne det, er vi nødt til at specificere det korrekte antal konkrete typeparametre. Herefter kan vi konstruere konkrete typer baseret på den generiske typedefinition. 

For at illustrere dette med et eksempel, så er List<T> en generisk typedefinition, mens List<string> er en konkret type. 

Forudsætninger

Formålet med dette indlæg er at vise, hvordan generiske typer opfører sig på kørselstidspunktet, men inden vi kommer så langt, er der lige et par basale kendsgerninger, der skal være på plads. De er forhåbentlig kendte af de fleste, men for at sikre et fælles udgangspunkt, følger her en kort gennemgang. 

En type er kendetegnet ved at have en mængde data samt et antal metoder, der som minimum inkluderer en constructor og de metoder, typen arver fra typen Object. Der er altså en direkte forbindelse mellem typer, data og metoder. Det vigtige i denne sammenhæng er forbindelsen mellem typer og metoder. 

Som bekendt opererer .NET og dermed C# med to forskellige slags typer: referencetyper og værdityper. Referencetyper allokeres altid på heapen, og en variabel af en referencetype er således altid en reference til den konkrete instans. Værdityper allokeres som udgangspunkt på stakken, med mindre de er en del af en referencetype, i hvilket fald de allokeres på heapen sammen med den omsluttende type. I alle tilfælde er værdien af en værditype, den faktiske værdi af den konkrete instans og ikke en reference, som tilfældet er for referencetyper. 

Med disse grundbegreber på plads er det tid til at se lidt på generiske typer, som de tager sig ud i afviklingsmiljøet.

Generisk<værditype>

Hvad sker der, når vi opretter en List<int>? Før generiske typer blev indført i CLR 2.0, ville vi få en samling af boxed ints, men det er jo netop dette problem, generiske typer adresserer, så det er ikke tilfældet længere. Vi forventer således, at få en type, der arbejder direkte på ints. Men vi forventer også, at List<T> kan håndtere andre værdityper som f.eks. DateTime. Hvordan håndterer den underliggende generiske type dette?

Vi kan lave en lille applikation, der opretter en liste af hver slags og bruge WinDbg til at undersøge, hvordan disse repræsenteres i CLRen. Så givet to lister med værdityper:

var numbers = new List<int>() { 1, 2, 3 };
var dates = new List<DateTime> { DateTime.Now, DateTime.Now.AddDays(1) };

 
Hvordan ser de ud under afviklingen? Uanset hvordan generiske typer end må være skruet sammen, ved vi, at List<T> er en referencetype, og da vi har to instanser i spil, forventer vi at kunne lokalisere disse på heapen.  Det kan vi gøre ved hjælp af !dumpheap. 

      MT    Count    TotalSize Class Name
0238c808        1           24 System.Collections.Generic.List`1[[System.DateTime, mscorlib]]
0238c12c        1           24 System.Collections.Generic.List`1[[System.Int32, mscorlib]]

Jeg har forkortet resultatet af kommandoen en del, men ganske som forventet finder vi to instanser. Læg mærke til, hvordan generiske typer repræsenteres. Først har vi selve navnet. Derefter følger `1 – der betyder, at vi i dette tilfælde har en generisk type med et typeparameter. Typen af dette optræder umiddelbart efter. Til sammenligning vil en Dictionary<int, string> være repræsenteret som System.Collections.Generic.Dictionary`2[[System.Int32, mscorlib],[System.String, mscorlib]]. ILDasm bruger samme notation for generiske typer. 

Indtil videre er der intet ud over den spøjse syntaks, der indikerer, at vi har med generiske typer at gøre, men vi ved, at List<T> erklærer et antal metoder, der opererer på elementer af typen T – f.eks. er Add()-metoden defineret som Add(T).  Det interessante er derfor, om det er den samme metode, der håndterer Add(int) og Add(DateTime). Det kan vi se nærmere på ved hjælp af kommandoen !dumpmt og det tilhørende -md flag, der lister alle metoder for en given type. 

Det resulterer i en ret lang liste for hver type, så jeg har forkortet en del, men læg mærke til, hvordan det ser ud for List<int>:

Name: System.Collections.Generic.List`1[[System.Int32, mscorlib]]
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
02358658   0238bf14      JIT System.Collections.Generic.List`1[[System.Int32, mscorlib]].Add(Int32)
02358628   0238be54      JIT System.Collections.Generic.List`1[[System.Int32, mscorlib]]..ctor()

Og for List<DateTime>:

Name: System.Collections.Generic.List`1[[System.Int32, mscorlib]]
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
0235a730   0238c5f0      JIT System.Collections.Generic.List`1[[System.DateTime, mscorlib]].Add(System.DateTime)
02358778   0238c530      JIT System.Collections.Generic.List`1[[System.DateTime, mscorlib]]..ctor()

Ikke alene bruger metoderne, de specifikke typer, de ligger på forskellige adresser i hukommelsen. Ergo, har de to varianter hver deres implementering af Add(T). Det samme er sågar tilfældet for deres respektive default constructors. List<int> og List<DateTime> ser altså ikke ud til at dele noget på afviklingstidspunktet. 

Det skyldes, at CLRen af hensyn til performance opretter nye, komplette typer for generiske typer, når de initialiseres med forskellige værdityper. Opretter vi flere instanser af f.eks. List<int>, benytter de dog samme kode helt som forventet, men generiske typer med konstrueret med forskellige værdityper resulterer i nye, selvstændige typer. 

Generisk<referencetype>

Anderledes forholder det sig for referencetyper, hvilket vi kan konstatere, hvis vi laver samme øvelse for nedenstående lister:

var strings = new List<string> { "hello", "world" };
var objects = new List<SomeType> { new SomeType(42), new SomeType(1337) };

 
Også her forventer vi to instanser på heapen, og tag mit ord for, at de er der. Lad os i stedet se på, om hvordan Add(T) er håndteret for referencetyper.

Her er et udsnit af metoderne for List<string>:

Name: System.Collections.Generic.List`1[[System.Int32, mscorlib]]
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
0235a960   0238cc8c      JIT System.Collections.Generic.List`1[[System.__Canon, mscorlib]].Add(System.__Canon)
0235a858   0238cbcc      JIT System.Collections.Generic.List`1[[System.__Canon, mscorlib]]..ctor()

Og her er det tilsvarende udsnit for List<SomeType>:

Name: System.Collections.Generic.List`1[[System.Int32, mscorlib]]
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
023651c9   0238cc8c      JIT System.Collections.Generic.List`1[[System.__Canon, mscorlib]].Add(System.__Canon)
0235a858   0238cbcc      JIT System.Collections.Generic.List`1[[System.__Canon, mscorlib]]..ctor()

Bemærk, at her er adresserne på de listede metoder identiske mellem de to instanser. List<string> kalder altså den samme Add(T) som List<SomeType>. Selv default constructoren er delt mellem de to varianter. 

Læg også mærke til, at de to lister, står anført til at arbejde på en type ved navn System.__Canon. Hvad er nu det for en type? Søger vi efter den på heapen, finder vi ingen instanser, og hvis vi inspicerer den med !name2ee eller i Reflector, ser vi, at den ligner Object til forveksling. 

Navnet kommet af canonical, men hvad bruges typen til? Da vi jo ikke kan oprette instanser af generiske typedefinitioner uden at binde dem til en eller flere konkrete typer, har vi brug for et sted at placere koden for generiske typer, så de kan deles mellem forskellige varianter af den generiske type. Det er her System.__Canon kommer ind i billedet. Koden til List<string> og List<SomeType> er således delt gennem den konkrete instans baseret på __Canon. På afviklingstidspunktet finder CLRen ud af hvilken specifik type __Canon er stand-in for, så forekomster af T kan udskiftes med den konkrete type. 

Med andre ord opfører generiske typer sig altså anderledes, når de bruges med referencetyper, end når de anvendes med værdityper. Generiske typer konstrueret med en referencetype deler kode. Generiske typer konstrueret med en værditype deler ikke kode.