设计模式

1.简单工厂模式与工厂模式

简单工厂模式举例代码：

 public abstract class Light
    {
        public abstract void TurnOn();
        public abstract void TurnOff();
    }
    public class BulbLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("BulbLight is turned on");
            //throw new NotImplementedException();
        }
        public override void TurnOff()
        {
            Console.WriteLine("BulbLight is turned off");
            //throw new NotImplementedException();
        }
    }
    public class TubeLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("TubeLight is turned on");
            //throw new NotImplementedException();
        }
        public override void TurnOff()
        {
            Console.WriteLine("TubeLight is turned off");
            //throw new NotImplementedException();
        }
    }
    public class LightSimpleFactory //负责生产对象的一个类
    {
        public Light Create(string lightType)
        {
            if (lightType == "Bulb")
                return new BulbLight();
            else if (lightType == "Tube")
                return new TubeLight();
            else
                return null;
        }
    }

    
    class Program
    {
        static void Main(string[] args)
        {
            LightSimpleFactory lsf = new LightSimpleFactory();
            Light l = lsf.Create("Bulb");
            l.TurnOn();
            l.TurnOff();
            Console.WriteLine("-------");
            l = lsf.Create("Tube");
            l.TurnOn();
            l.TurnOff();
            Console.ReadKey();
         }
    }

工厂方法模式举例代码：

public abstract class Light
    {
        public abstract void TurnOn();
        public abstract void TurnOff();
    }
    public class BulbLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("BulbLight is turned on");
            //throw new NotImplementedException();
        }
        public override void TurnOff()
        {
            Console.WriteLine("BulbLight is turned off");
            //throw new NotImplementedException();
        }
    }
    public class TubeLight : Light
    {
        public override void TurnOn()
        {
            Console.WriteLine("TubeLight is turned on");
            //throw new NotImplementedException();
        }
        public override void TurnOff()
        {
            Console.WriteLine("TubeLight is turned off");
            //throw new NotImplementedException();
        }
    }

    public abstract class Creator
    {
        public abstract Light factory();
    }
    public class BulbCreator : Creator
    {
        public override Light factory()
        {
            return new BulbLight();
            //throw new NotImplementedException();
        }
    }
    public class TubeCreator : Creator
    {
        public override Light factory()
        {
            return new TubeLight();
            //throw new NotImplementedException();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //LightSimpleFactory lsf = new LightSimpleFactory();
            Creator c1 = new BulbCreator();
            Creator c2 = new TubeCreator();

            Light L1 = c1.factory();
            Light L2 = c2.factory();

            L1.TurnOn();
            L1.TurnOff();

            Console.WriteLine("----");

            L2.TurnOn();
            L2.TurnOff();
            Console.ReadKey();
         }
    }

  由上面两个例子可以看出：

  工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类（如上述的BulbCreato类r和TubeCreator类），而简单工厂模式把核心放在具体类上(如代码中的LightSimpleFactory类)。

 工厂方法模式之所以有一个别名叫多态性工厂模式，是因为居停工厂类都有共同的接口，或者有共同的抽象父类。当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好地符合了“开放-封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。（工厂方法模式退化后可以演变成简单工厂模式。）

补充：开放-封闭原则的思想：

软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。

因此，开放封闭原则主要体现在两个方面：

对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改

2.原型模式

 原型模式是通过给出一个原型对象来指明所要创建的对象类型，然后用复制这个原型对象的方法创建出更多的同类型对象。

 在C#里面，我们可以很容易地通过Clone()方法实现原型模式。任何类，只要想支持克隆，必须实现C#中的ICloneable接口。ICloneable接口中有一个Clone方法，可以在类中复写实现自定义的克隆方法。克隆的实现方法有两种：浅拷贝和深拷贝（这个概念你懂的）。

举例:

 public class ShallowCopy : ICloneable
    {
        public int[] v = { 1, 2, 3 };
        public Object Clone()
        {
            return this.MemberwiseClone();
        }
        public void Display()
        {
            foreach (int i in v)
            {
                Console.Write(i + ",");
                Console.WriteLine();
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ShallowCopy sc1 = new ShallowCopy();
            ShallowCopy sc2 = (ShallowCopy)sc1.Clone();
            sc1.v[0] = 9;

            sc1.Display();
            sc2.Display();
            Console.ReadKey();
         }
    }

 ShallowCopy对象实现了一个浅拷贝，因此当对SC1进行克隆时，其字段V并没有克隆，这导致SC1和SC2的字段v都指向了同一个v。因此，当修改了SC1的v[0]后,SC2的v[0]也发生了变化。

深拷贝的例子：

public class DeepCopy : ICloneable
    {
        public int[] v = { 1, 2, 3 };
        public DeepCopy()//默认构造函数
        {
        }
        //供Clone方法调用的私有构造函数
        private DeepCopy(int[] v)
        {
            this.v = (int[])v.Clone();
        }
        public Object Clone()
        {
            //构造一个新的DeepCopy对象，构造参数为原有对象中使用的V
            return new DeepCopy(this.v);
        }
        public void Display()
        {
            foreach (int i in v)
            {
                Console.Write(i + ",");
                Console.WriteLine();
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DeepCopy sc1 = new DeepCopy();
            DeepCopy sc2 = (DeepCopy)sc1.Clone();
            sc1.v[0] = 9;

            sc1.Display();
            sc2.Display();
            Console.ReadKey();
         }
    }

由结果可以看出，这次在克隆的时候，不但克隆对象本身，连里面的数组字段一并克隆了。因此，最终打印出来的结果不同。

3.观察者模式

 在这种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来做事件处理系统。

  public class Subject
    {
        private ArrayList observers;
        //构造函数
        public Subject()
        {
           observers=new ArrayList();
        }

        public void Register(IObserver observer)
        {
           if(!observers.Contains(observer))
           {
               observers.Add(observer);
           }
        }

        public void Deregister(IObserver observer)
        {
            if (observers.Contains(observer))
            {
                observers.Remove(observer);
            }
        }

        public void Notify(string message)
        {
            foreach (IObserver observer in observers)
            {
                observer.Update(message);
            }
        }
    }
    public interface IObserver
    {
        void Update(string message);
    }
    public class Observer1 : IObserver
    {
        public void Update(string message)
        {
            Console.WriteLine("Observer1:"+message);
        }
    }
    public class Observer2 : IObserver
    {
        public void Update(string message)
        {
            Console.WriteLine("Observer2:" + message);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Subject mySubject = new Subject();
            IObserver myObserver1 = new Observer1();
            IObserver myObserver2 = new Observer2();

            mySubject.Register(myObserver1);
            mySubject.Register(myObserver2);

            mySubject.Notify("hello");
            //mySubject.Notify("message2");
            Console.ReadKey();
         }
    }

 4.单例模式

 单例模式的特点有三：

 1）.单例类只能由一个实例。

 2）.单例类必须自己创建自己的唯一实例

 3）.单例类必须给所有其他对象提供这一实例

 class Singleton
    {
        private static Singleton instance;
        private Singleton() { }
        //共有静态方法
        public static Singleton Instance()
        {
            if (instance == null)
                instance = new Singleton();
            return instance;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.Instance();
            Singleton s2 = Singleton.Instance();
            if (s1 == s2)
            {
                Console.WriteLine("The same instance");
            }
            Console.ReadKey();
         }
    }