Equivalente a Java 1.6 @Override para interfaces en C#

Question

This question da la respuesta que @Override de Java tiene el equivalente de C# de la palabra clave override en los métodos. Sin embargo, desde Java 1.6, la anotación @Override también se puede aplicar a las interfaces.

El uso práctico de esto es que en Java se obtienen errores de compilación cuando una clase afirma que implementa un método de interfaz cuando ya no lo hace (por ejemplo, si se elimina el método de interfaz). ¿Hay una funcionalidad equivalente en C#?

Algunos ejemplos de código:

Java:

public interface A { 
    public void foo(); 
    // public void bar(); // Removed method. 
} 

public class B implements A { 
    @Override public void foo(); 
    @Override public void bar(); // Compile error 
} 

C#:

public interface IA { 
    void Foo(); 
    // void Bar(); // Removed method. 
} 

public class B : A { 
    public override void Foo(); // Doesn't compile as not 'overriding' method 
    public void Bar(); // Compiles, but no longer implements interface method 
} 

Answer 1

Hay similares funcionalidad: implementación de interfaz explícita.

public interface IA { 
    void foo(); 
    // void bar(); // Removed method. 
} 

public class B : IA { 
    void IA.foo() {} 
    void IA.bar() {} // does not compile 
} 

El problema es que si usted hace esto no se puede llamar a los métodos a través del puntero this (desde el interior de la clase) o por medio de una expresión que se evalúa como un B - ahora es necesario para echar a IA.

puede evitar que al hacer un método público con la misma firma y remisión de la llamada a la aplicación explícita de este modo:

public class B : IA { 
    void IA.foo() { this.foo(); } 
    public void foo() {} 
} 

Sin embargo esto no es bastante ideal, y nunca he visto hecho en la práctica

Answer 2

En realidad no, aunque VB.Net hace.

podría implementar el método de forma explícita y tienen que llamar a la versión pública normales:

public void bar() { ... } 
void IA.bar() { bar(); } 

Answer 3

Como se indicó, no se puede obtener ese tipo de control solo desde una interfaz en C#. Usted podría obtenerlo de una clase abstracta sin embargo. A los efectos de integridad, esto es lo que podría hacer:

public interface IA 
{ 
    void Foo(); 
    //void Bar(); - removed 
} 

public abstract class A : IA 
{ 
    virtual void Foo() 
    { } 

    // Removed method 
    //virtual void Bar() 
    //{ } 
} 

public class B : A 
{ 
    public override void Foo() 
    { } 

    //throws an error like the one you were receiving regarding no method to override. 
    public override void Bar() 
    { } 
} 

Answer 4

El @Override para la interfaz en Java significa "aperos. Cuando en Java una clase implementa un método de interfaz y la firma de ese método se cambia o el método se elimina de la interfaz más tarde, el compilador java comienza a quejarse de ello.

De esta manera evita que el método se convierta en "código muerto", o bien tiene que eliminar la anotación @Override (para que el método se convierta en un método normal) o eliminar o cambiar el método para que coincida con la interfaz. Esta es una característica muy buena para mantener su código limpio. Me gustaría que C# también tenga esta característica.

Utilizo la implementación explícita tanto como puedo.

Por cierto: Resharper lo muestra cuando un método implementa un método de interfaz.