7

我正在寻找RealProxy.NET Core 中的替代品，这个问题将我转发到DispatchProxy.

它有简单的 API，但不清楚如何将现有对象包装到代理中。
例如，有这个接口：

interface IFoo
{
    string Bar(int boo);
}

这个实现：

class FooImpl : IFoo
{
    public string Bar(int boo)
    {
        return $"Value {boo} was passed";
    }
}

如何得到我想要的？

class Program
{
    static void Main(string[] args)
    {
        var fooInstance = new FooImpl();
        var proxy = DispatchProxy.Create<IFoo, FooProxy>();

        var s = proxy.Bar(123);

        Console.WriteLine(s);
    }
}

class FooProxy : DispatchProxy
{
    protected override object Invoke(MethodInfo targetMethod, object[] args)
    {
        return targetMethod.Invoke(/* I need fooInstance here */, args);
    }
}

由于DispatchProxy后代必须有无参数构造函数，我唯一的想法是发明一些方法，如下所示：

class FooProxy : DispatchProxy
{
    private object target;

    public void SetTarget(object target)
    {
        this.target = target;
    }

    protected override object Invoke(MethodInfo targetMethod, object[] args)
    {
        return targetMethod.Invoke(target, args);
    }
}

并以这种方式使用它：

var fooInstance = new FooImpl();
var proxy = DispatchProxy.Create<IFoo, FooProxy>();

((FooProxy)proxy).SetTarget(fooInstance);

// the rest of code...

这是正确的方法吗？

4

2 回答 2

5

IFoo您是对的，除了将生成的代理类型转换为已知的代理类型（FooProxy）并使用自定义方法或属性之外，这里没有其他选择FooProxy。没有公共 API 可以添加构造函数参数或返回代理作为实现类型。但是，DispatchProxy.Create()将返回一个子类的实例，FooProxy其类型是在运行时通过反射和 IL 发射生成的。

如果您正在寻找其他方法来快速包装实现并替换接口方法/虚拟方法，我建议改用模拟框架（FakeItEasy、Moq、NSubstitute 等）。

于 2017-07-05T10:18:11.067 回答
2

您需要创建自己的 Generic 类，该类继承自 DispatchProxy 并具有自己的静态 Create，该类具有来自目标类型的额外参数。

例子

public class AopAction<T>:DispatchProxy
{
  #region Private Fields
  private Action<MethodInfo,object[],object> ActAfter;
  private Action<MethodInfo,object[]> ActBefore;
  private Action<MethodInfo,object[],Exception> ActException;
  private T Decorated;
  #endregion Private Fields

  #region Public Methods
  public static T Create(T decorated,Action<MethodInfo,object[]> actBefore = null,Action<MethodInfo,object[],object> actAfter = null,Action<MethodInfo,object[],Exception> actException = null)
  {
    object proxy = Create<T,AopAction<T>>();
    SetParameters();
    return (T)proxy;
    void SetParameters()
    {
      var me = ((AopAction<T>)proxy);
      me.Decorated = decorated == null ? throw new ArgumentNullException(nameof(decorated)) : decorated;
      me.ActBefore = actBefore;
      me.ActAfter = actAfter;
      me.ActException = actException;
    }
  }
  #endregion Public Methods

  #region Protected Methods
  protected override object Invoke(MethodInfo targetMethod,object[] args)
  {
    _ = targetMethod ?? throw new ArgumentException(nameof(targetMethod));

    try
    {
      ActBefore?.Invoke(targetMethod,args);
      var result = targetMethod.Invoke(Decorated,args);
      ActAfter?.Invoke(targetMethod,args,result);
      return result;
    }
    catch(Exception ex)
    {
      ActException?.Invoke(targetMethod,args,ex);
      throw ex.InnerException;
    }
  }
  #endregion Protected Methods
}

用你的例子

var proxy=AopAction<IFoo>.Create(new FooImpl());
于 2019-10-09T17:28:33.563 回答