So verlängern Sie die Schnittstelle, indem die Methode Namen?

Gegeben zwei Schnittstellen:

interface I1 {
    int Foo();
}

interface I2 {
    void Foo();
}

Einer Klasse:

class Test : I1, I2 {
    int I1.Foo() {
        Console.WriteLine("I1.Foo");
        return default(int);
    }

    public void Foo() {
        Console.WriteLine("I2.Foo");
    }
}

Wie kann ich verlängern Sie die Schnittstelle I2 mit I1 indem Sie die Methoden mit dem Namen Foo?

Habe ich versucht den folgenden code, aber es kann nicht kompiliert werden:

interface I1 {
    int Foo();
}

interface I2 : I1 {
    void I2.Foo();
} 

class Test : I2 { /* same code */ }
Sie können nicht implementiert nichts in einem interface. Nur Deklarationen erlaubt sind.
Es ist nicht sonderlich hilfreich, ist aber sicherlich erlaubt. Sie wollen vermeiden, mit dem gleichen Namen, das macht es schwer für eine Klasse die Schnittstelle implementieren, und für niemanden, es zu benutzen.

InformationsquelleAutor Omar | 2012-01-22

  1. 18

    Es ist unklar, in den Beispiel, was explizit deklarieren I2.Foo() in der Schnittstelle selbst erledigen würde, wenn es erlaubt ist. Die Spezifikation (en. 13.4.1) erlaubt es, die Struktur oder Klasse, die Implementierung einer Schnittstelle zu deklarieren explizit Mitglied der Implementierung. (Schnittstellen kann nicht erklären, Implementierung, explizite oder anderweitig).

    So, nehmen wir an, wir haben definiert:

    interface IFoo
{
    void Bar();
}

interface IBaz : IFoo
{
    new void Bar();
}

interface IQux : IBaz { }

class A : IQux //equivalent to class A : IQux, IBaz, IFoo (spec sec. 13.4.6)
{
    void IFoo.Bar()
    {
        Console.WriteLine("IFoo.Bar");
    }

    void IBaz.Bar()
    {
        Console.WriteLine("IBaz.Bar");
    }

    public void Bar()
    {
        Console.WriteLine("A.Bar");
    }

    //Not allowed: void IQux.Bar() {...}
    //Since "The fully-qualified name of the interface member
    //must reference the interface in which the member
    //was declared" (s. 13.4.1)
}

    Dann den folgenden Treiber zeigt die Wirkung der explizite interface-Implementierung.

    public static void Main()
{
    A a = new A();
    a.Bar(); //prints A.Bar
    (a as IFoo).Bar(); //prints IFoo.Bar
    (a as IBaz).Bar(); //prints IBaz.Bar
    (a as IQux).Bar(); //prints IBaz.Bar
}
    Dies ist bei weitem die vollständigste und beste Antwort.

    InformationsquelleAutor drf

  2. 2

    nicht ganz sicher, was Sie wollen, es zu tun, aber Sie tun können :-

    public interface I1
{
    int Foo();
}

public interface I2:I1
{
    new void Foo();
}

    InformationsquelleAutor Keith Nicholas

  3. 0

    Es funktioniert nur, wenn die beiden Methoden haben verschiedene Signaturen, was bedeutet, dass Sie müssen haben eine unterschiedliche Anzahl von Parametern oder unterschiedlichen Typen von Parametern, oder beides.

    Warum nicht Namen Ihrer zwei Methoden GetFoo und DoFoo?

    Dies funktionieren würde

    public interface I1 
{ 
    int Foo(); 
} 

public interface I2 : I1 
{ 
    void Foo(int i); 
}

    Diese auch funktionieren würde

    public interface I1 
{ 
    int GetFoo(); 
} 

public interface I2 : I1 
{ 
    void DoFoo(); 
}

    Könnte man auch das deklarieren einer Eigenschaft. Eigenschaften bestehen aus zwei Methoden: Eine getter-und eine setter.

    public interface I
{
    int Foo { get; set; }
}

public class C : I
{
    private int _foo;
    public int Foo
    {
        get {
            //getter
            return _foo;
        }
        set {
            //setter
            _foo = value;
        }
    }
}

    InformationsquelleAutor Olivier Jacot-Descombes

Schreibe einen Kommentar