(33) C \ # 디자인 모델 - 브리지 모델 (브리지 패턴)

머리말
텔레비전 리모컨 의 예 를 들 어 브리지 모드 로 해결 하 는 문 제 를 끌어내다.우리 각 브랜드 의 텔레비전 은 모두 리모컨 을 가지 고 있다. 이때 우리 가 생각 할 수 있 는 디자인 은 리모컨 을 추상 적 인 유형 으로 하고 추상 적 인 유형 에서 리모컨 의 모든 실현 을 제공 하 며 다른 구체 적 인 텔레비전 브랜드 의 리모컨 은 모두 이 추상 적 인 유형 을 계승 하 는 것 이다.이러한 실현 으로 인해 모든 모델 의 텔레비전 은 자신의 리모컨 을 가지 게 되 었 다.이러한 디자인 은 텔레비전의 변화 에 잘 대응 할 수 있다. 하나의 파생 류 만 추가 하면 된다. 그러나 시간 이 지 날수 록 사용 자 는 리모컨 의 기능 을 바 꿔 야 한다. 이때 추상 류 가 제공 하 는 인 터 페 이 스 를 수정 해 야 한다. 이때 추상 류 에 하나의 방법 만 추가 하면 해결 할 수 있다.그러나 이렇게 가 져 온 문 제 는 우리 가 추상 적 인 실현 을 바 꾸 었 다 는 것 이다. 만약 에 사용자 가 텔레비전 모델 과 리모컨 기능 을 동시에 바 꿔 야 한다 면 위의 디자인 은 상당 한 수정 을 초래 할 것 이다.브리지 모드 를 사용 하면 이런 문 제 를 해결 할 수 있다.
브리지 모드 에 대한 상세 한 소개
정의.
브리지 모델 은 곧 추상 적 인 부분 과 실현 부분의 결합 을 실현 하여 그것들 을 독립 화 시 킬 것 이다.대상 을 대상 으로 하 는 패 키 징 변화 원칙 에 따라 우 리 는 실현 부분의 변화 (리모콘 기능 의 변화) 를 다른 유형 에 밀봉 할 수 있다. 이런 사고방식 은 바로 브리지 모델 의 실현 이다.
이루어지다

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _24BridgePatternDemo
{
    /// 

    ///    
    /// 
    class Program
    {
        static void Main(string[] args)
        {
            //       
            RemoteControl remotecontrol = new RemoteControl();
            //  
            remotecontrol.Implementor = new Changhong();
            remotecontrol.On();
            remotecontrol.SetChannel();
            remotecontrol.Off();
            Console.WriteLine();
            //  
            remotecontrol.Implementor = new Sanxing();
            remotecontrol.On();
            remotecontrol.SetChannel();
            remotecontrol.Off();

            Console.WriteLine();

            ConcreteRemoter Conremotecontrol = new ConcreteRemoter();
            Conremotecontrol.Implementor = new Changhong();
            Conremotecontrol.On();
            Conremotecontrol.SetChannel();
            Conremotecontrol.Off();

        }
    }
    /// 

    ///          ，       
    /// 
    public class RemoteControl
    {
        private TV implementor;

        public TV Implementor
        {
            get
            {
                return implementor;
            }

            set
            {
                implementor = value;
            }
        }
        /// 

        ///                    ，           
        /// 
        public virtual void On()
        {
            implementor.On();
        }
        public virtual void Off()
        {
            implementor.Off();
        }
        public virtual void SetChannel()
        {
            implementor.SetChannel();
        }
      

    }
    /// 

    ///      
    /// 
    public class ConcreteRemoter : RemoteControl
    {
        public override void SetChannel()
        {
            Console.WriteLine("---------------------");
            base.SetChannel();
            Console.WriteLine("---------------------");
        }
    }

    /// 

    ///    ，      
    /// 
    public abstract class TV
    {
        public abstract void On();
        public abstract void Off();
        public abstract void SetChannel();
    }
    /// 

    ///                         
    /// 
    public class Changhong : TV
    {
        public override void On()
        {
            Console.WriteLine("          ！");
        }

        public override void Off()
        {
            Console.WriteLine("          ！");
        }

        public override void SetChannel()
        {
            Console.WriteLine("        ");
        }
    }
    public class Sanxing : TV
    {
        public override void On()
        {
            Console.WriteLine("          ！");
        }

        public override void Off()
        {
            Console.WriteLine("          ！");
        }

        public override void SetChannel()
        {
            Console.WriteLine("        ");
        }
    }
}

위의 브리지 모델 의 실현 에서 리모컨 의 기능 실현 방법 은 리모컨 추상 류 에서 이 루어 지지 않 고 실현 부분 을 다른 텔레비전 류 로 밀봉 하 는 것 이다. 그러나 리모컨 에는 텔레비전 류 의 인용 만 포함 된다.브리지 모델 을 통 해 우 리 는 추상 화 와 실현 화 부분 을 분리 했다.
브리지 모드 의 장단 점
장점:

추상 적 인 인터페이스 와 결합 해제

여가 와 실현 은 독립 적 으로 확장 할 수 있 고 상대방 에 게 영향 을 주지 않 습 니 다

세부 사항 은 고객 에 게 투명 하고 사용자 에 게 구체 적 인 실현 세부 사항 을 숨 겼 다

단점:
    시스템 의 복잡 도 를 증가 시 켰 다
필드 사용

만약 에 한 시스템 이 구축 한 추상 화 된 역할 과 구체 적 인 역할 사이 에 더 많은 유연성 을 추가 하고 두 차원 에서 정태 적 인 관 계 를 구축 하지 않도록 해 야 한다.

디자인 요구 실현 화 캐릭터 의 어떠한 변화 도 클 라 이언 트 에 영향 을 주지 않 거나 실현 화 캐릭터 의 변 화 는 클 라 이언 트 에 게 완전히 투명 하 다

.

여러 플랫폼 을 뛰 어 넘 는 그래 픽 과 창 시스템

한 가지 유형 은 두 개의 독립 적 인 변화 차원 이 존재 하고 두 차원 모두 확장 해 야 한다

.
실제 응용 브리지 모델 의 예
3 층 구조 에 응 용 된 브리지 모드 에 대해 BLL 층 에서 브리지 모드 를 통 해 DAL 층 과 결합 을 해제 하 는데 그 실현 방식 은 BLL 층 에서 DAL 층 의 인용 을 인용 한 것 이다. 그러면 데이터 작업 의 실현 은 클 라 이언 트 코드 를 바 꾸 지 않 고 동적 으로 바 꿀 수 있다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _25BridgePatternApplyDemo
{
    //   
    class Program
    {
        static void Main(string[] args)
        {
            BusinessObject customers = new BusinessObject("ChengDu");
            customers.Dataaccess = new CustomersDataAccess();

            customers.Add("   ");
            Console.WriteLine("          ：");
            customers.ShowAll();
            customers.Delete("  ");
            Console.WriteLine("          ：");
            customers.ShowAll();
            Console.WriteLine("          ：");
            customers.Update("Learning_Hard");
            customers.ShowAll();
            Console.WriteLine();
        }
    }
    //BLL 
    public class BusinessObject
    {
        private DataAccess dataaccess;
        private string city;
        public BusinessObject(string city)
        {
            this.city = city;
        }

        public DataAccess Dataaccess
        {
            get { return dataaccess; }
            set { dataaccess = value; }
        }

        public virtual void Add(string name)
        {
            Dataaccess.AddRecord(name);
        }
        public virtual void Delete(string name)
        {
            Dataaccess.DeleteRecord(name);
        }

        public virtual void Update(string name)
        {
            Dataaccess.UpdateRecord(name);
        }

        public virtual string Get(int index)
        {
            return Dataaccess.GetRecord(index);
        }
        public virtual void ShowAll()
        {
            Console.WriteLine();
            Console.WriteLine("{0}    ：", city);
            Dataaccess.ShowAllRecords();
        }
    }
    public class CustomersBusinessObject:BusinessObject
    {
        public CustomersBusinessObject(string city):base(city)
        {

        }
        public override void ShowAll()
        {
            Console.WriteLine("------------------");
            base.ShowAll();
            Console.WriteLine("------------------");
        }
    }

    //        DAL
    public abstract class DataAccess
    {
        public abstract void AddRecord(string name);
        public abstract void DeleteRecord(string name);
        public abstract void UpdateRecord(string name);
        public abstract string GetRecord(int index);
        public abstract void ShowAllRecords();
    }
    public class CustomersDataAccess : DataAccess
    {
        private List customers = new List();
        public CustomersDataAccess()
        {
            customers.Add("Learning Hard");
            customers.Add("  ");
            customers.Add("  ");
            customers.Add("  ");
            customers.Add("Bob");
        }
        public override void AddRecord(string name)
        {
            customers.Add(name);
        }

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

        public override string GetRecord(int index)
        {
            return customers[index];
        }

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

        public override void UpdateRecord(string name)
        {
            customers[0] = name;
        }
    }

}