Equivalent of Java 1.6 @Override for interfaces in C#

Question

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

Answer 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.

Answer 2

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

Answer 3

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

Answer 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.