使用装饰器模式有条件地替换行为而不是扩展

Question

最初我有这个结构：

interface IFileBackup
{
    void Backup();
}

class BackUpMechanism1 : IFileBackup
{
    void Backup()
    {
        //Back it up
    }
}

class BackUpMechanism2 : IFileBackup
{
    void Backup()
    {
        //Back it up in another way
    }
}

class Client 
{
    //Instantiation of both mechanisms
    //

    try
    {
        backUpMechanism1.Backup();
    }
    catch(Exception ex)
    {
        backupMechanism2.Backup();
    }
}

我被告知这不是一个非常干净的设计，并使用装饰图案重新设计它。 客户端不应该知道两个备份机制，而只是调用备份，然后第一个机制应该尝试备份文件，如果失败则使用机制2.但是我不明白如何使用装饰器模式，因为从我的理解它扩展了功能，但没有取代功能 - 这就是我想要的......我如何存档？ 我尝试过以下方法：

interface IFileBackup
{
    void Backup();
}

class BackupMechanism1 : IFileBackup
{
    public void Backup()
    {
        try
        {
            Console.WriteLine("Trying to back up to the cloud...");
            throw new Exception();
        }
        catch(Exception ex)
        {
            Console.WriteLine("Oops that failed. We need to back up locally instead...");
        }

    }
}

class BackupMechanism2 : IFileBackup
{
    IFileBackup _fileBackup;
    public BackupMechanism2(IFileBackup fileBackup)
    {
        _filebackup = fileBackup;
    }

    public void Backup()
    {
        //All examples I have seen does this. But doesn't make sense in my case?
        _fileBackup.Backup();

        Console.WriteLine("Backing up locally");
    }
}

//The client does not care about how the backup is done
class Client
{
    static void Main()
    {
        //This is not right, but not sure what I should do in the client.
        BackupMechanism2 localBackup = new BackupMechanism2(new BackupMechanism1());
        localBackup.Backup();

        Console.Read();
    }
}

基本上我想要实现的是拥有两个备份机制。 请客户说备份我不在乎如何。 让第一种机制尝试它的备份方法如果失败然后尝试第二种方法。 我试图使用装饰器模式来扩展（替换）第一个机制的备份行为，如果它失败。 我很难想出一个有意义的设计。

Answer 1

在这种情况下，装饰器模式可用于提供回退实现。 您可以在.Net流实现中找到大量明显的示例。

因此，考虑到这一点，您的代码应如下所示：

class abstract BaseFileBackup
{
  internal BaseFileBackup Fallback;
  internal BaseFileBackup(BaseFileBackup fallback) { Fallback = fallback; }
  internal BaseFileBackup() { }

  internal abstract void DoBackupWork();

  internal void Backup()
  {
    try { DoBackupWork(); }
    catch { if(Fallback != null) Fallback.Backup(); else throw; }
  }
}

class BackUpMechanism1 : BaseFileBackup
{
    internal BackUpMechanism1 (BaseFileBackup fallback): base(fallback) {}
    internal BackUpMechanism1 (): base() {}

    internal void DoBackupWork()
    {
        //Back it up
    }
}

class BackUpMechanism2 : BaseFileBackup
{
    internal BackUpMechanism2 (BaseFileBackup fallback): base(fallback) {}
    internal BackUpMechanism2 (): base() {}

    internal void DoBackupWork()
    {
        //Back it up in another way
    }
}

// and to call it
class Client
{
    static void Main()=>
        new BackupMechanism2(new BackupMechanism1()).Backup();
}

Answer 2

一个非常干净的实现方法是添加复合IFileBackup获取一个IFileBackup对象数组，并逐个尝试，直到找到一个IFileBackup解决方案：

class CompositeBackup {
    private readonly IFileBackup[] chain;
    public CompositeBackup(params IFileBackup[] chain) {
        this.chain = chain.ToArray();
    }
    public void Backup() {
        foreach (var backup in chain) {
            try {
                backup.Backup();
                return;
            } catch {
                continue;
            }
        }
        throw new InvalidOperationException();
    }
}

现在客户端只是这样做：

IFileBackup backup = new CompositeBackup(
    new BackupMechanism1()
,   new BackupMechanism2()
);
backup.Backup();

如果您以后决定添加BackupMechanism3和BackupMechanism4 ，则用户需要将另一个对象添加到备份链中。 其余代码将保持不变。 此外，备份机制本身仍然不会意识到其他机制的存在，这也简化了代码。

Answer 3

在这种情况下，装饰器模式是错误的选择。

你在这里遇到的问题是

• 在条件x下调用一个方法
• 在条件y下调用不同的方法
• ...

这是战略模式的前提条件，您的初始解决方案非常接近于此。 我想到的问题是你使用Exception来确定程序流，这是一件坏事：例外成本堆栈空间，它们只应在特殊情况下抛出。 在您的情况下，预计给定的策略将不起作用

IFileBackupStrategy 
{
    bool Backup(File fileToBackup);
}

IFileBackupContext
{
    File ForBackup { set; }
    bool Backup();
}

class CloudBackUp : IFileBackupStrategy 
{
    private bool _success;

    public bool Backup(File fileToBackup) 
    {
        // code to do backup omitted 
        // it will set the value of _success to false if it was unsuccessful

        return _success;
    }
}   

class LocalBackUp : IFileBackupStrategy 
{
    private bool _success;

    public bool Backup(File fileToBackup) 
    {
        // code to do backup omitted
        // it will set the value of _success to false if it was unsuccessful

        return _success;
    }
}

public class FileBackupContext : IFileBackupContext
{
    private IEnumerable<IFileBackupStrategy> _backupStrategies
    public Context(IEnumerable<IFileBackupStrategy> backupStrategies)
        => _backupStrategies = backupStrategies;

    public File ForBackup { set; private get; }

    public bool Backup()
    {
        bool successFlag;

        foreach(var strategy in _backupStrategies)
        {
            successFlag = strategy.Backup(ForBackup);
            if(successFlag) break;
        }

        return successFlag;
    }
}

在这种情况下，客户端需要注意的全部是IFileBackupContext，而不是用于执行保存的策略。

public class MyBackupClient
{
    private IFileBackupContext _context;

    public MyBackupClient(IFileBackupContext context) => _context = context;

    void SomeMethodThatInvokesBackingUp()
    {
        _context.ForBackup = new File(/* */);

        if(!_context.Backup())
        {
            Console.WriteLine("Failed to backup  the file");
        }
    }
}

这个设计的美妙之处在于你可以添加更多的IFileBackupStrategy实现，将它们注册到你的DI容器中，并且它们可以立即供客户使用而无需单个代码更改或需要重新编译（尽管这最终取决于你如何正在填充您的DI容器）

装饰器模式是一种在SOLID中遵循O原则的方法：即

打开以进行扩展并关闭以进行修改

这意味着您将使用装饰器模式来装饰 现有的类，该类不应更改，但不会显示所需的行为。 线索是模式的名称： Decorator 添加了一些东西，它不会改变任何东西。

装饰模式是一种结构模式 ，而战略模式 ，以及您正在寻找的是一种行为模式

当然，这个例子可以延伸到报告最终采用的策略，并且（如果需要）任何推理替代策略的原因。

编辑：回应Blindy的评论如下 。 这是装饰器模式的范例，它应该演示它不是这个问题的正确模式：

 class Image 
 {
    void Render() { /*  */ }
 }

 class FramedImage : Image 
 { 
    private Image _originalImage;
    public FramedImage(Image original) => _originalImage = original;

    new public void Render()
    {
        /* code to render a frame */
        _originalImage.Render();
    }
 }

Image originalImage = new Image();
Image framedImage = new FramedImage(originalImage);

Image toRender = originalImage;
toRender.Render() // Renders the original image

toRender = framedImage;
toRender.Render(); // Renders the original image in a frame

应该观察到， 不需要将每个Image分配给toRender变量，这仅仅是为了证明装饰器是装饰的。

从这个例子中可以看出，装饰器模式增加了行为， 它还调用了装饰项的行为 。

编辑：继续DSF提出的问题如下 。 以下是控制台应用程序的完整列表，演示如何使用Unity 5.8.6实现此目的

该代码利用了C＃7.0中的新元组。 我刚刚使用了一些随机数生成来确定每个策略实现是否成功执行其任务。

using System;
using System.Collections.Generic;
using System.IO;
using Unity;
using Unity.Injection;

namespace StrategyPattern
{
   public interface IFileBackupContext
   {
      FileStream ForBackup { set; }
      (bool success, string strategy) Backup();
   }

   public interface IFileBackupStrategy 
   {
      (bool success, string name) Backup(FileStream fileToBackup);
   }

   internal class LocalBackUp : IFileBackupStrategy
   {
      private bool _success = false;

      public (bool success, string name) Backup(FileStream fileToBackup)
      {
         // code to do backup omitted
         var random = new Random(DateTime.Now.Millisecond);
         _success = (random.Next() % 3) == 0;
         if(_success) fileToBackup.Close();
         // it will set the value of _success to false if it was unsuccessful
         return (_success, "LocalBackUp");
      }
   }

   internal class CloudBackUp : IFileBackupStrategy
   {
      private bool _success = false;

      public (bool success, string name) Backup(FileStream fileToBackup)
      {
         // code to do backup omitted 
         var random = new Random(DateTime.Now.Millisecond);
         _success = (random.Next() % 3) == 0;
         if (_success) fileToBackup.Close();
         // it will set the value of _success to false if it was unsuccessful

         fileToBackup.Close();
         return (_success, "CloudBackUp");
      }
   }

   public class FileBackupContext : IFileBackupContext
   {
      private readonly IEnumerable<IFileBackupStrategy> _backupStrategies;

      public FileBackupContext(IEnumerable<IFileBackupStrategy> backupStrategies)
         => _backupStrategies = backupStrategies;

      public FileStream ForBackup { set; private get; }

      public (bool success, string strategy) Backup()
      {
         foreach (var strategy in _backupStrategies)
         {
            var (success, name) = strategy.Backup(ForBackup);
            if (success) return (true, name);
         }

         return (false, "");
      }
   }

   public class MyBackupClient
   {
      private IFileBackupContext _context;

      public MyBackupClient(IFileBackupContext context) => _context = context;

      public void BackgUpMyFile()
      {
         _context.ForBackup = new FileStream("d:\\myfile", FileMode.OpenOrCreate);

         (bool success, string strategy) = _context.Backup();

         if (!success)
         {
            Console.WriteLine("Failed to backup  the file");
            return;
         }

         Console.WriteLine($"File backed up using [{strategy}] strategy");
      }
   }

   public class Bootstrap
   {
      private readonly IUnityContainer _container;
      public Bootstrap()
      {
         _container = new UnityContainer();


         _container.RegisterType<IFileBackupContext, FileBackupContext>();
         _container.RegisterType<IFileBackupStrategy, LocalBackUp>("local");
         _container.RegisterType<IFileBackupStrategy, CloudBackUp>("cloud");
         _container.RegisterType<MyBackupClient>();

         _container.RegisterType<Func<IEnumerable<IFileBackupStrategy>>>(new InjectionFactory(c =>
            new Func<IEnumerable<IFileBackupStrategy>>(() =>
               new[]
               {
                  c.Resolve<IFileBackupStrategy>("local"),
                  c.Resolve<IFileBackupStrategy>("cloud")
               }
            )));
      }

      public MyBackupClient GetClient() => _container.Resolve<MyBackupClient>();
   }

   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Press ESC to quit ...");
         Console.WriteLine("Press any other key to try again.");
         Console.WriteLine();
         var client = new Bootstrap().GetClient();
         do
         {
            client.BackgUpMyFile();
         } while (Console.ReadKey().Key != ConsoleKey.Escape);
      }
   }
}