Interface arv

Du bliver nød til implementere begge metoder, ellers opfylder du ikke kriterierne specificeret af interfacet. Det du kan gøre er at implementere Execute metoden som returnerer en DerivedResult. Fra den anden Execute metode kalder du den første.

public class DerivedClass : IDerivedInterface
{
    public DerivedResult Execute()
    {
        //Kode her
    }

    BaseResult ITestInterface.Execute()
    {
        return ((IDerivedInterface)this).   
    }
}

Whoops, der forsvandt noget da jeg copy/pastede! Her er koden igen:

public class DerivedClass : IDerivedInterface
{
    public DerivedResult Execute()
    {
        //Kode her
    }

    BaseResult ITestInterface.Execute()
    {
        return ((IDerivedInterface)this).Execute();
    }
}

Ja, det kom jeg også frem til, men synes ikke det er så pænt og forstå ikke helt logikken, da der netop i IDerivedInterface er specificeret end "new" Execute() metode.

Findes der alternative metoder til at kode dette "rigtigt" ?

Hvis du tænker lidt over det, er det logisk at du bliver nød til at implementere begge metoder. Du vil til en hver tid kunne putte en instans af IDerivedInterface ned i en variabel af typen ITestInterface, da den nedarver fra denne. En IDerivedInterface er også en ITestInterface, derfor skal den kunne opføre sig som en ITestInterface.

Hvis du har en variable af typen ITestInterface som indeholder en IDerivedInterface og du kalder Execute(), da vil kompileren forvente at der bliver returneret en BaseResult, hvor der i dette tilfælde vil blive returneret en DerivedResult. I dette eksempel ville det (Hvis det kunne lade sig gøre) gå godt, da DerivedResult nedarver fra BaseResult, men hvad hvis det havde være 2 helt forskellige returtyper?

Jeg vil mene at den måde du er i gang med at gøre det, er den rigtige. Når du opretter en instans af DerivedClass, vil det kun være den ene Execute() metode som er synlig. Hvis du har denne instans liggende i en variabel af typen ITestInterface, vil ITestInterface.Execute() metoden være synlig, men automatisk kalde den nedarvede klasses Execute metode.

new betyder ny metode, saa er det vel ikke saa overraskende at den ikke betragtes
som vaerende den gamle.

Men jeg vil kraftigt anbefale dig at redesigne lidt. Det valgte design vil give
nogle meget tricky situationer.

Proev of se paa dette eksempel:

using System;

namespace E
{
    public class DBase
    {
        public virtual void Test()
        {
            Console.WriteLine("I am a DBase");
        }
    }
    public class DDerived : DBase
    {
        public override void Test()
        {
            Console.WriteLine("I am a DDerived");
        }
    }
    public interface IBase
    {
        DBase GetD();
    }
    public interface IDerived : IBase
    {
        new DDerived GetD();
    }
    public class X : IBase, IDerived
    {
        DBase IBase.GetD()
        {
            return new DBase();
        }
        DDerived IDerived.GetD()
        {
            return new DDerived();
        }
    }
    public class Program
    {
        public static void Main(string[] args)
        {
            IDerived o = new X();
            o.GetD().Test();
            IBase o2 = o;
            o2.GetD().Test();
            Console.ReadKey();
        }
    }
}

Det er meget ikke-polymorphistisk at GetD afhaenger af hvordan typen er erklaeret !

smider i et svar?

.

svar :-)

Du må huske at acceptere svarene!