2

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

我正在寻找一种机制，在给定接口的情况下，它将为该接口动态生成一对类，一个多路复用器和一个多路分解器，它将调用/从以下形式的通用委托转换：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 和 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 );
    }
}

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

那么，有没有人写过或知道如何为 CreateMux() 和 CreateDemux() 写实际的实现？

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

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

我知道我想要的可以使用现有的代理框架（如 CastleProxy）来完成，但我不想为这样一个简单的任务使用整个外部框架，也不希望使用这样的框架产生运行时开销。我查看了 CastleProxy 的源代码，试图弄清楚如何使用它的一部分来做我想做的事，但我发现它太复杂了，无法理解它。

编辑1：

六个月后，我实现了一个工具，可以满足我在这个问题中的要求。我打算发表一篇关于它的论文，但在此之前，我需要命名方面的帮助，所以我提出了另一个问题：Need help with Naming (marshaling interface calls)

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

编辑2：

我决定称该工具为“ intertwine” ，操作为“entwine ”和“untwine”。如果你想了解它，这里是：michael.gr - Intertwine: Normalizing Interface Invocations

4

2 回答 2

1

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

我看不出这是如何从您的要求中得出的。我认为您真正想要的是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。

于 2011-05-27T19:10:29.177 回答
0

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

动态代理类是实现在运行时指定的接口列表的类，这样通过类实例上的一个接口的方法调用将被编码并通过统一接口分派到另一个对象。

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

于 2013-11-08T12:31:01.507 回答