Structural Patterns : Bridge-优快云博客

本文详细介绍了桥接模式的概念及其在软件开发中的应用。通过两个示例，一个是结构化的简单示例，另一个是现实世界的应用场景，展示了如何将抽象与实现分离，使两者能够独立变化。该模式有助于解耦业务对象与其数据对象，便于实现动态演化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Gieno Design Pattern : Brige

Bridge

definition

Decouple an abstraction from its implementation so that the two can vary independently.

Frequency of use: medium

participants

The classes and/or objects participating in this pattern are:

Abstraction (BusinessObject)
- defines the abstraction's interface.
- maintains a reference to an object of type Implementor.
RefinedAbstraction (CustomersBusinessObject)
- extends the interface defined by Abstraction.
Implementor (DataObject)
- defines the interface for implementation classes. This interface doesn't have to correspond exactly to Abstraction's interface; in fact the two interfaces can be quite different. Typically the Implementation interface provides only primitive operations, and Abstraction defines higher-level operations based on these primitives.
ConcreteImplementor (CustomersDataObject)
- implements the Implementor interface and defines its concrete implementation.

sample code in C#

This structural code demonstrates the Bridge pattern which separates (decouples) the interface from its implementation. The implementation can evolve without changing clients which use the abstraction of the object.

// Bridge pattern -- Structural example

using System;

namespace DoFactory.GangOfFour.Bridge.Structural
{

  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      Abstraction ab = new RefinedAbstraction();

      // Set implementation and call
      ab.Implementor = new ConcreteImplementorA();
      ab.Operation();

      // Change implemention and call
      ab.Implementor = new ConcreteImplementorB();
      ab.Operation();

      // Wait for user
      Console.Read();
    }
  }

  // "Abstraction"

  class Abstraction
  {
    protected Implementor implementor;

    // Property
    public Implementor Implementor
    {
      set{ implementor = value; }
    }

    public virtual void Operation()
    {
      implementor.Operation();
    }
  }

  // "Implementor"

  abstract class Implementor
  {
    public abstract void Operation();
  }

  // "RefinedAbstraction"

  class RefinedAbstraction : Abstraction
  {
    public override void Operation()
    {
      implementor.Operation();
    }
  }

  // "ConcreteImplementorA"

  class ConcreteImplementorA : Implementor
  {
    public override void Operation()
    {
      Console.WriteLine("ConcreteImplementorA Operation");
    }
  }

  // "ConcreteImplementorB"

  class ConcreteImplementorB : Implementor
  {
    public override void Operation()
    {
      Console.WriteLine("ConcreteImplementorB Operation");
    }
  }
}

Output

ConcreteImplementorA Operation
ConcreteImplementorB Operation

This real-world code demonstrates the Bridge pattern in which a BusinessObject abstraction is decoupled from the implementation in DataObject. The DataObject implementations can evolve dynamically without changing any clients.

// Bridge pattern -- Real World example

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Bridge.RealWorld
{

  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      // Create RefinedAbstraction
      Customers customers =
        new Customers("Chicago");

      // Set ConcreteImplementor
      customers.Data = new CustomersData();

      // Exercise the bridge
      customers.Show();
      customers.Next();
      customers.Show();
      customers.Next();
      customers.Show();
      customers.New("Henry Velasquez");

      customers.ShowAll();

      // Wait for user
      Console.Read();
    }
  }

  // "Abstraction"

  class CustomersBase
  {
    private DataObject dataObject;
    protected string group;

    public CustomersBase(string group)
    {
      this.group = group;
    }

    // Property
    public DataObject Data
    {
      set{ dataObject = value; }
      get{ return dataObject; }
    }

    public virtual void Next()
    {
      dataObject.NextRecord();
    }

    public virtual void Prior()
    {
      dataObject.PriorRecord();
    }

    public virtual void New(string name)
    {
      dataObject.NewRecord(name);
    }

    public virtual void Delete(string name)
    {
      dataObject.DeleteRecord(name);
    }

    public virtual void Show()
    {
      dataObject.ShowRecord();
    }

    public virtual void ShowAll()
    {
      Console.WriteLine("Customer Group: " + group);
      dataObject.ShowAllRecords();
    }
  }

  // "RefinedAbstraction"

  class Customers : CustomersBase
  {
    // Constructor
    public Customers(string group) : base(group)
    {
    }

    public override void ShowAll()
    {
      // Add separator lines
      Console.WriteLine();
      Console.WriteLine ("------------------------");
      base.ShowAll();
      Console.WriteLine ("------------------------");
    }
  }

  // "Implementor"

  abstract class DataObject
  {
    public abstract void NextRecord();
    public abstract void PriorRecord();
    public abstract void NewRecord(string name);
    public abstract void DeleteRecord(string name);
    public abstract void ShowRecord();
    public abstract void ShowAllRecords();
  }

  // "ConcreteImplementor"

  class CustomersData : DataObject
  {
    private ArrayList customers = new ArrayList();
    private int current = 0;

    public CustomersData()
    {
      // Loaded from a database
      customers.Add("Jim Jones");
      customers.Add("Samual Jackson");
      customers.Add("Allen Good");
      customers.Add("Ann Stills");
      customers.Add("Lisa Giolani");
    }

    public override void NextRecord()
    {
      if (current <= customers.Count - 1)
      {
        current++;
      }
    }

    public override void PriorRecord()
    {
      if (current > 0)
      {
        current--;
      }
    }

    public override void NewRecord(string name)
    {
      customers.Add(name);
    }

    public override void DeleteRecord(string name)
    {
      customers.Remove(name);
    }

    public override void ShowRecord()
    {
      Console.WriteLine(customers[current]);
    }

    public override void ShowAllRecords()
    {
      foreach (string name in customers)
      {
        Console.WriteLine(" " + name);
      }
    }
  }
}

Output

Jim Jones
Samual Jackson
Allen Good

------------------------
Customer Group: Chicago
Jim Jones
Samual Jackson
Allen Good
Ann Stills
Lisa Giolani
Henry Velasquez
------------------------