Proposal: Allow implicit implementation of internal interfaces

[dotMorten]

When you want to implement an interface on a class, you can do it implicit or explicit. Ie

public interface IMyInterface
{
    void MyMethod();
}
public class MyClassImplicit : IMyInterface
{
    public void MyMethod() { }
}
public class MyClassExplicit : IMyInterface
{
    void IMyInterface.MyMethod() { }
}

However if I create an internal interface You are forced to implement interfaces explicitly.

internal interface IMyInterface
{
    void MyMethod();
}
public class MyClassImplicit : IMyInterface
{
    internal void MyMethod() { } //Won't compile
}
public class MyClassExplicit : IMyInterface
{
    void IMyInterface.MyMethod() { } //This works
}

Implementing implicitly has a lot of nice features - I don't have to always cast to the interface to use it. This becomes very useful for wrapping native interop classes. I can create an interface that ensures that all classes that wrap native objects follow a common pattern. For instance:

    internal interface INativeWrapper : IDisposable
    {
        internal IntPtr Pointer { get; }
    }

That way if all my classes that wrap my features from my native interop layer all expose the pointer (or similar) in a common way, and always implements IDisposable. So I can just write

IntPtr ptr = MyClass.Pointer;

However, because I'm forced to explicitly implement classes, this benefit goes away somewhat, by forcing casting on my, and it's not as discoverable from intellisense code that this is available.

IntPtr ptr = ((INativeWrapper)MyClass).Pointer;

Naturally if you implement an internal interface implicitly, you would be forced to use the 'internal' or a more accessible modifier on the members.

Moved over from dotnet/roslyn#3599
/CC @onovotny

[svick]

Related: #288. One of the open issues there is:

[S]hould we permit interface methods to be […] internal […]? If so, what are the semantics?

[gafter]

You are attempting to override a method declared public with a method declared internal. I understand that is intentional, but I just wanted to make that explicit.

[dotMorten]

You are attempting to override a method declared public with a method declared internal

Huh? No. The interface is internal.

[agocke]

@dotMorten No. The effective accessibility is internal, but the declared accessibility is public. All interface methods are implicitly declared public.

§ 3.5.1

Interface members implicitly have public declared accessibility. No access modifiers are allowed on interface member declarations.

[dotMorten]

That's what the doc says, but it's not really what's happening when implementing explicitly, and you can't cast to an internal interface and access the methods either (if that were to be allowed). It's not really much different than this:

internal class SomeClass
{
      public void MyMethod() { }
}

MyMethod is declared public, but it effectively isn't. It's internal, because the class is internal.

[agocke]

@dotMorten Nope. You're not making a distinction between declared accessibility and effective accessibility, which the spec calls accessibility domain.

§ 3.5.1:

The declared accessibility of a member can be one of the following:
• Public, which is selected by including a public modifier in the member declaration. The intuitive meaning of public is “access not limited”.

§ 3.5.2:

The accessibility domain of a nested member M declared in a type T within a program P is defined as follows (noting that M itself may possibly be a type):
• If the declared accessibility of M is public, the accessibility domain of M is the accessibility domain of T.

[Thaina]

I support this proposal but I want to point out that

internal class SomeClass
{
      public void MyMethod() { }
}

Is not effectively the same as

internal class SomeClass
{
      internal void MyMethod() { }
}

Because if

public class DerivedClass : SomeClass
{
}

/// another dll

new DerivedClass().MyMethod(); // depends on the above implementation

But well, for interface it really be another story. I want to point out that class is not a good analogy

[svick]

@Thaina A public class can't inherit from an internal base class ("CS0060 Inconsistent accessibility: base class 'SomeClass' is less accessible than class 'DerivedClass'"). On the other hand, a public class can implement an internal interface.

[Thaina]

Oh right I forgot. Sorry.

Then this proposal has no problem altogether