C# Interfaces geerbte Methode verstecken

[Torben (Gast)]

Hallo, ich hab wie im Bespiel zwei Interfaces und würde mir gerne die 
doppelte Implementierung sparen, aber die Implementierung SubImp, soll 
die Methode Getkey() nicht enthalten.

Gibt es dafür eine bessere und einfachere Möglichkeit als meine Lösung?

 public interface IMain
        {
            void Hallo();
            void Test();

            void GetKey();
        }

        public interface ISub
        {
            void Hallo();
            void Test();

           
        }

        public class MainImp : IMain
        {
            public void GetKey()
            {
                throw new NotImplementedException();
            }

            public void Hallo()
            {
                throw new NotImplementedException();
            }

            public void Test()
            {
                throw new NotImplementedException();
            }
        }

        public class SubImp : ISub
        {
            private readonly MainImp _mainImp = new MainImp();


            public void Hallo()
            {
                _mainImp.Hallo();
            }

            public void Test()
            {
                _mainImp.Test();
            }
        }

[Horst S. (Gast)]

Ich hoffe, ich habe Dich richtig verstanden?!

mit "virtual" z.b.:

    public interface IMain : ISub
    {
        void GetKey();
    }

    public interface ISub
    {
        void Hallo();
        void Test();


    }

   public class MainImp : SubImp, IMain
    {
        public void GetKey()
        {
            Hallo();
            Test();
        }

        public override void Hallo()
        {
            System.Diagnostics.Debug.WriteLine ("Hallo");
        }

        public override void Test()
        {
            System.Diagnostics.Debug.WriteLine("Test");
        }
    }

    public class SubImp : ISub
    {
        public virtual void Hallo()
        {
        }

        public virtual void Test()
        {
        }
    }

Geht aber auch mit "abstract", wenn Du willst dass SubImp nur in der 
Ableitung instanziiert werden kann.

[Ing (Gast)]

Torben schrieb:
> Hallo, ich hab wie im Bespiel zwei Interfaces und würde mir gerne
> die doppelte Implementierung sparen, aber die Implementierung SubImp,
> soll die Methode Getkey() nicht enthalten.
> Gibt es dafür eine bessere und einfachere Möglichkeit als meine Lösung?


Hallo,
In deinem Beispiel enthält SubImp doch gar nicht die Implementierung von 
GetKey?

[Torben (Gast)]

Hallo Horst,

danke für deine Antwort. In deinem Beispiel erbt IMain von ISub, wenn 
ich IMain nicht mehr ändern kann, dann fällt es flach oder?

@Ing:

Richtig, ich hab schon meine Lösung gepostet und ich hatte gehofft es 
geht irgendwie einfacher.

[Ing (Gast)]

Torben schrieb:
> Hallo Horst,
>
> danke für deine Antwort. In deinem Beispiel erbt IMain von ISub, wenn
> ich IMain nicht mehr ändern kann, dann fällt es flach oder?
>
> @Ing:
>
> Richtig, ich hab schon meine Lösung gepostet und ich hatte gehofft es
> geht irgendwie einfacher.

Warum willst du nicht das SubImpl GetKey implementiert? Lass doch 
SubImpl beide Interfaces implementieren (Stichwort Interface 
Segregation) und delegier die Methoden von IMain an deine Main Klasse.

Wenn du nicht willst das von der Klasse SubImpl nicht auf SubImpl 
zugegriffen werden kann, sondern nur über IMain, dann implemtiet GetKey 
über ein explizites Interface.

Das geht dann so

class SubImpl : ISubImpl, IMain
{
 private Main Test = new Main();

string IMain.GetKey()
{
 Return Test.GetKey();
}

....
}

[Ing (Gast)]

Ing schrieb:

>
> Wenn du nicht willst das von der Klasse SubImpl nicht auf SubImpl
> zugegriffen werden kann, sondern nur über IMain, dann implemtiet GetKey
> über ein explizites Interface.
>
> Das geht dann so
>
> class SubImpl : ISubImpl, IMain
> {
>  private Main Test = new Main();
>
> string IMain.GetKey()
> {
>  Return Test.GetKey();
> }
>
> ....
> }

Meinte wenn du nicht willst das von SubImpl direkt auf GetKey 
zugegriffen werden kann, sondern nur über das IMain Interface, dann 
verwende die explizite Interface Implementierung. Sorry für den 
Schreibfehler oben

[Torben (Gast)]

>Warum willst du nicht das SubImpl GetKey implementiert?

Weil der Kunde nur eine abgespeckte Version bekommen soll und ich kann 
leider das MainInterface nicht mehr aufteilen.

Danke für eure Antworten.