[C#] Inheritance en hiding

[Knakker]

Ik wil het volgende doen:

C#:

public interface IFunctionaliteitA 
{ 
    GegevensKlasse Data { get; } 
    void DoeEenMetData(); 
}

public interface IFunctionaliteitB : IFunctionaliteitA 
{ 
    void DoeOokTweeMetData(); 
} 

public interface IObjectA
{
    IFunctionaliteitA Functies { get; }
}

public interface IObjectB : IObjectA
{
    new IFunctionaliteitB Functies { get; }
}

Als ik echter het volgende probeer:

C#:

public class Object : IObjectB
{
    private IFunctionaliteitB _Functies;
    public IFunctionaliteitB Functies { get { return _Functies; } }
}

Dan krijg ik de melding dat IFunctionaliteitA Functies { get; } niet geimplementeerd is.

Het idee is dat van de objecten die FunctionaliteitA hebben, sommigen tevens FunctionaliteitB kunnen hebben. FunctionaliteitA en FunctionaliteitB moeten gegevens en methodes delen.

Waarom mag dit niet en wat is de beste oplossing? Alvast bedankt

[bigbeng]

Dat is toch logisch? Interface B is ook van het type Interface A, dus ieder object dat Interface B implementeert, is ook een implementatie van Interface A en moet dus de bijbehorende methoden en properties implementeren.

[ Voor 3% gewijzigd door bigbeng op 21-05-2009 23:44 ]

[D-Raven]

Die "Functies" is trouwens best lelijk imho. Als je objecten een interface implementeren laat dat dan expliciet zijn, en expose de interface implementatie niet via een property. Als je runtime wilt weten of een object een bepaalde interface implementeert moet je toch met het IS keyword, of reflectie, kijken of deze dat ook doet.

Maar als je dezelfde methodes in 2 interfaces hebt zitten, en je wilt dat ze allebei deze methode implementeren, dan moet je die methode(s) in een 3de interface definitie plaatsen. Dan werkt t wel

[whoami]

Waarom moet IObjectB afleiden van IObjectA ?
IFunctionaliteitB is een IFunctionaliteitA, dus is het helemaal niet nodig om van IObjectA af te leiden

Zowiezo vind ik het een beetje een raar design ...

[Knakker]

Ik wil B van A afleiden omdat ik B ook als A wil kunnen identificeren. Ik zie B als een doorontwikkeling / uitbreiding va A, en functies die A als argument accepteren moeten ook B aannemen omdat B dezelfde funcitonaliteit als A heeft. Als ik IObjectB niet van IObjectA inherit, gaat dat dus niet op - anders moet ik ze als zowel IObjectA als IObjectB inheriten, maar dan krijg ik dezelfde fout.

[Hele dikke edit]
Maar ik had net een klein verhelderend moment en bedacht me dat ik het object prima als IObjectA kan identificeren om vervolgens kijken naar de interface achter Functies...

[ Voor 82% gewijzigd door Knakker op 22-05-2009 21:06 ]

[R4gnax]

Knakker schreef op donderdag 21 mei 2009 @ 22:22:
Waarom mag dit niet en wat is de beste oplossing? Alvast bedankt

http://msdn.microsoft.com/en-us/library/4taxa8t2(VS.80).aspx

Je kunt interfaces expliciet implementeren in welk geval twee interfaces ook verschillende methods, properties, etc. kunnen implementeren met dezelfde naam. Expliciet geimplementeerde methods, properties, etc. zijn alleen op te vragen via de interface definitie en niet via de class definitie die de interfaces implementeert. Wil je dat je ook een versie hebt die via de class definitie op te vragen is, dan zul je één van beide implementaties niet expliciet, maar impliciet ('normaal') moeten implementeren. Als je het object dan niet door een interface aanspreekt wordt dat als de 'default' implementatie gekozen.

In jouw geval:

C#:

public interface IFunctionaliteitA 
{ 
    GegevensKlasse Data { get; } 
    void DoeEenMetData(); 
}

public interface IFunctionaliteitB : IFunctionaliteitA 
{ 
    void DoeOokTweeMetData(); 
} 

public interface IObjectA
{
    IFunctionaliteitA Functies { get; }
}

public interface IObjectB
{
    IFunctionaliteitB Functies { get; }
}

public Object_InterfaceOnly: IObjectA, IObjectB
{
    private IFunctionaliteitB _Functies;

    public IFunctionaliteitA IObjectA.Functies { get { return _Functies; } }
    public IFunctionaliteitB IObjectB.Functies { get { return _Functies; } }
}

public Object_WithDefault: IObjectA, IObjectB
{
    private IFunctionaliteitB _Functies;

    public IFunctionaliteitA IObjectA.Functies { get { return _Functies; } }
    public IFunctionaliteitB Functies { get { return _Functies; } }
}

Ik moet alleen wel even kwijt dat ik het eens ben met de andere mensen in deze thread: deze structuur is ronduit smerig en absoluut niet vriendelijk voor wie verder met deze classes moet werken of er onderhoud aan moet plegen.

Ik raad je ten zeerste aan nog eens goed na te denken over je architectuur want dit is een WTF in wording.

[.oisyn]

De vraag is, waarom gebruik je het new keyword op regel 19? Werkt het niet gewoon naar behoren als je dat weghaalt? IFunctionaliteitB is namelijk covariant met IFunctionaliteitA, en daarom zou een specifiekere implementatie zoals IObjectB prima een specifieker type terug kunnen geven. In feite gaat het dan om dezelfde method, ipv een nieuwe zoals je nu aangeeft dmv het 'new' keyword. En dan moet een klasse idd beide methods implementeren.

.edit: ah, C# ondersteunt geen covariant return types. Suf . Zeker gezien het feit dat het bij het casten van delegates wel kan.

[ Voor 12% gewijzigd door .oisyn op 23-05-2009 01:20 ]