解读设计模式

技术是死的，功能是活的。如何实现一个功能有很多种方式，如何快速灵活高效的实现这些功能就是一门艺术了。这其中可能会组合式的用到设计模式，这就是架构。当你会使用设计模式的时候我相信你会爱上它！
一、创建型模式
1、工厂方法模式：使用继承，动态实例化不同的对象执行相同的方法。
2、抽象工厂模式：
3、单例模式：通过static关键字保证系统中一个类只有一个实例
4、建造者模式：
5、原型模式：需要和单例模式对比，类似单例模式，原型模式可以new出不同的对象
二、结构型模式
6、适配器模式：
7、装饰器模式：使用依赖倒置原则，在对象的方法上又封装一层（组合优于继承，组合+继承）。
8、代理模式：
9、外观模式：
10、桥接模式：
11、组合模式：
12、亨元模式：
三、行为型模式
13、策略模式：
14、模板方法模式：
15、观察者模式：使用事件的方式提前把观察者的反应注册到被观察者的事件中，等待被观察者触发
16、迭代子模式：
17、责任链模式：
18、命令模式：
19、备忘录模式：
20、状态模式：
21、访问者模式：
22、中介者模式：
23、解释器模式：

四、设计模式六大原则

1、单一职责原则：增加功能，从方法级别上是增加方法而不是修改方法，从类的级别上是增加类而不是修改类。对扩展开放,对修改关闭，多使用抽象类和接口。（适当使用）
2、里氏替换原则：基类可以被子类替换，使用抽象类继承,不使用具体类继承。
3、依赖倒置原则：要依赖于抽象,不要依赖于具体，针对接口编程,不针对实现编程。
4、接口隔离原则：使用多个隔离的接口,比使用单个接口好，建立最小的接口。
5、迪米特法则：一个软件实体应当尽可能少地与其他实体发生相互作用，通过中间类建立联系。
6、开闭原则：尽量使用合成/聚合,而不是使用继承。

 

单例模式：

    public class SingletonClass
    {
        private static SingletonClass instance = null;
        public static SingletonClass Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new SingletonClass();
                }
                return instance;
            }
        }
       
        private SingletonClass() { }

        public void MyFuntion()
        {
            //do some thing
        }
    }

    //简写方式
    public class SingletonClass2
    {
        public static SingletonClass2 Instance = new SingletonClass2();
        private SingletonClass2() { }
        public void MyFuntion()
        {
            //do some thing
        }
    }

    //调用示例
    public class TestSingletonClass
    {
        public void DoSomeThing()
        {
            SingletonClass.Instance.MyFuntion();
            SingletonClass2.Instance.MyFuntion();
        }
    }

 

装饰器模式： 

    //可扩展任意类型的学生
    public abstract class AbstractStudentBase
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public abstract void StudentDay();//学生的一天
    }
    public class XiaoXueSheng : AbstractStudentBase
    {
        public override void StudentDay()
        {
            Console.WriteLine("小学生一天开始");
        }
    }
    public class DaXueSheng : AbstractStudentBase
    {
        public override void StudentDay()
        {
            Console.WriteLine("大学生一天开始");
        }
    }


    //装饰器，可扩展任意行为（组合+继承）
    public class DecoratorStudentBase : AbstractStudentBase
    {
        private AbstractStudentBase _Student = null;

        public DecoratorStudentBase(AbstractStudentBase student)
        {
            this._Student = student;
        }

        public override void StudentDay()
        {
            //Console.WriteLine("**********************************");
            this._Student.StudentDay();
            //Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
        }
    }

    //学习,可以扩展任意学习任意课程
    public class Study : DecoratorStudentBase
    {
        public Study(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("学习");
        }
    }


    //学生一边学习一边兼职，可以扩展任何兼职，并装饰到任意学生身上
    public class JianZhi : DecoratorStudentBase
    {
        public JianZhi(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("学习完成之后去兼职");
        }
    }
    //比如做家教
    public class JianZhiJiaJiao : JianZhi
    {
        public JianZhiJiaJiao(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("兼职家教");
        }
    }

    //学生一边学习一边玩游戏
    public class PlayGame : DecoratorStudentBase
    {
        public PlayGame(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("开始玩游戏");
        }
    }
    //比如玩王者荣耀、吃鸡，可以扩展任何游戏，并装饰到任意学生身上
    public class PlayGameWangZhe : PlayGame
    {
        public PlayGameWangZhe(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("王者荣耀游戏");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            AbstractStudentBase xiaoXueSheng = new XiaoXueSheng();
            xiaoXueSheng = new Study(xiaoXueSheng);
            xiaoXueSheng.StudentDay();//小学生只知道学习


            AbstractStudentBase daXueSheng = new DaXueSheng();
            daXueSheng = new Study(daXueSheng);
            daXueSheng = new JianZhiJiaJiao(daXueSheng);
            daXueSheng = new PlayGameWangZhe(daXueSheng);
            //继续加...
            daXueSheng.StudentDay();//大学生一边学习，一边做家教，一边玩王者荣耀，可扩展任意行为，比如说交女朋友
        }
    }

 

依赖倒置原则

    public interface ICar
    {
        public void Run();
    }
    public interface IDriver
    {
        public void DriverCar(ICar car);
    }


    public class BM : ICar
    {
        public void Run()
        {
            //do some thing
        }
    }
    public class Driver : IDriver
    {
        public void DriverCar(ICar car)
        {
            car.Run();
        }
    }
    //调用示例
    public class TestDriveCar
    {
        public void SomeOneDriveCar()
        {
            IDriver zhangSan = new Driver();
            ICar BaoMa = new BM();
            zhangSan.DriverCar(BaoMa);
        }
    }

 

观察者模式（两种方式，一种使用面向对象思想把观察者的对象添加到被观察中，一种是使用微软自带的事件添加到被观察的事件中）
最经典的示例：猫叫，老鼠跑，孩子哭，妈妈醒来......

    public class Cat
    {
        private List<Observer> obServerList=new List<Observer>();
        public void Add(Observer obServer)
        {
            obServer.Add(obServer);
        }
        public void Remove(Observer obServer)
        {
            obServer.Remove(obServer);
        }
        public void Miao_Observer()//猫叫
        {
            foreach(Observer obServer in obServerList)
            {
                obServer.ActionFuntion();
            }
        }


        public Action OnCatMiaoHandler;
        public void Miao_Event()//猫叫
        {
            foreach(Action action in OnCatMiaoHandler.GetInvocationList())
            {
                action.Invoke();
            }
        }
    }
    //调用示例
    public class TestCat
    {
        Mouse mouse1=new Mouse();
        Child child1=new Child();
        void Miao_ObserverTest()
        {
            Cat cat =new Cat();
            cat.Add(mouse1);
            cat.Add(child1);

            cat.Miao_Observer();
        }
        void Miao_EventTest()
        {
            Cat cat =new Cat();
            cat.OnCatMiaoHandler+=mouse1.Run;
            cat.OnCatMiaoHandler+=child1.Cry;

            cat.Miao_Event();
        }
    }


     public abstract class Observer
       {
         public abstract void ActionFuntion();
       }
    public class Mouse:Observer
    {
        public void ActionFuntion()
        {
            this.Run();
        }
        public void Run()//老鼠跑
        {

        }
    }
    public class Child:Observer
    {
          public void ActionFuntion()
        {
            this.Cry();
        }
        public void Cry()//孩子哭
        {

        }
    }

游戏中的示例：当玩家攻击了其中之一的敌人时，那个队伍的所有敌人都会注意到玩家，在攻击范围的敌人会掉血，并且开始攻击玩家
参考：http://blog.csdn.net/sinat_20559947/article/details/50046201

 

 

未完待续...