C# Design Pattern: Decorator (Wrapper)

using System;
namespace DesignPatterns.Composite.Conceptual
{
    // Giao diện Component cơ sở xác định các hoạt động có thể được thay đổi bởi
    // decorator.
    public abstract class Component
    {
        public abstract string Operation();
    }
    // Concrete Component cung cấp các triển khai mặc định của các hoạt động. 
    // Có thể có một số biến thể của các lớp này.
    class ConcreteComponent : Component
    {
        public override string Operation()
        {
            return "ConcreteComponent";
        }
    }
    // Lớp Decorator cơ sở tuân theo giao diện tương tự như các thành phần khác. 
    // Mục đích chính của lớp này là xác định giao diện bao bọc cho tất cả các Concrete 
    // Component. Việc triển khai mặc định của mã wrap có thể bao gồm một trường 
    // để lưu trữ một component được bọc và phương tiện để khởi tạo nó.
    abstract class Decorator : Component
    {
        protected Component _component;
        public Decorator(Component component)
        {
            this._component = component;
        }
        public void SetComponent(Component component)
        {
            this._component = component;
        }
        // Decorator ủy quyền cho tất cả các component được bao bọc.
        public override string Operation()
        {
            if (this._component != null)
            {
                return this._component.Operation();
            }
            else
            {
                return string.Empty;
            }
        }
    }
    // Concrete Decorator gọi đối tượng được bọc và thay đổi kết quả của nó 
    // theo một cách nào đó.
    class ConcreteDecoratorA : Decorator
    {
        public ConcreteDecoratorA(Component comp) : base(comp)
        {
        }
        // Decorator có thể gọi việc thực thi của hoạt động cha, thay vì gọi trực
        // tiếp đối tượng được bao bọc. Cách tiếp cận này đơn giản hóa việc
        // mở rộng các lớp decorator.
        public override string Operation()
        {
            return $"ConcreteDecoratorA({base.Operation()})";
        }
    }
    // Decorator có thể thực hiện hành vi của chúng trước hoặc sau lời gọi
    // đến một đối tượng được bao bọc.
    class ConcreteDecoratorB : Decorator
    {
        public ConcreteDecoratorB(Component comp) : base(comp)
        {
        }
        public override string Operation()
        {
            return $"ConcreteDecoratorB({base.Operation()})";
        }
    }
    
    public class Client
    {
        // Client hoạt động với tất cả các đối tượng bằng giao diện Component. 
        // Bằng cách này, nó có thể độc lập với các lớp cụ thể của các thành phần 
        // mà nó hoạt động cùng.
        public void ClientCode(Component component)
        {
            Console.WriteLine("RESULT: " + component.Operation());
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Client client = new Client();
           // Bằng cách này, client có thể hỗ trợ cả hai component đơn giản...
            var simple = new ConcreteComponent();
            Console.WriteLine("Client: I get a simple component:");
            client.ClientCode(simple);
            Console.WriteLine();
            // ...cũng như decorator.
            //
            // Lưu ý cách decorator có thể bọc không chỉ các component 
            // đơn giản mà còn cả các decorator khác.
            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've got a simple component:
RESULT: ConcreteComponent
Client: Now I've got a decorated component:
RESULT: ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))