[Generics] Alleen bepaalde types toestaan

[Verwijderd]

Stel ik heb de volgende abstract class:

C#:

public abstract class AbstractIets<T>
{
   public void DoeIets(T entity)
   {
      ...
   }
}

Vervolgens kan ik een implementatie maken van deze abstract class:

C#:

public class CustomerIets : AbstractIets<Customer>
{

}

Maar ik kan ook bijvoorbeeld een interface als type meegeven:

C#:

public class CustomerIets : AbstractIets<ICustomer>
{

}

En dat wil ik dus niet. Ik wil alleen classes als type hebben, en geen interfaces o.i.d. Is er een manier om hier op te checken?

Ik hoopte dat dit zou werken:

C#:

public abstract class AbstractIets<T> where T : class

maar dat is blijkbaar geen constraint op het type.

Iemand een idee?

[Flard]

Je zou kunnen proberen where T : Object (of T : class, Object?), alle classen inheriten immers van System.Object, en interfaces voor zover ik weet niet.

Maar wat zou er mogelijkerwijs tegen een Interface zijn, uiteindelijk bij het gebruik van je klasse heb je er toch geen interfaces meer in zitten, maar echte objecten (die die interface implementeren).
Dus ik zou niet echt weten waarom je álleen classen zou toestaan, maar geen interfaces.

[whoami]

code:

where T : new()

Hiermee dwing je al af dat je type een parameterless constructor moet hebben ....
Als je het combineert met de class constraint, dan bereik je misschien al min of meer wat je wil ?

code:

where T : class, new()

type constraints

Maar, de logica waarom je deze constraint wilt afdwingen, ontgaat me ook een beetje... Ik bedoel, je wil gewoon afdwingen dat het 'een' class moet zijn; wat is het nut daarvan ?

[ Voor 107% gewijzigd door whoami op 04-12-2008 10:32 ]

[.oisyn]

Flard schreef op donderdag 04 december 2008 @ 10:24:
Je zou kunnen proberen where T : Object (of T : class, Object?), alle classen inheriten immers van System.Object, en interfaces voor zover ik weet niet.

It doesn't work that way. Een interface inherit idd zelf niet van Object, maar je weet wel dat ieder object dat die interface implementeert ook minstens een Object is. Alle methoden die je op Object aan kunt roepen zijn dan ook gewoon beschikbaar in een generic method die werkt op een interface.

[Verwijderd]

whoami schreef op donderdag 04 december 2008 @ 10:28:
Maar, de logica waarom je deze constraint wilt afdwingen, ontgaat me ook een beetje... Ik bedoel, je wil gewoon afdwingen dat het 'een' class moet zijn; wat is het nut daarvan ?

Het punt is dat ik anders een interface kan doorgeven als type en dat wil ik niet. Ik wil bijvoorbeeld een instantie van het type kunnen teruggeven, en dat kan alleen als het type een class is.

[Verwijderd]

whoami schreef op donderdag 04 december 2008 @ 10:28:

code:

where T : class, new()

Dit is trouwens de oplossing!

Thanks

[.oisyn]

En dat dekt ook meteen de case dat de class abstract is (of simpelweg niet default constructable is), wat je dus eigenlijk ook wilt . Maar wil je die 'class' ook echt?

[ Voor 31% gewijzigd door .oisyn op 04-12-2008 12:10 ]

[Jaap-Jan]

Verwijderd schreef op donderdag 04 december 2008 @ 11:59:
[...]


Het punt is dat ik anders een interface kan doorgeven als type en dat wil ik niet. Ik wil bijvoorbeeld een instantie van het type kunnen teruggeven, en dat kan alleen als het type een class is.

En wat is het probleem met dat 'potentiële misbruik'? Waarom wil je de potentiële gebruiker van die generic class die mogelijkheid ontzeggen?

Ik ben daar echt benieuwd naar, want ik kan het nut ervan niet echt inzien.

[ Voor 8% gewijzigd door Jaap-Jan op 04-12-2008 12:35 ]

[Flard]

.oisyn schreef op donderdag 04 december 2008 @ 11:59:
[...]

It doesn't work that way. Een interface inherit idd zelf niet van Object, maar je weet wel dat ieder object dat die interface implementeert ook minstens een Object is. Alle methoden die je op Object aan kunt roepen zijn dan ook gewoon beschikbaar in een generic method die werkt op een interface.

Je hebt helemaal gelijk... denkfoutje van mijn kant.


where T: new() is inderdaad gewoon de way to go...

[.oisyn]

Jaap-Jan schreef op donderdag 04 december 2008 @ 12:34:
[...]

En wat is het probleem met dat 'potentiële misbruik'? Waarom wil je de potentiële gebruiker van die generic class die mogelijkheid ontzeggen?

Ik ben daar echt benieuwd naar, want ik kan het nut ervan niet echt inzien.

Je begrijpt het niet. Een interface kun je niet new'en. Je kunt dus ook geen new T() doen in de implementatie van die generic functie als je T niet de constraint meegeeft dat ie default constructable is. De TS dacht dat op te lossen door een één of ander constraint mee te geven dat T een class moet zijn. Z'n gedachtengang was juist, hij wist alleen niet hoe dat moest.

[ Voor 13% gewijzigd door .oisyn op 04-12-2008 12:43 ]

[whoami]

Verwijderd schreef op donderdag 04 december 2008 @ 11:59:
[...]


Het punt is dat ik anders een interface kan doorgeven als type en dat wil ik niet. Ik wil bijvoorbeeld een instantie van het type kunnen teruggeven, en dat kan alleen als het type een class is.

Tja, en wil je dat echt afdwingen ... Ik bedoel, dat is uiteindelijk de programmeur zijn verantwoordelijkheid.

Die constraints op type parameters zijn imho enkel nodig en bedoeld als je binnen de class waarin je het generieke type gebruikt, bepaalde methods moet gaan aanroepen. Als je dus moet afdwingen dat het generieke type bv een bepaalde interface implementeert, of overerft van een bepaalde class.

Dergelijke dingen, maar afdwingen dat het 'een class moet zijn', dat zou ik niet doen. Gewoon documenteren, en de developer die je type dan gebruikt moet er maar voor zorgen dat hij het goed doet.

[.oisyn]

C#:

class MyGeneric<T>
{
    public static T New()
    {
        return new T();
    }
}

Compile error. Where T : new() is nodig.

[whoami]

Your point being ?

Voor dergelijke zaken zijn die constraints idd bedoeld. Om af te dwingen dat je generiek type bepaalde functionaliteit heeft (zij het een bepaalde interface implementeren, of een default constructor hebben).

Trouwens, de topic-starter wil dat zijn type een class is. Maw, zijn type zou in principe ook deze class mogen zijn:

code:

public class Melp
{
    public Melp( int a ){}
}

Dus, een class zonder public default constructor. Volgens mij wordt dit door die constraint niet toegelaten.

[ Voor 39% gewijzigd door whoami op 04-12-2008 12:59 ]

[.oisyn]

My point being: .oisyn in "[Generics] Alleen bepaalde types toestaan". In het stuk dat jij quote van hem zegt ie dat ie een nieuw instance wil kunnen returnen. Jouw Melp wordt dus ook wat moeilijk, omdat hij niet weet hoe een Melp geconstruct moet worden. Dus die mag niet.

Imho blijven zowel jij als Jaap-Jan teveel hameren op het feit dat ie gezegd heeft dat ie wil dat het een class is. Blijkbaar is dat niet wat hij wilt, hij wilt dat iets constructable is. De vraag is dan nog of hij daadwerkelijk wil dat het een class is (en niet ook struct), aangezien dat ook een constraint is wat hij momenteel gebruikt (zie ook .oisyn in "[Generics] Alleen bepaalde types toestaan").

[ Voor 95% gewijzigd door .oisyn op 04-12-2008 13:14 ]

[Jaap-Jan]

.oisyn schreef op donderdag 04 december 2008 @ 13:10:
My point being: .oisyn in "[Generics] Alleen bepaalde types toestaan". In het stuk dat jij quote van hem zegt ie dat ie een nieuw instance wil kunnen returnen. Jouw Melp wordt dus ook wat moeilijk, omdat hij niet weet hoe een Melp geconstruct moet worden. Dus die mag niet.

Hij zegt nergens 'nieuw instance'. Hij zegt alleen dat 'ie een instance wil teruggeven. Dat kan natuurlijk ook iets zijn wat er al eerder is ingestopt. Al impliceert 'en dat kan alleen als het type een class is' wel (deels) dat 'ie een nieuwe instance wil retourneren, afgezien van het feit dat je geen abstract class kunt instantiëren.

[ Voor 13% gewijzigd door Jaap-Jan op 04-12-2008 13:16 ]

[.oisyn]

Hmm right, dat woordje heb ik er waarschijnlijk zelf bij verzonnen. Waarschijnlijk ook omdat zonder dat woordje "nieuw" zijn hele post geen sense maakt. Het had dan ook wel handig geweest als jullie op zijn post reageerde dat het returnen van een instance natuurlijk altijd kan, ipv door te vragen waarom hij dan wil dat het per se een class moet zijn

[ Voor 40% gewijzigd door .oisyn op 04-12-2008 13:18 ]

[Verwijderd]

ik bedoelde inderdaad 'nieuwe' instantie