理解c#中的装饰器设计模式

interface IComponent
{
    void Operation();
}
class Component : IComponent
{
    public void Operation()
    {
        Console.WriteLine("I am walking ");
    }
}
class DecoratorA : IComponent
{
    IComponent component;
    public DecoratorA(IComponent c)
    {
        component = c;
    }
    public void Operation()
    {
        component.Operation();
        Console.WriteLine("in the rain");
    }
}
class DecoratorB : IComponent
{
    IComponent component;
    public DecoratorB(IComponent c)
    {
        component = c;
    }
    public void Operation()
    {
        component.Operation();
        Console.WriteLine("with an umbrella");
    }
}
class Client
{
    static void Main()
    {
        IComponent component = new Component();
        component.Operation();
        DecoratorA decoratorA = new DecoratorA(new Component());
        component.Operation();
        DecoratorB decoratorB = new DecoratorB(new Component());
        component.Operation();
        Console.Read();
    }
 }

class Photo
{
    public void Draw()
    {
        Console.WriteLine("draw a photo");
    }
}
class BorderedPhoto : Photo
{
    public void drawBorder()
    {
        Console.WriteLine("draw a border photo");
    }
}
class FramePhoto : BorderedPhoto
{
    public void frame()
    {
        Console.WriteLine("frame the photo");
    }
}
class Client
{
    static void Main()
    {
        Photo p = new Photo();
        p.Draw();
        BorderedPhoto b = new BorderedPhoto();
        b.Draw();
        b.drawBorder();
        FramePhoto f = new FramePhoto();
        f.Draw();
        f.drawBorder();
        f.frame();
    }
}

这应该是一个评论，但是我的话太多了。

例如，您有一个对象和接口，如Repository : IRepository。

public interface IRepository
{
    void SaveStuff();
}
public class Repository : IRepository
{
    public void SaveStuff()
    {
        // save stuff   
    }
}

和client，可能是别人写的

class RepoClient
{
    public void DoSomething(IRepository repo)
    {
        //...
        repo.SaveStuff();
    }
}

一旦你决定了，所有对存储库的调用都应该被记录。但是您有一个问题:Repository类来自外部库，您不想更改该代码。所以你需要扩展Repository的行为。编写RepositoryLogDecorator : IRepository，并在每个方法中执行日志记录，如

public class RepositoryLogDecorator  : IRepository
{
    public IRepository _inner;
    public RepositoryLogDecorator(IRepository inner)
    {
        _inner = inner;
    }
    public void SaveStuff()
    {
        // log enter to method
        try
        {
            _inner.SaveStuff();
        }
        catch(Exception ex)
        {
            // log exception
        }       
        // log exit to method
    }
}

所以，在你使用client作为 之前

var client = new RepoClient();
client.DoSomething(new Repository());

但是现在你可以用

var client = new RepoClient();
client.DoSomething(new RepositoryLogDecorator(new Repository()));

注意，这是一个非常简单的例子。在实际项目中，对象主要是用DI容器创建的，您可以通过更改一些配置来使用decorator。

因此，装饰器用于扩展对象的功能，而不改变对象或客户端。

装饰器的另一个好处:你的装饰器不依赖于Repository的实现。只依赖于一个接口IRepository。为什么这是一个优势?如果你决定编写自己的IRepository

实现

public class MyAwesomeRepository : IRepository
{
    public void SaveStuff()
    {
        // save stuff, but AWESOME!
    }
}

你将能够自动用decorator来装饰它，它已经存在了

var client = new RepoClient();
client.DoSomethig(new RepositoryLogDecorator(new MyAwesomeRepository()));

想看真实软件的例子吗?(只是作为示例，代码很难看，我知道)=>到这里

Youtube上有一个PatternCraft系列，解释了《星际争霸》中的设计模式，你应该在这里查看有关decorator的视频。

在上面的视频中，作者给出了一个Marine和WeaponUpgrade的例子。

在游戏中你将有一个Marine，然后你可以升级它的武器:

marine = new WeaponUpgrade(marine);

注意，你仍然有一个陆战队员在那里，它不是一个新的单位，它是相同的单位，修改了它的属性。

public class MarineWeaponUpgrade : IMarine
{
    private IMarine marine;
    public MarineWeaponUpgrade(IMarine marine)
    {
        this.marine = marine;
    }
    public int Damage
    {
        get { return this.marine.Damage + 1; } // here
        set { this.marine.Damage = value; }
    }
}

您可以通过创建一个类来实现与您的单元相同的接口，并访问您的单元属性来修改值。

有一个在CodeWars上挑战你完成武器和盔甲装饰的海军陆战队。

Per GOF page Decorator设计模式:

动态地为对象附加额外的职责。装饰器为扩展功能提供了一个灵活的选择，而不是子类化。

在你的第二个例子中，你使用继承来扩展类的行为，我相信这在技术上不是一个Decorator设计模式。

装饰器模式允许您将特定的行为添加到给定类型的单个对象中，而不会影响相同类型的其他实例。

在第二个示例中，这是正常的继承，类的所有实例继承修改后的行为。