Are internal methods supported?

[baynezy]

I have a bug raised on NSubstitute nsubstitute/NSubstitute#866 which after some debugging looks like it makes more sense to be here.

I have a reporoduction case which you can check out here https://github.com/baynezy/NSubstituteIssue

Essentially, this interface can be mocked:

public interface IExample
{
    bool Check();
}

and this one

public interface IExampleWithInternal
{
    internal bool Check();
}

throws a System.TypeLoadException.

Let me know if you need more detail.

Thanks.

[304NotModified]

In addition, this will also give the same exception in Moq. So it's unclear is this a bug, a limitation or NSubstitute and Moq doing incorrect calls.

The full exception stacktrace, with the message from Castle Core "method .. does not have an implementation":

System.TypeLoadException
Method 'Check' in type 'Castle.Proxies.IExampleWithInternalProxy' from assembly 'DynamicProxyGenAssembly2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' does not have an implementation.
   at System.Reflection.Emit.RuntimeTypeBuilder.CreateTypeNoLock()
   at System.Reflection.Emit.RuntimeTypeBuilder.CreateTypeInfoImpl()
   at System.Reflection.Emit.TypeBuilder.CreateTypeInfo()
   at Castle.DynamicProxy.Generators.Emitters.AbstractTypeEmitter.CreateType(TypeBuilder type)
   at Castle.DynamicProxy.Generators.Emitters.AbstractTypeEmitter.BuildType()
   at Castle.DynamicProxy.Generators.BaseInterfaceProxyGenerator.GenerateType(String typeName, INamingScope namingScope)
   at Castle.DynamicProxy.Generators.BaseProxyGenerator.<>c__DisplayClass13_0.<GetProxyType>b__0(CacheKey cacheKey)
   at Castle.Core.Internal.SynchronizedDictionary`2.GetOrAdd(TKey key, Func`2 valueFactory)
   at Castle.DynamicProxy.Generators.BaseProxyGenerator.GetProxyType()
   at Castle.DynamicProxy.DefaultProxyBuilder.CreateInterfaceProxyTypeWithoutTarget(Type interfaceToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
   at Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithoutTarget(Type interfaceToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
   at Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(Type interfaceToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options, IInterceptor[] interceptors)
   at Moq.CastleProxyFactory.CreateProxy(Type mockType, IInterceptor interceptor, Type[] interfaces, Object[] arguments) in /_/src/Moq/Interception/CastleProxyFactory.cs:line 50
   at Moq.Mock`1.InitializeInstance() in /_/src/Moq/Mock`1.cs:line 309
   at Moq.Mock`1.OnGetObject() in /_/src/Moq/Mock`1.cs:line 323
   at Moq.Mock.get_Object() in /_/src/Moq/Mock.cs:line 181
   at Moq.Mock`1.get_Object() in /_/src/Moq/Mock`1.cs:line 281
   at Target.UnitTests.ReproductionCase.Moq_IExampleWithInternal() 

Tested with version 5.1.1

To be clear, I think the (simplified) use case could be:

Given this interface

public interface IExample
{
    bool CheckPublic()
    internal bool CheckInternal();
}

Goal:
Create a mock and mock CheckPublic method.

Current result:
System.TypeLoadException ... with "method CheckInternal ... does not have an implementation"

[stakx]

I would have guessed that using [assembly: InternalsVisibleTo(InternalsVisible.ToDynamicProxyGenAssembly2)] would take care of that, but seeing that the issue is with non-public interface methods, there could be some accessibility checks missing in the new code paths we added to support those.

[stakx]

I checked. DynamicProxy can proxy such types if the correct [assembly: InternalsVisibleTo] custom attribute has been declared on your proxied type's assembly.

Depending on whether your own assembly is strong-named ("signed") or not, either of the following two custom attributes should enable your type to become proxyable:

[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

[assembly: InternalsVisibleTo(InternalsVisible.ToDynamicProxyGenAssembly2)]

But how would you know about that? Well, at least in some cases, DynamicProxy tells you exactly what custom attribute to declare in your assembly. But apparently we're looking at a case where it does not.

Let's run a few simple test cases to see what kind of error you get when the proper required [assembly: InternalsVisibleTo(...)] custom attribute is absent:

Test case 1: internal interface

internal interface IInternalInterface { }
_ = generator.CreateInterfaceProxyWithoutTarget<IInternalInterface>();

System.ArgumentException: Can not create proxy for type IInternalInterface because it is not accessible. Make it public, or internal and mark your assembly with [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] attribute, because assembly ... is not strong-named.

This is quite helpful, no further action required here.

Test case 2: public interface with an internal method

public interface IInterfaceWithInternalMethod
{
	internal bool Method();
}
_ = generator.CreateInterfaceProxyWithoutTarget<IInterfaceWithInternalMethod>();

System.TypeLoadException: Method 'Method' in type 'Castle.Proxies.IInterfaceWithInternalMethodProxy' from assembly 'DynamicProxyGenAssembly2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' does not have an implementation.

This is the case being discussed in this issue. The exception message isn't helpful and could be improved.

Test case 3: internal class

internal class InternalClass { }
_ = generator.CreateClassProxy<InternalClass>();

System.ArgumentException: Can not create proxy for type InternalClass because it is not accessible. Make it public, or internal and mark your assembly with [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] attribute, because assembly ... is not strong-named.

Same helpful message as in test case 1. No further action required here.

Test case 4: public class with an internal method

_ = generator.CreateClassProxy<ClassWithInternalMethod>();
public abstract class ClassWithInternalMethod
{
	internal abstract void Method();
}

System.TypeLoadException: Method 'Method' in type 'Castle.Proxies.ClassWithInternalMethodProxy' from assembly 'DynamicProxyGenAssembly2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' does not have an implementation.

Same unhelpful message as in test case 2, could be improved.

What the last test case demonstrates is that those TypeLoadExceptions are nothing particularly new; they happened even before we introduced support for C# 8's non-public / non-method interface members.