动态创建代理类

Question

我正在尝试动态创建代理类。我知道有一些非常好的框架可以做到这一点，但这纯粹是一个作为学习练习的宠物项目，所以我想自己做。

例如，如果我有以下类实现一个接口：

interface IMyInterface
{
    void MyProcedure();
}

class MyClass : IMyInterface
{
    void MyProcedure()
    {
        Console.WriteLine("Hello World");
    }
}

为了拦截这个类的方法以便记录它们，我正在创建另一个类（我的代理类版本），它实现了相同的接口，但包含对“真实”类的引用。此类执行一个操作（例如记录日志），然后在真实类上调用相同的方法。

例如：

class ProxyClass : IMyInterface
{
    private IMyInterface RealClass { get; set; }

    void MyProcedure()
    {
        // Log the call
        Console.WriteLine("Logging..");

        // Call the 'real' method
        RealClass.MyProcedure();
    }
}

然后调用者调用代理类上的所有方法（我使用一个基本的自制 IoC 容器来注入代理类来代替真实类）。我使用这种方法是因为我希望能够在运行时将RealClass 换成另一个实现相同接口的类。

有没有办法在运行时创建ProxyClass 并填充其RealClass 属性，以便它可以用作真实类的代理？有没有一种简单的方法可以做到这一点，还是我需要使用 Reflection.Emit 之类的东西并生成 MSIL？

Answer 1

看看System.Runtime.Remoting.Proxies.RealProxy。您可以使用它来创建从调用者的角度来看似乎是目标类型的实例。 RealProxy.Invoke 提供了一个点，您可以从该点简单地调用底层类型的目标方法或在调用之前/之后执行额外的处理（例如日志记录）。

以下是在每次方法调用之前/之后记录到控制台的代理示例：

public class LoggingProxy<T> : RealProxy
{
    private readonly T _instance;

    private LoggingProxy(T instance)
        : base(typeof(T))
    {
        _instance = instance;
    }

    public static T Create(T instance)
    {
        return (T)new LoggingProxy<T>(instance).GetTransparentProxy();
    }

    public override IMessage Invoke(IMessage msg)
    {
        var methodCall = (IMethodCallMessage)msg;
        var method = (MethodInfo)methodCall.MethodBase;

        try
        {
            Console.WriteLine("Before invoke: " + method.Name);
            var result = method.Invoke(_instance, methodCall.InArgs);
            Console.WriteLine("After invoke: " + method.Name);
            return new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall);
        }
        catch (Exception e)
        {
            Console.WriteLine("Exception: " + e);
            if (e is TargetInvocationException && e.InnerException != null)
            {
                return new ReturnMessage(e.InnerException, msg as IMethodCallMessage);
            }

            return new ReturnMessage(e, msg as IMethodCallMessage);
        }
    }
}

您将如何使用它：

IMyInterface intf = LoggingProxy<IMyInterface>.Create(new MyClass());
intf.MyProcedure();

控制台的输出将是：

调用前：MyProcedure
你好世界
调用后：MyProcedure

Answer 2

我不建议这样做。通常你会使用一些著名的库，例如 Castle 或 EntLib。对于一些复杂的类，动态生成代理可能是一个相当大的挑战。这是一个使用“Is”多态性的示例。为此，您必须将 base 中的所有方法声明为虚拟方法。您尝试执行此操作的方式（“有”）也是可能的，但对我来说看起来更复杂。

public class A
{
    public virtual void B()
    {
        Console.WriteLine("Original method was called.");
    }
}

class Program
{

    static void Main(string[] args)
    {
        // Create simple assembly to hold our proxy
        AssemblyName assemblyName = new AssemblyName();
        assemblyName.Name = "DynamicORMapper";
        AppDomain thisDomain = Thread.GetDomain();
        var asmBuilder = thisDomain.DefineDynamicAssembly(assemblyName,
                     AssemblyBuilderAccess.Run);

        var modBuilder = asmBuilder.DefineDynamicModule(
                     asmBuilder.GetName().Name, false);

        // Create a proxy type
        TypeBuilder typeBuilder = modBuilder.DefineType("ProxyA",
           TypeAttributes.Public |
           TypeAttributes.Class |
           TypeAttributes.AutoClass |
           TypeAttributes.AnsiClass |
           TypeAttributes.BeforeFieldInit |
           TypeAttributes.AutoLayout,
           typeof(A));
        MethodBuilder methodBuilder = typeBuilder.DefineMethod("B", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot);
        typeBuilder.DefineMethodOverride(methodBuilder, typeof(A).GetMethod("B"));


        // Generate a Console.Writeline() and base.B() calls.
        ILGenerator ilGenerator = methodBuilder.GetILGenerator();
        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.EmitWriteLine("We caught an invoke! B method was called.");

        ilGenerator.EmitCall(OpCodes.Call, typeBuilder.BaseType.GetMethod("B"), new Type[0]);
        ilGenerator.Emit(OpCodes.Ret);

        //Create a type and casting it to A. 
        Type type = typeBuilder.CreateType();
        A a = (A) Activator.CreateInstance(type);

        // Test it
        a.B();
        Console.ReadLine();
    }
}

Answer 3

您可以按照in this question 的描述使用动态对象，但是对于动态生成的强类型对象，您必须使用Reflection.Emit，正如您所怀疑的那样。 This blog 的示例代码显示了类型的动态创建和实例化。

我读到Roslyn 具有使创建动态代理更容易的功能，所以也可以看看那里。

Answer 4

也许我误解了这个问题，构造函数怎么样？

class ProxyClass : IMyInterface
{
    public ProxyClass(IMyInterface someInterface)
    {
        RealClass = someInterface;
    }
   // Your other code...
}