C\#디자인 모델 에서 브리지 모델 에 대한 구체 적 인 활용 을 깊이 분석 하 다.

여기 서 텔레비전 리모컨 의 한 예 를 들 어 브리지 모델 로 해결 하 는 문 제 를 끌 어 낸다.먼저,우리 각 브랜드 의 텔레비전 에는 리모컨 이 있다.이때 우리 가 생각 할 수 있 는 디자인 은 리모컨 을 추상 적 인 유형 으로 하고 추상 적 인 유형 에서 리모컨 을 제공 하 는 것 이 실현 되 며 다른 구체 적 인 텔레비전 브랜드 의 리모컨 은 모두 이 추상 적 인 유형 을 계승 하 는 것 이다.구체 적 인 디자인 유형 도 는 다음 과 같다.

이러한 실현 으로 인해 모든 유형의 텔레비전 은 자신의 리모컨 을 가지 게 되 었 다.이런 디자인 은 텔레비전의 변화 에 잘 대응 할 수 있 고 파생 류 만 추가 하면 된다.그러나 시간 이 지 날수 록 사용 자 는 리모컨 의 기능 을 바 꿔 야 한다.예 를 들 어 사용자 가 나중에 리모컨 에 이전 데스크 로 돌아 가 는 등 기능 을 추가 해 야 할 때이때 위의 디자인 은 추상 류 Remote Control 이 제공 하 는 인 터 페 이 스 를 수정 해 야 한다.이때 추상 류 에 하나의 방법 만 추가 하면 해결 할 수 있다.그러나 이런 문 제 는 우리 가 추상 적 인 실현 을 바 꾸 었 다 는 것 이다.만약 에 사용자 가 전기 기기 의 모델 과 리모컨 기능 을 동시에 바 꾸 려 면 위의 디자인 은 상당 한 수정 을 초래 할 것 이다.분명히 이런 디자인 은 결코 좋 은 디자인 이 아니다.그러나 브리지 모델 을 사용 하면 이 문 제 를 잘 해결 할 수 있다.다음은 브리지 모델 이 어떻게 실현 되 는 지 구체 적 으로 보 자.
정의.
브리지 모델 은 추상 적 인 부분 과 실현 부분의 결합 을 통 해 독립 적 으로 변화 할 수 있 도록 할 것 이다.위의 문제 에서 추상 화 는 바로 RemoteControl 류 이 고 실현 부분 은 On(),Off(),NextChannel()등 과 같은 방법(즉 리모컨 의 실현)이다.위의 디자인 에서 추상 화 와 실현 부분 이 함께 있 으 면 브리지 모델 의 목적 은 이들 을 분리 시 키 고 대상 을 대상 으로 하 는 패 키 징 변화 원칙 에 따라우 리 는 실현 부분의 변화(즉 리모컨 기능 의 변화)를 다른 유형 에 밀봉 할 수 있다.이런 사고방식 은 바로 브리지 모델 의 실현 이다.여러분 은 브리지 모델 의 실현 코드 를 대조 하여 우리 의 분석 사고방식 을 해결 할 수 있다.
브리지 모드 구현
위의 정의 부분 은 우리 의 브리지 모델 의 목적 과 실현 방향 을 제시 했다.다음은 브리지 모델 이 머리말 부분 디자인 의 부족 을 어떻게 해결 하 는 지 구체 적 으로 보 자.
추상 화 된 부분의 코드:

/// <summary>
  ///          ，       
  /// </summary>
  public class RemoteControl
  {
    //   
    private TV implementor;
    //   
    public TV Implementor
    {
      get { return implementor; }
      set { implementor = value; }
    }
    /// <summary>
    ///     ，             ，           
    /// </summary>
    public virtual void On()
    {
      implementor.On();
    }
    /// <summary>
    ///     
    /// </summary>
    public virtual void Off()
    {
      implementor.Off();
    }
    /// <summary>
    ///    
    /// </summary>
    public virtual void SetChannel()
    {
      implementor.tuneChannel();
    }
  }
  /// <summary>
  ///      
  /// </summary>
  public class ConcreteRemote : RemoteControl
  {
    public override void SetChannel()
    {
      Console.WriteLine("---------------------");
      base.SetChannel();
      Console.WriteLine("---------------------");
    }
  }

리모컨 의 실현 방법 부분 코드,즉 일부 코드 를 실현 하 는 것 이다.이때 우 리 는 다른 추상 적 인 유형의 TV 로 리모컨 기능 의 변 화 를 밀봉 하고 구체 적 인 실현 은 구체 적 인 모델 텔레비전 에 맡 겨 완성 한다.

/// <summary>
  ///    ，      
  /// </summary>
  public abstract class TV
  {
    public abstract void On();
    public abstract void Off();
    public abstract void tuneChannel();
  }
  /// <summary>
  ///       ，         
  ///        
  /// </summary>
  public class ChangHong : TV
  {
    public override void On()
    {
      Console.WriteLine("           ");
    }
    public override void Off()
    {
      Console.WriteLine("           ");
    }
    public override void tuneChannel()
    {
      Console.WriteLine("         ");
    }
  }
  /// <summary>
  ///       ，         
  /// </summary>
  public class Samsung : TV
  {
    public override void On()
    {
      Console.WriteLine("           ");
    }
    public override void Off()
    {
      Console.WriteLine("           ");
    }
    public override void tuneChannel()
    {
      Console.WriteLine("         ");
    }
  }

브리지 모드 를 사용 한 클 라 이언 트 호출 코드:

/// <summary>
  ///                  
  /// </summary>
  class Client
  {
    static void Main(string[] args)
    {
      //        
      RemoteControl remoteControl = new ConcreteRemote();
      //      
      remoteControl.Implementor = new ChangHong();
      remoteControl.On();
      remoteControl.SetChannel();
      remoteControl.Off();
      Console.WriteLine();
      //       
      remoteControl.Implementor = new Samsung();
      remoteControl.On();
      remoteControl.SetChannel();
      remoteControl.Off();
      Console.Read();
    }
  }

위의 브리지 모델 의 실현 에서 리모컨 의 기능 실현 방법 은 리모컨 추상 류 에서 이 루어 지지 않 고 실현 부분 을 다른 텔레비전 류 로 밀봉 하 는 것 이다.그러나 리모컨 에는 텔레비전 류 의 인용 만 포함 되 어 있다.이 동시에 이런 디자인 도 현실 생활 의 상황 에 매우 부합된다.브리지 모델 을 통 해 우 리 는 추상 화 와 실현 화 부분 을 분리 하면 이 두 가지 변화 에 잘 대응 할 수 있다.
다른 인 스 턴 스
예 를 들 어 자주 사용 되 는 자동차 대상 을 살 펴 보 자.
우선 Abstraction 을 정의 합 니 다.

public abstract class Car
  {
    public IEngine _engine;

    public Car(IEngine engine)
    {
      _engine = engine;
    }

    public virtual void Start()
    {
      _engine.Start();
    }

    public virtual void Stop()
    {
      _engine.Stop();
    }
  }

이어서 서로 다른 자동차 유형 을 실현 한다.

public class Bus : Car
  {
    public Bus(IEngine engine)
      : base(engine)
    {
    }

    public override void Start()
    {
      base.Start();
      Console.WriteLine("Bus Start");
    }

    public override void Stop()
    {
      base.Stop();
      Console.WriteLine("Bus Stop");
    }
  }

  public class Limousine : Car
  {
    public Limousine(IEngine engine)
      : base(engine)
    {
    }

    public override void Start()
    {
      base.Start();
      Console.WriteLine("Limousine Start");
    }

    public override void Stop()
    {
      base.Stop();
      Console.WriteLine("Limousine Stop");
    }
  }

두 번 째 변화 차원,즉 엔진 의 인 터 페 이 스 를 정의 한다.

public interface IEngine
   {
     void Start();
     void Stop();
   }

마지막 으로 서로 다른 엔진 을 실현 한다.

public class GasEngine : IEngine
  {
    public void Start()
    {
      Console.WriteLine("Gas Engine Start");
    }

    public void Stop()
    {
      Console.WriteLine("Gas Engine Stop");
    }
  }

  public class DieselEngine : IEngine
  {
    public void Start()
    {
      Console.WriteLine("Diesel Engine Start");
    }

    public void Stop()
    {
      Console.WriteLine("Diesel Engine Stop");
    }
  }