C# 将接口方法调用多路复用到单个委托并解多路复用

我正在寻找的简短版本如下：

我正在寻找一种机制，在给定一个接口的情况下，该机制将为该接口动态生成一对类，一个多路复用器和一个解多路复用器，将调用转换为以下形式的通用委托：

objectanycall（int-method\u-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 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 } ); }
}

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;
    }
}

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

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 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 } ); }
}

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;
    }
}

然后使用下面的类来考虑：

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 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 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 } ); }
}

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;
    }
}

以下是IFooable接口的解复用器的实现：

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 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 } ); }
}

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和DemuxForFooable类是手工编写的，而我希望动态生成它们。考虑下面的生成它们的模拟方法，以及使用这些方法的代码：

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 );
    }
}

公共部分类MuxdemTest
{
公共静态T CreateMux（AnyCall AnyCall）
{
if（typeof（T）=typeof（IFooable））
返回（T）（IFooable）新MUXFORFOABLE（anycall）；
抛出新系统。NotImplementedException（）；
}
公共静态任意调用CreateDemux（T目标）
{
if（typeof（T）=typeof（IFooable））
返回新的DemuxForFooable（（IFooable）目标）；
抛出新系统。NotImplementedException（）；
}
公共静态void Run3（）
{
IFooable fooable=new foooimplementation（）；
AnyCall demux=CreateDemux（可移动）；
IFooable mux=CreateMux（demux）；
调用fo（mux）；
}
}

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

那么，有没有人编写过或知道如何编写CreateMux（）和CreateDemux（）的实际实现？

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

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

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

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

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

编辑2： 我决定将该工具称为“缠绕”，操作称为“缠绕”和“解开”。如果你想了解它，这里是：

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

我看不出这与你的要求有什么关系。我想你真正想要的是，或者类似的东西。使用它，您可以拦截对方法的调用，这似乎正是您想要的。简单的例子：

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);
}

DynamicProxy生成一个在运行时实现接口的类型，因此它应该非常快

如果您不想将“整个框架”添加到项目中，则不必这样做。运行上述示例所需的只是一个附加程序集：Castle.Core.dll。

我刚刚阅读并发现java运行时环境提供了我想要的一半。用他们自己的话来说：

动态代理类是实现接口列表的类 在运行时指定，以便通过