多路复用接口方法调用单个委托并进行多路分解

本文关键字：多路 分解 单个委 复用 接口 方法 调用 | 更新日期: 2023-09-27 17:57:45

我想要的简短版本是：

我正在寻找一种机制，在给定接口的情况下，它将为该接口动态生成一对类，一个多路复用器和一个多路分解器，将调用转换为以下形式的通用委托：object AnyCall( int method_selector, object[] arguments )。复用器类将接受AnyCall委托作为构造时间参数，并通过将每个调用委托给该委托来实现接口。解复用器类将接受对接口的引用作为构造时间参数，它将通过打开方法选择器并调用接口的适当方法来实现委托，并将传递给委托的参数传递给它。

我正在寻找的长版本是：

考虑以下接口：

public interface IFooable
{
    void Moo( int i );
    void Boo( string s, bool b );
}

并考虑实现该接口的以下类：

public class FooImplementation: IFooable
{
    void IFooable.Moo( int i ) { System.Console.WriteLine( "i: " + i ); }
    void IFooable.Boo( string s, bool b ) { System.Console.WriteLine( "s: " + s + ", b: " + b );  }
}

然后考虑使用上述内容的以下类别：

public partial class MuxdemTest
{
    public static void InvokeFoo( IFooable fooable )
    {
        fooable.Moo( 42 );
        fooable.Boo( "fubar!", true );
    }
    public static void Run1()
    {
        IFooable fooable = new FooImplementation();
        InvokeFoo( fooable );
    }
}

这里没什么特别的。

现在让我们假设，我不想直接引用InvokeFoo（）到FooImplementation，而是想在两者之间嵌入一些功能，使我能够使用接口方法调用做一些真正有用的事情，比如，计算对接口的一个方法进行调用的次数；或者将调用转换为消息并将它们传递给驻留在不同线程上的FooImplementation；或者在另一个大陆上；或者其他什么。当然，这个中间功能应该能够在任何接口上工作，而不仅仅是IFooable。

为了实现这一点，我们需要一种方法，将对接口方法的调用多路复用为单个通用委托的调用，然后将它们从对该委托的调用多路分解为接口方法调用。我正在考虑的代表将采用以下形式：

public delegate object AnyCall( int method_selector, object[] arguments );

因此，这里有一个用于IFooable接口的多路复用器的实现：

public class MuxForFooable: IFooable
{
    private readonly AnyCall AnyCall;
    public MuxForFooable( AnyCall anycall ) { AnyCall = anycall; }
    void IFooable.Moo( int i ) { AnyCall( 0, new object[]{ i } ); }
    void IFooable.Boo( string s, bool b ) { AnyCall( 1, new object[]{ s, b } ); }
}

这里是一个用于IFooable接口的多路分解器的实现：

public class DemuxForFooable
{
    public readonly IFooable Target;
    public DemuxForFooable( IFooable target ) { Target = target; }
    public object AnyCall( int method_selector, object[] arguments )
    {
        switch( method_selector )
        {
            case 0: Target.Moo( (int)arguments[0] ); break;
            case 1: Target.Boo( (string)arguments[0], (bool)arguments[1] ); break;
            default: throw new System.InvalidOperationException();
        }
        return null;
    }
}

这里有一段代码利用了上面的内容，实现了与上面的Run1（）方法完全相同的功能，现在的区别是所有调用都通过一个"AnyCall"委托：

public partial class MuxdemTest
{
    public static void Run2()
    {
        IFooable fooable = new FooImplementation();
        DemuxForFooable demux = new DemuxForFooable( fooable );
        MuxForFooable mux = new MuxForFooable( demux.AnyCall );
        InvokeFoo( mux );
    }
}

我唯一的问题是类MuxForFooable和DemuxForFooble是手工编写的，而我希望它们是动态生成的。考虑以下将生成它们的mock方法，以及一段将使用这些方法的代码：

public partial class MuxdemTest
{
    public static T CreateMux<T>( AnyCall anycall )
    {
        if( typeof(T) == typeof(IFooable) )
            return (T)(IFooable)new MuxForFooable( anycall );
        throw new System.NotImplementedException();
    }
    public static AnyCall CreateDemux<T>( T target )
    {
        if( typeof(T) == typeof(IFooable) )
            return new DemuxForFooable( (IFooable)target ).AnyCall;
        throw new System.NotImplementedException();
    }
    public static void Run3()
    {
        IFooable fooable = new FooImplementation();
        AnyCall demux = CreateDemux<IFooable>( fooable );
        IFooable mux = CreateMux<IFooable>( demux );
        InvokeFoo( mux );
    }
}

上面的Run3（）与上面的Run2（）和Run1（）具有完全相同的效果。

那么，有人写过或者知道如何为CreateMux（）和CreateDemux（）编写实际实现吗

您可以假设接口将只包含方法而不包含属性，并且所有方法都将返回void，并且不接受任何"ref"或"out"参数。（尽管我不介意实现这些功能。）

有很多代码示例可以做与我想要的类似的事情，但我发布这个问题是希望有人已经做了我想要做的事情，因为动态代码生成的主题非常棘手。

我知道我想要的可以通过现有的代理框架（如CastleProxy）来实现，但我不想使用整个外部框架来完成这样一个简单的任务，也不想使用这样的框架带来运行时开销。我查看了CastleProxy的源代码，试图弄清楚如何使用它的一部分来做我想做的事情，但我发现它太复杂了，没有任何意义

编辑1:

六个月后，我实现了一个工具，它满足了我在这个问题上的要求。我打算发表一篇关于它的论文，但在此之前，我需要命名方面的帮助，所以我提出了另一个问题：需要命名（封送接口调用）方面的帮助

同时，如果您有答案，请随时添加。

编辑2：

我决定将工具称为"intertwine"，而操作则称为"entwine"和"untwine"。如果你想了解它，这里是：michael.gr-Intertwine：规范化接口调用

多路复用接口方法调用单个委托并进行多路分解

为了实现这一点，我们需要一种方法，将对接口方法的调用多路复用为单个通用委托的调用，然后将它们从对该委托的调用多路分解为接口方法调用。

我不明白你的要求是怎么回事。我想你真正想要的是DynamixProxy，或者类似的东西。有了它，您可以拦截对方法的调用，这似乎正是您想要的。简单示例：

class LoggingIntereceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine(invocation.Method);
        invocation.Proceed();
    }
}
…
public static void Run1()
{
    var generator = new ProxyGenerator();
    IFooable fooable = generator.CreateInterfaceProxyWithTarget<IFooable>(
        new FooImplementation(), new LoggingIntereceptor());
    InvokeFoo(fooable);
}

这会产生以下输出：

Void Moo(Int32)
i: 42
Void Boo(System.String, Boolean)
s: fubar!, b: True

DynamicProxy生成一个在运行时实现接口的类型，所以它应该很快。

如果你不想在你的项目中添加"一个完整的框架"，你不必这样做。你只需要运行上面的例子，只需要一个额外的程序集：Castle。Core.dll。

我刚读了oracle.com:动态代理类，发现java运行时环境提供了我想要的一半。用他们自己的话说：

动态代理类是一个实现接口列表的类在运行时指定，以便通过类实例上的接口将被编码和调度通过统一接口连接到另一个对象。

相关的功能在java.lang.reflect包中：Proxy类创建多路复用器，InvocationHandler接口扮演我的AnyCall委托的角色。Java似乎没有提供任何创建多路分解器的方法；为什么，我不知道。

相关文章：