3

假设我有一个接口 IFoo

interface IFoo
{
  int Bar();
  int Bar2();
  void VBar();
  //etc,
}

我可以创建一个包装器来接受任何 IFoo 对象并在实际调用之前/之后做一些事情吗？

例如当我做这样的事情时

IFoo wrappedFoo = new Wrapper<IFoo>(actualFooObject).Object;
wrappedFoo.Bar();

然后 wrapper.Bar() 方法实际上执行这样的事情

PreCall(); //some code that I can define in the wrapper
actualFooObject.Bar();
PostCall();

有没有一种简单而干净的方法来做到这一点？

4

4 回答 4

0

我看不到这样做的“干净和简单”的方式。

我能想到的最好的选择是编写一个泛型Wrapper<T>来封装和实例化T并实现泛型Precall和Postcall方法：

public class Wrapper<T>
{
    protected T _instance;
    public Wrapper(T instance)
    {
        this._instance = instance;
    }
    protected virtual void Precall()
    {
        // do something
    }
    protected virtual void Postcall()
    {
        // do something
    }
}

这样您就可以编写自己FooWrapper的接口IFoo（或任何其他接口）并委托方法调用：

public class FooWrapper :Wrapper<IFoo>, IFoo
{
    public FooWrapper(IFoo foo)
        : base(foo)
    {
    }
    public int Bar()
    {
        base.Precall(); return base._instance.Bar(); base.Postcall();
    }
    public int Bar2()
    {
        base.Precall(); return base._instance.Bar2(); base.Postcall();
    }
    public void VBar()
    {
        base.Precall();  base._instance.VBar(); base.Postcall();
    }
}

所以你可以像这样使用它：

IFoo f = new ActualFooClass();
IFoo wf = new FooWrapper(f);
f.Bar();

当然，如果你的PrecallandPostcall方法不是泛型的，那么使用Wrapper<T>类真的没有意义。随手去吧FooWrapper。

于 2013-04-09T04:25:40.040 回答
0

如果你需要在 and 上有一些东西PreCall()，PostCall简单的方法是在代理基础方法下包装

  public abstract class ProxyBase
  {
    public void Execute()
    {
      PreCondition();
      Call();
      PostCondition();
    }
    private void PreCondition()
    {
      Console.WriteLine("ProxyBase.PreCondition()");
    }
    private void PostCondition()
    {
      Console.WriteLine("ProxyBase.PreCondition()");
    }
    protected abstract void Call();
  }
  public class AppProxy<T> : ProxyBase where T : IApp
  {
    private IApp _app;

    public AppProxy<T> Init(IApp app)
    {
      _app = app;
      return this;
    }

    protected override void Call()
    {
      Console.WriteLine("AppProxy.Call()");
      _app.Call();
    }

    public IApp Object
    {
      get { return _app; }
    }
  }

  public interface IApp
  {
    void Call();
  }

  public interface IFoo : IApp
  {

  }

  public class ActualFoo : IApp
  {
    public void Call()
    {
      Console.WriteLine("ActualFoo.Call()");
    }
  }

 class Program
  {
    static void Main(string[] args)
    {
      ActualFoo actualFoo = new ActualFoo();
      var app = new AppProxy<IFoo>().Init(actualFoo);
      app.Execute();
      var o = app.Object as ActualFoo;

      Console.ReadLine();

    }
  }

--------------- 输出 --------------
ProxyBase.PreCondition()
AppProxy.Call()
ActualFoo.Call()
ProxyBase.PreCondition()

于 2013-04-09T04:05:33.737 回答
0

您可以为这种方法使用代码契约。查看用户手册(pdf)2.8 Interface Contracts部分。

于 2013-04-09T03:01:02.813 回答
0

您可以使用 AOP。我已经使用这个库很长一段时间了：

http://www.postsharp.net/products

于 2013-04-09T03:11:29.420 回答