[.NET]Generics definitie

[Woy]

Ik heb een Generic type, waarbij ik op de generic parameter een constraint leg dat hij van een type moet zijn die ook een generic parameter heeft.

Dus het volgende

C#:

class Foo<T>{}

class Bar<T, T2> where T : Foo<T2> {}

Als ik een bar defineer moet dat dus op de volgende manier

C#:

Bar bar = new Bar<Foo<int>, int>();

Het probleem wat ik hier mee heb is dat de 2e type parameter altijd int moet zijn, en ook niks anders mag zijn. Dan is het toch eigenlijk zinloos om die op te geven? ( Behalve dat het anders niet compiled natuurlijk )
Immers zou de compiler uit de volgende code alle informatie kunnen halen die hij nodig heeft om de Type parameters te vullen

C#:

Bar bar = new Bar<Foo<int>>();

Dat zou ook haalbaar zijn als ik in mijn constraint een open generic type zou kunnen gebruiken ( Wat niet mag in de huidige specificatie )

C#:

class Bar<T> where T : Foo<> {}

Natuurlijk is dit niet altijd voldoende informatie als ik in Bar ook gebruik zou maken van de type parameter van Foo, maar stel dat het alleen een container type is.

Dit zou ik op kunnen lossen door per type parameter van Foo een subclass van Bar te maken

C#:

public class BarInt<T> : Bar<T, int> where T : Foo<int> {}

Maar dat is natuurlijk niet echt handig want dan heb je potentieel enorm veel extra classes.

Maak ik nou een denkfout dat de 2e type parameter nutteloos is? En is er mischien nog een andere manier om dit eleganter op te lossen?


Ik hoop dat het een beetje duidelijk is wat ik bedoel

[.oisyn]

rwb schreef op vrijdag 12 december 2008 @ 12:16:
Het probleem wat ik hier mee heb is dat de 2e type parameter altijd int moet zijn, en ook niks anders mag zijn. Dan is het toch eigenlijk zinloos om die op te geven? ( Behalve dat het anders niet compiled natuurlijk )

Nee hoor:

C#:

class Aap : Foo<float> { };
Bar b = new Bar<Aap, float> { };

voldoet ook aan de constraints. Ok, je kunt stellen dat de compiler de subclasses van Aap kan doorzoeken om de generic parameter van Foo te bepalen, maar volgens mij doet de compiler niet aan dergelijke type deduction (wat als Foo een interface was en Aap implementeert zowel Foo<int> als Foo<float>?)

[ Voor 27% gewijzigd door .oisyn op 12-12-2008 12:37 ]

[Woy]

.oisyn schreef op vrijdag 12 december 2008 @ 12:32:
[...]


Nee hoor:

C#:

class Aap : Foo<float> { };
Bar b = new Bar<Aap, float> { };

voldoet ook aan de constraints. Ok, je kunt stellen dat de compiler de subclasses van Aap kan doorzoeken om de generic parameter van Foo te bepalen, maar volgens mij doet de compiler niet aan dergelijke type deduction

Nee dat doet hij inderdaad niet, maar ik wou dus weten of daar een goede reden voor was dat hij dat niet deed.

(wat als Foo een interface was en Aap implementeert zowel Foo<int> als Foo<float>?)

En dat is dus idd een goede reden, waar ik nog niet aan gedacht had. In het geval van classes zou het nog wel kunnen, maar dat zou weer niet echt consistent gedrag zijn natuurlijk.

Maar dan blijft mijn voorbeeld

C#:

class Bar<T> where T : Foo<> {}

Nog steeds voor sommige gevallen een oplossing waar de Type parameter van Foo niet interessant is. Volgens mij heef Java trouwens iets dergelijks alleen dan met een ?, maar ik heb Generics in Java eigenlijk nooit echt goed bekeken, dus mischien heb ik het fout ( De syntax ieder geval )

Java:

class Bar<T> where T : Foo<?> {}

C# kent overigens ook wel "open generic types" maar die zijn hier niet te gebruiken. het volgende mag bijvoorbeeld wel

C#:

Type t = typeof( Foo<> );

[ Voor 33% gewijzigd door Woy op 12-12-2008 13:04 ]