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 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
}

I'm confused. Why should `B` implement `A.bar` if `A` no longer defines `bar`? Are you looking for a way to enforce that children of `A` *only* implement the methods defined by `A`? — M.Babcock, Jan 20 '12 at 03:14
@M.Babcock The case I'm trying to guard against is that `B.bar()` should not compile if B's author expects it to implement `A.bar()`. This is especially the case if a naive developer removes `A.bar()` without checking its implementing classes first. — , Jan 20 '12 at 03:22

score 7 · Accepted Answer · answered Jan 20 '12 at 03:09

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.

score 0 · Answer 2 · answered Jan 20 '12 at 03:08

0

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

answered Jan 20 '12 at 03:08

SLaks

868,454
176
1,908
1,964

score 0 · Answer 3 · answered Jan 20 '12 at 05:52

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

score -1 · Answer 4 · answered Dec 22 '12 at 12:35

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#

4 Answers4

Related