Bridge design pattern C#

The Abstraction defines the interface for the control part of the two class hierarchies. It maintains a reference to an object of the Implementation hierarchy and delegates all of the real work to this object.

class Abstraction
{
  protected IImplementation _implementation;
        
  public Abstraction(IImplementation implementation)
  {
       this._implementation = implementation;
  }
        
  public virtual string Operation()
  {
      return "Abstract: Base operation with:\n" + 
             _implementation.OperationImplementation();
  }
}

The Implementation defines the interface for all implementation classes. It doesn't have to match the Abstraction's interface. In fact, the two interfaces can be entirely different. Typically the Implementation interface provides only primitive operations, while the Abstraction defines higher-level operations based on those primitives.

public interface IImplementation
{
   string OperationImplementation();
}

You can extend the Abstraction without changing the Implementation classes.

class ExtendedAbstraction : Abstraction
{
   public ExtendedAbstraction(IImplementation implementation) : base(implementation)
   {
   }
        
   public override string Operation()
   {
       return "ExtendedAbstraction: Extended operation with:\n" +
              base._implementation.OperationImplementation();
   }
}

Each Concrete Implementation corresponds to a specific platform and implements the Implementation interface using that platform's API.

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";
   }
}

Except for the initialization phase, where an Abstraction object gets linked with a specific Implementation object, the client code should only depend on the Abstraction class. This way the client code can support any abstraction-implementation combination.

class Client
{
   public void ClientCode(Abstraction abstraction)
   {
       Console.Write(abstraction.Operation());
   }
}

The Client code should be able to work with any pre-configured abstraction-implementation combination.

class Program
{
   static void Main(string[] args)
   {
       Client client = new Client();

       Abstraction abstraction;
       abstraction = new Abstraction(new ConcreteImplementationA());
       client.ClientCode(abstraction);
            
       Console.WriteLine();
            
       abstraction = new ExtendedAbstraction(new ConcreteImplementationB());
       client.ClientCode(abstraction);
   }
}

Let's compile and run. When we run the result will be:

Abstract: Base operation with:
ConcreteImplementationA: The result in platform A.

ExtendedAbstraction: Extended operation with:
ConcreteImplementationA: The result in platform B.

The Ray Code is AWESOME!!!
wikipedia

Find Ray on:

facebook
youtube
The Ray Code
Ray Andrade