Decorator em C#

using System; namespace RefactoringGuru.DesignPatterns.Composite.Conceptual { // The base Component interface defines operations that can be altered by // decorators. public abstract class Component { public abstract string Operation(); } // Concrete Components provide default implementations of the operations. // There might be several variations of these classes. class ConcreteComponent : Component { public override string Operation() { return "ConcreteComponent"; } } // The base Decorator class follows the same interface as the other // components. The primary purpose of this class is to define the wrapping // interface for all concrete decorators. The default implementation of the // wrapping code might include a field for storing a wrapped component and // the means to initialize it. abstract class Decorator : Component { protected Component _component; public Decorator(Component component) { this._component = component; } public void SetComponent(Component component) { this._component = component; } // The Decorator delegates all work to the wrapped component. public override string Operation() { if (this._component != null) { return this._component.Operation(); } else { return string.Empty; } } } // Concrete Decorators call the wrapped object and alter its result in some // way. class ConcreteDecoratorA : Decorator { public ConcreteDecoratorA(Component comp) : base(comp) { } // Decorators may call parent implementation of the operation, instead // of calling the wrapped object directly. This approach simplifies // extension of decorator classes. public override string Operation() { return $"ConcreteDecoratorA({base.Operation()})"; } } // Decorators can execute their behavior either before or after the call to // a wrapped object. class ConcreteDecoratorB : Decorator { public ConcreteDecoratorB(Component comp) : base(comp) { } public override string Operation() { return $"ConcreteDecoratorB({base.Operation()})"; } } public class Client { // The client code works with all objects using the Component interface. // This way it can stay independent of the concrete classes of // components it works with. public void ClientCode(Component component) { Console.WriteLine("RESULT: " + component.Operation()); } } class Program { static void Main(string[] args) { Client client = new Client(); var simple = new ConcreteComponent(); Console.WriteLine("Client: I get a simple component:"); client.ClientCode(simple); Console.WriteLine(); // ...as well as decorated ones. // // Note how decorators can wrap not only simple components but the // other decorators as well. ConcreteDecoratorA decorator1 = new ConcreteDecoratorA(simple); ConcreteDecoratorB decorator2 = new ConcreteDecoratorB(decorator1); Console.WriteLine("Client: Now I've got a decorated component:"); client.ClientCode(decorator2); } } } 

Client: I get a simple component: RESULT: ConcreteComponent Client: Now I've got a decorated component: RESULT: ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))