Equivalent of Java 1.6 @Override for interfaces in C#

问题:

This question gives the answer that Java's @Override has the C# equivalent of the override keyword on methods. However, since Java 1.6 the @Override annotation can be applied to interfaces also.

The practical use for this is that in Java you get compile errors when a class claims it implements an interface method when it no longer does (e.g. if the interface method is removed). Is there equivalent functionality in C#?

Some code examples:

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 } 

回答1:

There is similar functionality: explicit interface implementation.

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

The problem is that if you do this you cannot call the methods through the this pointer (from inside the class) or through an expression that evaluates to a B -- it is now necessary to cast to IA.

You can work around that by making a public method with the same signature and forwarding the call to the explicit implementation like so:

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

However this isn't quite ideal, and I 've never seen it done in practice.

回答2:

Not really, although VB.Net does.

You could implement the method explicitly and have that call the normal public version:

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

回答3:

As stated, you cannot get that kind of control from an interface alone in C#. You could get it from an abstract class however. For the purpose of completeness, here is what you could do:

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()     { } } 

回答4:

The @Override for interface in Java means 'implements'. When in Java a class implements an interface method and that method's signature is changed or the method is removed from the interface later the java compiler starts complaining about it.

This way it prevents the method to become 'dead code', you either have to remove the @Override annotation (so the method becomes a normal method) or remove or change the method to match the interface again. This is a very nice feature to keep your code clean. I would like C# to have this feature too.

I use explicit implementing as much as I can.

By the way: Resharper shows it when a method implements an interface method.

文章来源: Equivalent of Java 1.6 @Override for interfaces in C#