使用装饰器设计模式时的一个问题

Question

我们目前正在使用装饰器设计模式来执行一些缓存。所以我们有一堆看起来像这样的类：

interface IComponent
{
  object Operation();
  object AnotherOperation();
}
public ConcreteComponentA : IComponent
{
  public object Operation()
  {
    return new object();
  }
  public object AnotherOperation()
  {
    return new object();
  }
}
public ConcreteDecoratorA : IComponent
{
  protected IComponent component;
  public object Operation()
  {
    if(!this.cache.Contains("key")
    {
      this.cache["key"] = this.component.Operation();
    }
    return this.cache["key"];
}

因此，如果客户端想要使用缓存，他们将创建一个新的 ConcreteDecoratorA 并将 ConcreteComponentA 传递给构造函数。我们面临的问题是，假设 AnotherOperation() 需要调用 Operation 才能完成工作。 ConcreteComponentA 现在可能看起来像这样：

public ConcreteComponentA : IComponent
{
  public object Operation()
  {
    return new object();
  }
  public object AnotherOperation()
  {
    object a = this.Operation();
    // Do some other work
    return a;
  }
}

问题是在AnotherOperation()方法中调用Operation()方法时，装饰器实现永远不会被调用，因为装饰器显然不在ConcreteComponentA的继承层次中。

那么我们是否在某个地方做出了糟糕的设计决定，或者这只是我们必须接受的装饰器设计模式的限制？

请注意，在我的真实示例中，ConcreteComponentA 是我们无法控制的第三方系统的包装器。我们开发了 IComponent 和一堆 POCO，我们使用它们来抽象出第三方系统。在这种情况下，我们必须对他们的系统进行两次调用才能获取所需的数据，这就是我们进行这两次调用的地方。

Answer 1

您可以创建另一个操作的重载，它将 IComponent 用作参数。

public ConcreteComponentA : IComponent
{
  public object Operation()
  {
    return new object();
  }
  public object AnotherOperation()
  {
    return AnotherOperation(this);
  }
  public object AnotherOperation(IComponent comp)
  {
    object a = comp.Operation();
    // Do some other work
    return a;
  }
}

public ConcreteDecoratorA : IComponent
{
  protected IComponent component;
  public object Operation()
  {
    if(!this.cache.Contains("key")
    {
      this.cache["key"] = this.component.Operation();
    }
    return this.cache["key"];
  }
  public object AnotherOperation()
  {
    return this.component.AnotherOperation(this);
  }
}

Answer 2

创建一个允许装饰器手动“覆盖” Operation 方法的委托（或一个事件，如果您想支持多个装饰器）。

public class ConcreteComponentA : IComponent
{
    public event Func<object> OperationOverride;

    public object Operation()
    {
        if (OperationOverride != null)
        {
            return OperationOverride();
        }
        return new object();
    }

    public object AnotherOperation()
    {
        var a = Operation();
        // Do some other work
        return a;
    }
}

在装饰器构造函数中尝试将组件实例转换为您的具体组件类型并附加一个操作覆盖委托。

public class ConcreteDecoratorA : IComponent, IDisposable
{
    protected readonly IComponent component;

    public ConcreteDecoratorA(IComponent component)
    {
        this.component = component;
        AttachOverride();
    }

    public void Dispose()
    {
        DetachOverride();
    }

    private void AttachOverride()
    {
        var wrapper = component as ConcreteComponentA;
        if (wrapper != null)
        {
            wrapper.OperationOverride += Operation;
        }
    }

    private void DetachOverride()
    {
        var wrapper = component as ConcreteComponentA;
        if (wrapper != null)
        {
            wrapper.OperationOverride -= Operation;
        }
    }
}

使用一次性模式确保在不再需要装饰器时事件被解除钩子以防止内存泄漏。

Answer 3

自调用是装饰器设计模式的局限，这是真的。 无需修改或添加任何额外基础结构即可拦截基本组件自调用的唯一方法是继承。因此，如果您不喜欢上面的解决方案并且您仍然希望拥有装饰器为您提供的灵活性（拥有任意数量和任意顺序的装饰器），您可以寻找生成子类型的动态代理的实现（即 Unity拦截，Castle 动态代理）。

Answer 4

我更喜欢使用继承而不是封装来做我的缓存，这样，缓存的值将使用缓存方法，因为它是虚拟的：

public ConcreteComponentA : IComponent
{
  public virtual object Operation()
  {
    return new object();
  }
  public object AnotherOperation()
  {
    object a = this.Operation();
    // Do some other work
    return a;
  }
}


public CachingComponentA : ConcreteComponentA
{
     public override object Operation()
     {
         if(!this.cache.Contains("key")
         {
            this.cache["key"] = base.Operation();
         }
         return this.cache["key"];
     }
}

那么当你使用装饰器对象时，this.Operation() 将使用装饰器类。

Answer 5

由于您可以控制两个级别（ConcreteComponentA 和 ConcreteDecoratorA），因此您可以让他们来回手写笔记：

interface IComponent 
{
  Action<object> myNotify;
  object Operation(); object AnotherOperation(); 
} 

public ConcreteComponentA : IComponent
{
  public Action<object> myNotify = null;
  public object Operation()
  {
    object result = new object();
    if (myNotify != null)
    {
      myNotify(result);
    }
    return result;
  }

  public object AnotherOperation()
  {
    return Operation();
  }
}

public ConcreteDecoratorA : IComponent
{
  public ConcreteDecoratorA(IComponent target)
  {
    component = target;
    target.myNotify = notifyMe;
  }
  protected IComponent component;
  protected notifyMe(object source)
  {
    this.cache["key"] = source;
  }

  public Action<object> myNotify = null;
  public object Operation()
  {
    if(!this.cache.Contains("key")
    {
      return component.Operation();
    }
    return this.cache["key"];
  }
  public object AnotherOperation()
  {

  }
}