设计模式

工厂方法与简单工厂

1. 简单工厂，最大优点是工厂类中包含了必要的逻辑判断，对于客户端来说，去除了与具体产品的依赖；但是，一旦要新增产品，就必须修改工厂类的判断逻辑，这明显违背的开放-封闭原则（对扩展开放，对修改封闭）
2. 工厂方法，则定义了一个创建对象的接口，让子类决定实例化哪一个类。新增产品时，只需要新增子类即可；但是，需要修改客户端。
3. 工厂方法+反射，可以很好的解决工厂方法在需求变动时，需要改动客户端代码的缺陷。

深拷贝与浅拷贝

1. 浅拷贝，只拷贝引用
2. 深拷贝，会重新实例化引用中的内容

模板方法

1. 过程一致，但是实现有差异，可以使用模板方法
2. 把不变的行为搬到超类，把差异放到子类，来去除子类中的重复代码

单实例

• 线程安全
• 惰性实例化
• 避免反复枷锁

 public sealed class Singleton
 {
     static Singleton instance = null;
     private static readonly object padlock = new object();

     private Singleton()
     {
     }

     public static Singleton Instance
     {
         get
         {
             if (instance == null)
             {
                 lock (padlock)
                 {
                     if (instance == null)
                     {
                         instance = new Singleton();
                     }
                 }
             }
             return instance;
         }
     }
 }

观察者

采用.NET事件机制和通用方法实现的观察者模式
NewMailEventArgs.cs（Subject/Observer之间的传递参数）

    public class NewMailEventArgs : EventArgs
    {
        public NewMailEventArgs(string from, string to, string subject)
        {
            From = from;
            To = to;
            Subject = subject;
        }

        public string From { get; set; }
        public string To { get; set; }
        public string Subject { get; set; }
    }

MailManager_Event.cs (基于.NET事件机制实现的Subject/Observer)

	//Subject
    public class MailManager_Event
    {
        public event EventHandler<NewMailEventArgs> NewMail;
        
        public void OnNewMail(NewMailEventArgs e)
        {
            EventHandler<NewMailEventArgs> temp = NewMail;
            if (temp != null)
            {
                temp(this, e);
            }
        }

        public void SimulateNewMail(String from, String to, String sub)
        {
            NewMailEventArgs e = new NewMailEventArgs(from, to, sub);

            OnNewMail(e);
        }

        public void add(EventHandler<NewMailEventArgs> handler)
        {
            //实现往集合中添加元素，C#因为事件机制已经将其做好
            this.NewMail += handler;
        }

        public void remove(EventHandler<NewMailEventArgs> handler)
        {
            this.NewMail -= handler;
        }
    }
	
	// Observer1
    class Computer
    {
        public void RunCompute(object sender, NewMailEventArgs e)
        {
            Console.WriteLine("Computer received messages: from {0} to {1} subject {2}", e.From, e.To, e.Subject);
        }
    }

	// Observer2
    class Watch
    {
        public void RunWatch(object sender, NewMailEventArgs e)
        {
            Console.WriteLine("Watch received messages: from {0} to {1} subject {2}", e.From, e.To, e.Subject);
        }
    }

MailManager_General.cs（基于通用方法实现的Subject/Observer）

	public class MailManager_General
    {
        public List<IObservor> observerList;

        public MailManager_General()
        {
            observerList = new List<IObservor>();
        }

        public void OnNewMail(NewMailEventArgs e)
        {
            foreach (var item in observerList)
            {
                item.NotifyHandler(this, e);
            }
        }

        public void SimulateNewMail(String from, String to, String sub)
        {
            NewMailEventArgs e = new NewMailEventArgs(from, to, sub);

            OnNewMail(e);
        }

        public void add(IObservor observer)
        {
            //...非C#代码，没有事件机制，应该这样处理：
            observerList.Add(observer);
        }

        public void remove(IObservor observer)
        {
            //...非C#代码，没有事件机制，应该这样处理：
            observerList.Remove(observer);
        }
    }


    public interface IObservor
    {
        void NotifyHandler(object sender, NewMailEventArgs e);
    }

    public class Cellphone : IObservor
    {

        public void NotifyHandler(object sender, NewMailEventArgs e)
        {
            Console.WriteLine("Phone received messages: from {0} to {1} subject {2}", e.From, e.To, e.Subject);
        }

    }

    public class Fax : IObservor
    {
        public void NotifyHandler(object sender, NewMailEventArgs e)
        {
            Console.WriteLine("Fax received messages: from {0} to {1} subject {2}", e.From, e.To, e.Subject);
        }
    }

Program.cs (客户端程序)

	class Program
    {
        static void Main(string[] args)
        {
            //======================================
            //C#事件机制: 
            //1. 观察者无需都继承自同一个基类，
            //2. 因此观察者处理通知的执行函数名称就可以自定义
            //主体（消息发布者）
            var mgr = new MailManager_Event();

            //观察者（消息订阅者）
            Computer computer = new Computer();
            Watch watch = new Watch();

            //客户端自行决定添加或移除
            mgr.NewMail += computer.RunCompute;
            mgr.NewMail += watch.RunWatch;

            //发布消息
            mgr.SimulateNewMail("wangyahua", "liqiuhua", "play");

            //======================================
            //非C#，无事件机制的处理：
            //1. 观察者必须继承自同一个基类
            //2. 因此导致通知执行函数名称只能在抽象观察者接口中定义好，而无法由使用者自定义
            var mgr_g = new MailManager_General();
            Cellphone phone = new Cellphone();
            Fax fax = new Fax();
            mgr_g.add(phone);
            mgr_g.add(fax);

            //发布消息
            mgr_g.SimulateNewMail("wangyahua", "liqiuhua", "eat");

            Console.ReadKey();
        }
    }