C# 8 基本接口的默认方法调用解决方法

Question

根据https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/default-interface-methods 可以使用以下语法显式调用接口基实现。

base(IInterfaceType).Method();

但这似乎还没有实现。

是否有解决方法（例如反射）来实现这一点？

---

说明问题的示例代码

interface IA
{
    void M()
    {
        Console.WriteLine("IA.M");
    }
}

interface IB : IA
{
    void IA.M()
    {
        Console.WriteLine("IB.M");
    }
}

interface IC : IA
{
    void IA.M()
    {
        Console.WriteLine("IC.M");
    }
}

class D : IA, IB, IC
{
    public void M()
    {
        // base(IB).M(); Is not yet supported apparently
        ((IB)this).M(); // Throws stack overflow
    }
}

class Program
{
    static void Main(string[] args)
    {
        D d = new D();
        d.M();
    }
}

Answer 1

问题中的链接指向复制的提案版本from the proposal document in Github

功能是cut in April 2019

结论

删减 C# 8 的 base() 语法。我们打算在下一个主要版本中恢复此功能。

设计会议文档解释说，如果没有运行时支持（无法及时提供），该实现最多只能用于 C#，但不能用于 VB.NET。

如果 B.M 在运行时不存在，则将调用 A.M()。对于 base() 和接口，运行时不支持此操作，因此调用将引发异常。我们希望在运行时添加对此的支持，但发布此版本的成本太高。

我们有一些解决方法，但它们没有我们想要的行为，也不是首选的代码生成器。我们的 C# 实现有点可行，虽然不完全是我们想要的，但 VB 实现会困难得多。此外，VB的实现需要接口实现方法是公共API表面。

至于无限递归，这个

public void M()
{
    ((IB)this).M(); // Throws stack overflow
}

本质上是这样的

public void M()
{
    M(); // Throws stack overflow
}

默认接口成员的调用方式与通过接口显式实现的接口方法相同。此外，您要求调用this 上的方法，而不是base。

Answer 2

有一个解决方法。 我得到它的工作，使用GetFunctionPointer

警告不要使用此代码

static class BaseInterfaceInvocationExtension
{
    private static readonly string invalidExpressionMessage = "Invalid expression.";

    public static void Base<TInterface>(this TInterface owner, Expression<Action<TInterface>> selector)
    {
        if (selector.Body is MethodCallExpression methodCallExpression)
        {
            MethodInfo methodInfo = methodCallExpression.Method;
            string name = methodInfo.DeclaringType.FullName + "." + methodInfo.Name;
            Type type = owner.GetType();
            InterfaceMapping interfaceMapping = type.GetInterfaceMap(typeof(TInterface));
            var map = interfaceMapping;
            var interfaceMethod = map.InterfaceMethods.First(info =>
                info.Name == name);
            var functionPointer = interfaceMethod.MethodHandle.GetFunctionPointer();

            var x = methodCallExpression.Arguments.Select(expression =>
            {
                if (expression is ConstantExpression constantExpression)
                {
                    return constantExpression.Value;
                }
                var lambda = Expression.Lambda(Expression.Convert(expression, expression.Type));
                return lambda.Compile().DynamicInvoke();
            }).ToArray();
            Type actionType = null;
            if (x.Length == 0)
            {
                actionType = typeof(Action);
            }else if (x.Length == 1)
            {
                actionType = typeof(Action<>);
            }
            else if (x.Length == 2)
            {
                actionType = typeof(Action<,>);
            }
            var genericType = actionType.MakeGenericType(methodInfo.GetParameters().Select(t => t.ParameterType).ToArray());
            var instance = Activator.CreateInstance(genericType, owner, functionPointer);
            instance.GetType().GetMethod("Invoke").Invoke(instance, x);
        }
        else
        {
            throw new Exception(invalidExpressionMessage);
        }
    }
}

class D : IA, IB, IC
{
    public void M(int test)
    {
       this.Base<IB>(d => d.M(test));
    }
}

class Program
{
    static void Main(string[] args)
    {
        D d = new D();
        d.M(12);
        Console.ReadKey();
    }
}

Answer 3

这是一种解决方法。这并不理想。也许它会帮助某人。

class C : IB
{
    public void IBM() => (this as IB).M();
}

class D : IA, IB, IC
{
    private C _c = new C();

    public void M()
    {
        _c.IBM();
    }
}