C# Design Patterns: Bridge

using System;
namespace DesignPatterns.Bridge.Conceptual
{
    // Abstraction định nghĩa giao diện cho phần "điều khiển" của hai phân cấp
    // lớp. Nó duy trì một tham chiếu đến một đối tượng của hệ thống phân cấp 
    // Implementation và ủy quyền tất cả công việc thực cho đối tượng này.
    class Abstraction
    {
        protected IImplementation _implementation;
        
        public Abstraction(IImplementation implementation)
        {
            this._implementation = implementation;
        }
        
        public virtual string Operation()
        {
            return "Abstract: Base operation with:\n" + 
                _implementation.OperationImplementation();
        }
    }
    // Có thể mở rộng Abstraction  mà không cần thay đổi các lớp Implementation.
    class ExtendedAbstraction : Abstraction
    {
        public ExtendedAbstraction(IImplementation implementation) : base(implementation)
        {
        }
        
        public override string Operation()
        {
            return "ExtendedAbstraction: Extended operation with:\n" +
                base._implementation.OperationImplementation();
        }
    }
    // Implementation xác định giao diện cho tất cả các lớp hiện thực. Nó không nhất 
    // thiết phải phù hợp với giao diện của Abstraction. Trên thực tế, hai giao diện 
    // có thể hoàn toàn khác nhau. Thông thường, giao diện Implementation chỉ cung 
    // cấp các hoạt động nguyên thủy, trong khi Abstraction xác định các hoạt động
    // cấp cao hơn dựa trên các nguyên thủy đó.
    public interface IImplementation
    {
        string OperationImplementation();
    }
    // Mỗi Concrete Implementation  tương ứng với một nền tảng cụ thể và triển 
    // khai giao diện Implementation bằng cách sử dụng API của nền tảng đó.
    class ConcreteImplementationA : IImplementation
    {
        public string OperationImplementation()
        {
            return "ConcreteImplementationA: The result in platform A.\n";
        }
    }
    class ConcreteImplementationB : IImplementation
    {
        public string OperationImplementation()
        {
            return "ConcreteImplementationA: The result in platform B.\n";
        }
    }
    class Client
    {
        // Ngoại trừ giai đoạn khởi tạo, trong đó một đối tượng Abstraction được liên 
        // kết với một đối tượng Implementation cụ thể, Client chỉ nên phụ thuộc vào  
        // lớp Abstraction . Bằng cách này, Client có thể hỗ trợ bất kỳ kết hợp 
        // hiện thực - trừu tượng nào.
        public void ClientCode(Abstraction abstraction)
        {
            Console.Write(abstraction.Operation());
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Client client = new Client();
            Abstraction abstraction;
            // Client phải có thể hoạt động với bất kỳ tổ hợp hiện thực - trừu tượng
            // nào được định cấu hình trước.
            abstraction = new Abstraction(new ConcreteImplementationA());
            client.ClientCode(abstraction);
            
            Console.WriteLine();
            
            abstraction = new ExtendedAbstraction(new ConcreteImplementationB());
            client.ClientCode(abstraction);
        }
    }
}

Abstraction: Base operation with:
ConcreteImplementationA: Here's the result on the platform A.
ExtendedAbstraction: Extended operation with:
ConcreteImplementationB: Here's the result on the platform B.