Abstract method in public abstract class implementing an internal interface doesn't compile?

internal interface I_Foo
{
    void Bar();
}

public abstract class A_Foo : I_Foo
{
    public A_Foo() { }
    abstract void I_Foo.Bar();
}

public class Foo : A_Foo
{
    public Foo() : base() { }
    internal override void Bar()
    {

    }
}

Hello! I'm trying to have some methods visible to outside code, and other only visible to my assembly. For this purpose, I made an internal interface I_Foo to serve as a contract to other parts of the assembly, a public abstract A_Foo to serve as abstraction for external code, and centralize some constructor functionality, and several different classes Foo that implement A_Foo and I_Foo explicitly to retain internal modifier.

However, in the A_Foo class, I get

'A_Foo.I_Foo.Bar()' must declare a body because it is not marked abstract, extern, or partial

even though the method is clearly marked as "abstract". If I add a body, I get "abstract is not a valid modifier".

I need this method to be explicitly declared, in order to be internal in a public class, and I need it to be abstract so I can override it in the actual implementation Foo.

Why doesn't the compiler let me? Is there another way I can achieve the same thing? Thank you.

Jon Skeet
people
quotationmark

Explicit interface implementations always have to have an actual implementation. The trick here is to making that just call a non-explicit (internal) abstract method:

public abstract class A_Foo : I_Foo
{
    // Classes outside the assembly can't derive from A_Foo
    // anyway, so let's make the constructor internal...
    internal A_Foo() { }

    void I_Foo.Bar()
    {
        Bar(); // Just delegate to the abstract method
    }

    internal abstract void Bar();
}

This still allows I_Foo to use internal types etc, because Bar is never exposed publicly - but it fits within the other rules of the language.

people

See more on this question at Stackoverflow