[C#] Type inference met generics

[GrimaceODespair]

Ik heb een generic service (MyService) die overerft van een generic interface (IService). De service is geparameteriseerd met 2 types (T, S), waarbij 1 type (T) afhankelijk is van het tweede (S):

C#:

public class MyService<T, S> : IService<T, S>
    where T : ObjectBase<S>
{
    ...
}

public class MyObject : ObjectBase<int>
{
    ...
}

Volgens mij maak ik ergens een denkfout, maar ik kan niet vinden waar. Aldus de vraag:
Is het mogelijk MyService zo te bouwen dat ik een type kan instantiëren met maar 1 type parameter?

C#:

MyService<MyObject, int> myService1; // compileert, maar _int_ is redundant
MyService<MyObject> myService2; // zou ik aan het compileren willen krijgen

[Infinitive]

Dat zou kunnen met type aliasses (of type abstractie in andere woorden), maar ik heb me laten vertellen dat dat niet door de generics in .Net ondersteund wordt.

I.e. iets als:

code:

type MyService2<T> = MyService<T, Int>

MyService2<MyObject> myService2;

[edit]mmm, laat maar zitten, volgens mij bedoel ik iets anders...

wat jij denk ik bedoeld lijkt op "Multiparameter type classes met Functional Dependencies" in een functionele programmeertaal als Haskell. Maar zelfs daar is men er nog niet helemaal uit wat de 'way-to-go' is, dus ik verwacht niet dat soort truukjes in de generics van .Net aan te treffen...

[ Voor 41% gewijzigd door Infinitive op 26-01-2007 18:28 ]

[EfBe]

GrimaceODespair schreef op vrijdag 26 januari 2007 @ 16:32:
Ik heb een generic service (MyService) die overerft van een generic interface (IService). De service is geparameteriseerd met 2 types (T, S), waarbij 1 type (T) afhankelijk is van het tweede (S):

C#:

public class MyService<T, S> : IService<T, S>
    where T : ObjectBase<S>
{
    ...
}

public class MyObject : ObjectBase<int>
{
    ...
}

Volgens mij maak ik ergens een denkfout, maar ik kan niet vinden waar. Aldus de vraag:
Is het mogelijk MyService zo te bouwen dat ik een type kan instantiëren met maar 1 type parameter?

Denkfout 1 is de interface generic maken. Je interface heb je nodig wanneer je MyService wilt accessen zonder dat je de generic types weet. Dus ik zou echt die interface non-generic maken en de class generic.

Interfaces zijn nl. al een manier om generic te programmeren: ieder type die de interface implementeert is valid, dus je hebt al een generic type middels je interface. Classes hebben nl. an sig al een interface dus een extra interface heb je niet nodig.

C#:

MyService<MyObject, int> myService1; // compileert, maar _int_ is redundant
MyService<MyObject> myService2; // zou ik aan het compileren willen krijgen

Dat laatste kan niet met je class, want je moet in de MyService class definieren wat je doorgeeft aan je ObjectBase<T> als generic type. Je had het op kunnen lossen door ObjectBase<T> een interface te laten implementeren, bv IObjectBase en je had dan kunnen doen:

C#:

public class MyService<T> : IService
    where T : IObjectBase
{
    ...
}

et voila

Het punt is nl. dat je nu omzeilt het generic type voor ObjectBase<T> te specifieren.

Verder zou ik willen adviseren spaarzaam te zijn met generics. Indien je het kunt vermijden, doe het dan, want zeker met 2 of meerdere generic type parameters krijg je eerder complexere dan simpelere code.

[ Voor 8% gewijzigd door EfBe op 26-01-2007 18:37 ]

[Woy]

GrimaceODespair schreef op vrijdag 26 januari 2007 @ 16:32:
Ik heb een generic service (MyService) die overerft van een generic interface (IService). De service is geparameteriseerd met 2 types (T, S), waarbij 1 type (T) afhankelijk is van het tweede (S):

C#:

public class MyService<T, S> : IService<T, S>
    where T : ObjectBase<S>
{
    ...
}

public class MyObject : ObjectBase<int>
{
    ...
}

Volgens mij maak ik ergens een denkfout, maar ik kan niet vinden waar. Aldus de vraag:
Is het mogelijk MyService zo te bouwen dat ik een type kan instantiëren met maar 1 type parameter?

C#:

MyService<MyObject, int> myService1; // compileert, maar _int_ is redundant
MyService<MyObject> myService2; // zou ik aan het compileren willen krijgen

Kan je niet zoiets doen

C#:

public class MyService< T > : IService<T,S> where T : ObjectBase<S>
{
}

Ik heb niet getest of het compiled maar mischien dat zoiets zou kunnen.

[GrimaceODespair]

EfBe schreef op vrijdag 26 januari 2007 @ 18:33:
Denkfout 1 is de interface generic maken. Je interface heb je nodig wanneer je MyService wilt accessen zonder dat je de generic types weet. [...] Interfaces zijn nl. al een manier om generic te programmeren.

Goed punt. Alleen gebruik ik een generic interface om snel een datalaag service interface te kunnen opzetten (GetByKey/List/Save), waarbij natuurlijk zwaar gebruik wordt gemaakt van het geparemeteriseerde type. Maar je opmerking is toch nog enigszins van toepassing, want dat tweede type heb ik inderdaad niet nodig in mijn interface.

rwb schreef op vrijdag 26 januari 2007 @ 18:34:

C#:

public class MyService< T > : IService<T,S> where T : ObjectBase<S>
{
}

Ik heb niet getest of het compiled maar mischien dat zoiets zou kunnen.

Niet vermeld in de TS, maar dat heb ik natuurlijk als eerste geprobeerd