Intercepting explicit interface implementations with Castle Dynamic Proxy

Question

I am having trouble getting Castle Dynamic Proxy to intercept methods that are explicit interface implementations. I read here http://kozmic.pl/category/dynamicproxy/ that it should be possible to do this. Here are my classes;

internal interface IDomainInterface
{
    string DomainMethod();
}

public class DomainClass : IDomainInterface
{
    string IDomainInterface.DomainMethod()
    {
        return "not intercepted";
    }
}

Here is my interceptor class;

public class DomainClassInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        if (invocation.Method.Name == "DomainMethod")
            invocation.ReturnValue = "intercepted";
        else
            invocation.Proceed();
    }
}

And here is my test (which fails);

    [TestClass]
    public void can_intercept_explicit_interface_implementation()
    {
        // Create proxy
        var generator = new ProxyGenerator();
        var interceptor = new DomainClassInterceptor();
        var proxy = (IDomainInterface)generator.CreateClassProxy(typeof(DomainClass), interceptor);

        // Invoke proxy method
        var result = proxy.DomainMethod();

        // Check method was intercepted -- fails
        Assert.AreEqual("intercepted", result);
    }

In addition to not being able to intercept the explicit interface implementation, it also seems that I am not receiving a notification of a non-proxyable member. Here is my proxy generation hook (which acts as a spy);

public class DomainClassProxyGenerationHook : IProxyGenerationHook
{
    public int NonProxyableCount;

    public void MethodsInspected() {}

    public void NonProxyableMemberNotification(Type type, MemberInfo memberInfo)
    {
        NonProxyableCount++;
    }

    public bool ShouldInterceptMethod(Type type, MethodInfo methodInfo)
    {
        return true;
    }
}

Here is my test (which again fails);

    [TestMethod] 
    public void receive_notification_of_nonproxyable_explicit_interface_implementation()
    {
        // Create proxy with generation hook
        var hook = new DomainClassProxyGenerationHook();
        var options = new ProxyGenerationOptions(hook);
        var generator = new ProxyGenerator();
        var interceptor = new DomainClassInterceptor();
        var proxy = (IDomainInterface)generator.CreateClassProxy(typeof(DomainClass), options, interceptor);

        // Check that non-proxyable member notification was received -- fails
        Assert.IsTrue(hook.NonProxyableCount > 0);
    }

Has anyone had success in getting DP to intercept explicit interface implementations? If so, how?

Answer 1

You are creating a class proxy. Class proxy only intercepts virtual methods on the class, and an explicit implementation of an interface method in C# by definition is not virtual (since it's private).

If you want to intercept methods on the interface you need to explicitly tell DynamicProxy about it

var proxy = (IDomainInterface)generator.CreateClassProxy(typeof(DomainClass), new Type[] { typeof(IDomainInterface) }, interceptor);

Also your interface is marked as internal so made sure it's public for DynamicProxy (either make the interface public or add InternalsVisibleToAttribute).

With that your first test will pass, and the method will be intercepted.