编辑1：

Question

我正在寻找的简短版本是：

我正在寻找一种机制，在给定接口的情况下，它将为该接口动态生成一对类，一个多路复用器和一个多路分解器，它们将调用转换为以下形式的通用委托： {1}}。多路复用器类将接受AnyCall委托作为构造时参数，并且它将通过委托对委托的每个调用来实现接口。解复用器类将接受对接口的引用作为构造时参数，它将通过切换方法选择器并调用接口的适当方法来实现委托，并将传递给委托的参数传递给它。 / p>

我正在寻找的长版本是：

考虑以下界面：

object AnyCall( int method_selector, object[] arguments )

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

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

这里没什么好看的。

现在让我们假设不是给InvokeFoo（）直接引用FooImplementation，我想在两者之间嵌入一些功能，这样我就可以通过接口方法调用做一些非常有用的事情，比如说count调用接口的其中一个方法的次数;或者将调用转换为消息并将它们传递给驻留在不同线程上的FooImplementation;或在不同的大陆;管他呢。当然，这种inbetween功能应该能够在任何接口上工作，而不仅仅是IFooable。

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

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

因此，这是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 } ); }
}

这是一段利用上述内容的代码，与上面的Run1（）方法完全相同，现在的区别在于所有调用都通过'AnyCall'委托：

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

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

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

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

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

您可以假设接口只包含方法而没有属性，并且所有方法都将返回void并且不接受任何“ref”或“out”参数。（即使我不介意允许这些事情的实现。）

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

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

编辑1：

六个月后，我实施了一个工具，可以完成我在这个问题中要求的工具。我将发表一篇关于它的论文，但在我这样做之前，我需要帮助命名，所以我打开了另一个问题：Need help with naming (marshaling interface calls)

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

编辑2：

我决定调用工具“intertwine”，操作“缠绕”和“unwine”。如果您想了解它，请点击此处：michael.gr - Intertwine: Normalizing Interface Invocations

Answer 1

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

我不知道这是如何符合您的要求的。我认为你真正想要的是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。

Answer 2

我刚刚阅读oracle.com: Dynamic Proxy Classes并发现java运行时环境提供了我正在寻找的一半。用他们自己的话说：

动态代理类是实现接口列表的类在运行时指定，以便通过其中一个方法调用将对类的实例上的接口进行编码和分派通过统一的界面到另一个对象。

相关工具位于java.lang.reflect包中：Proxy类创建多路复用器，InvocationHandler接口扮演我的AnyCall代理角色。 Java似乎没有提供任何创建多路分解器的方法;为什么，我不知道。

多路复用接口方法调用单个委托和解复用

编辑1：

编辑2：

2 个答案: