桥接模式

 

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

namespace ConsoleApplication2
{


    abstract class implementor
    {
        public abstract void nextrecord();
        public abstract void priorrecord();
        public abstract void newrecord(string content);
        public abstract void deleterecord(string content);
        public abstract void showrecord();
        public abstract void showalllrecords();
    }


    class concereimplementa : implementor
    {
        private ArrayList customers = new ArrayList();
        private int current = 0;
        public concereimplementa()
        {
            customers.Add("long1");
            customers.Add("long2");
            customers.Add("long3");
        }
        public override void nextrecord()
        {
            if (current < customers.Count - 1)
            {
                current++;
            }
        }
        public override void priorrecord()
        {
            if (current > 0)
            {
                current--;
            }
        }
        public override void newrecord(string content)
        {
            customers.Add(content);
        }
        public override void deleterecord(string content)
        {
            customers.Remove(content);
        }
        public override void showrecord()
        {
            Console.WriteLine(customers[current]);
        }
        public override void showalllrecords()
        {
            Console.WriteLine("all customers list :");
            foreach (string content in customers)
            {
                Console.WriteLine(content);

            }
        }
    }
    class abstaction
    {
        private implementor im;
        private string group;
        public abstaction(string group)
        {
            this.group = group;
        }
        public implementor Im
        {
            set { im = value; }
            get { return im; }
        }
        public virtual void nextrecord()
        {
            im.nextrecord();
        }
        public virtual void priorrecord()
        {
            im.priorrecord();
        }
        public virtual void newrecord(string content)
        {
            im.newrecord(content);
        }
        public virtual void deleterecord(string content)
        {
            im.deleterecord(content);
        }
        public virtual void showrecord()
        {
            im.showrecord();
        }
        public virtual void showallrecord()
        {
            im.showalllrecords();
        }
    }


    class refineabstraction:abstaction
    {
        public refineabstraction(string group):base(group)
        {

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

    /*
     * 将抽象部分与它的实现部分分离，使他们都可以独立地变化
     * 
     * 
     * 适用性
     * 你不希望在抽象和它的实现部分之间有一个固定的绑定关系，例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或切换
     * 类的抽象可以它的实现都应该尅通过子类的方法加以扩充。这时bridge模式使你以对不同的抽象接口和实现部分进行组合，并分别对他们进行扩充
     * 对一个抽象的实现部分的修改应该对客户不产生影响，即客户的代码不必重新编译
     * 
     
     
     */

}

 

            //bridge

            abstaction ab = new refineabstraction("group1");
            implementor im = new concereimplementa();
            ab.Im = im;
            ab.showallrecord();
            ab.newrecord("dalongnew");
            ab.deleterecord("long1");
            ab.showrecord();
            ab.showallrecord();