C#设计模式整理

　　我居然连一月一随笔都没有，啊啊啊，忙死个人

　　这个随笔主要是记录基于自己学习[美]James W.Cooper著的《C# Design Patterns : A Tutorial》一书中常用设计模式的整理，既是自己整理的，便避免不了理解偏差，欢迎分享宝贵见解。

Behavioral Pattern  行为型模式

　　行为型模式模式主要与对象间的通信有关。

　　Chain of Responsibility(职责链模式)，职责链模式减少对象间的耦合。整理了一个接口，如下：

    /// <summary>
    /// 职责链模式
    /// 职责链减少了类之间的耦合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IChain<T>
    {
        /// <summary>
        /// 添加一条链至本链后
        /// </summary>
        /// <param name="nextChain"></param>
        void AddNext(IChain<T> nextChain);
 
        /// <summary>
        /// 消息处理
        /// </summary>
        /// <param name="msg"></param>
        void OnChain(T msg);
    }

适用：

p) 职责链模式允许多个类处理同一个请求，请求在类之间传递，直到其中一个类处理它为止。

p) 不想把相互作用的内容放在调用程序里。

举例：

例2：

最近想关于硬件命令和数据收发时想到了用职责链解决，结果好像出现了偏差，便有了以下代码。以下代码用于统计字符串中JMB三个字母出现的次数以及J出现的次数以及两个B字母间用时(实属瞎JB写)。

以下是相关类定义：

 using System;
 using System.Collections.Generic;
 
 namespace ConcurrencySolution
 {
     #region base classes
     public class Msg
     {
         public string ID
         {
             get { return _id; }
         }
         private string _id;
 
         public Msg()
         {
             _id = Guid.NewGuid().ToString("N");
         }
     }
 
     public class MsgRep
     {
         public string MsgID;
 
         public bool ExecResult;
 
         public MsgRep()
             : this(string.Empty, false)
         { }
 
         public MsgRep(string vMsgID, bool vExecResult)
         {
             MsgID = vMsgID;
             ExecResult = vExecResult;
         }
     }
 
     public abstract class Chain
     {
         public Chain Next
         {
             get { return _next; }
         }
         private Chain _next;
 
         public void SetNext(Chain next)
         {
             _next = next;
         }
 
         public MsgRep HandleMsg(Msg msg)
         {
             MsgRep rep = HandleMessage(msg);
             if (true == rep.ExecResult)
                 return rep;
 
             if (Next != null)
                 return Next.HandleMsg(msg);
 
             return null;
         }
 
         protected abstract MsgRep HandleMessage(Msg msg);
     }
 
     public abstract class Worker : Chain
     {
         public string WorkerID
         {
             get { return _workerID; }
         }
         protected string _workerID;
 
         protected Worker()
             : this(string.Empty)
         { }
 
         protected Worker(string vWorkerID)
         {
             _workerID = vWorkerID;
         }
 
         protected override MsgRep HandleMessage(Msg msg)
         {
             WorkerMsg wmsg = msg as WorkerMsg;
             if (null == wmsg)
                 throw new ArgumentException("isn't a valid WorkerMsg", "msg");
 
             var rep = DoWork(wmsg);
             return rep;
         }
 
         protected abstract WorkerMsgRep DoWork(WorkerMsg msg);
     }
     #endregion
 
     public class WorkerMsg : Msg
     {
         public string Action
         {
             get { return _action; }
         }
         private string _action;
 
         public WorkerMsg(string vAction)
             : base()
         {
             _action = vAction;
         }
     }
 
     public class WorkerMsgRep : MsgRep
     {
         public string WorkerID;
 
         public WorkerMsgRep()
             : this(string.Empty, false, string.Empty)
         { }
 
         public WorkerMsgRep(string vMsgID, bool vExecResult, string vWorkerID)
             : base(vMsgID, vExecResult)
         {
             WorkerID = vWorkerID;
         }
     }
 
     #region Workers
     public class WorkerJ : Worker
     {
         public int MentionTimes
         {
             get { return _mentionTimes; }
         }
         protected int _mentionTimes;
 
         protected WorkerJ()
             : base()
         { }
 
         public WorkerJ(string vWorkerID)
             : base(vWorkerID)
         { }
 
         protected override WorkerMsgRep DoWork(WorkerMsg msg)
         {
             WorkerMsgRep rep = new WorkerMsgRep(msg.ID, false, WorkerID);
             rep.ExecResult = msg.Action == "J";
             if (true == rep.ExecResult)
                 _mentionTimes++;
 
             return rep;
         }
 
         public virtual void ChangeWorkerID(string vWorkerID)
         {
             throw new NotImplementedException();
         }
     }
 
     public class WorkerM : Worker
     {
         public WorkerM(string vWorkerID)
             : base(vWorkerID)
         { }
 
         protected override WorkerMsgRep DoWork(WorkerMsg msg)
         {
             var rep = new WorkerMsgRep(msg.ID, false, WorkerID);
             if (msg.Action == "M")
                 rep.ExecResult = true;
 
             return rep;
         }
     }
 
     public class WorkerB : Worker
     {
         public List<DateTime> MentionTime
         {
             get { return _mentionTime; }
         }
         List<DateTime> _mentionTime;
 
         public WorkerB(string vWorkerID)
             : base(vWorkerID)
         {
             _mentionTime = new List<DateTime>();
         }
 
         protected override WorkerMsgRep DoWork(WorkerMsg msg)
         {
             WorkerMsgRep rep = new WorkerMsgRep(msg.ID, false, WorkerID);
             rep.ExecResult = msg.Action == "B";
             if (true == rep.ExecResult)
                 _mentionTime.Add(DateTime.Now);
 
             return rep;
         }
 
     }
     #endregion
 }

以下是使用：

        public void TestMethod1()
        {
            string testStr = "Bb1123lkiJMoBp";
            WorkerJ wj = new WorkerJ("j");
            WorkerM wm = new WorkerM("m");
            WorkerB wb = new WorkerB("B");
            wj.SetNext(wm);
            wm.SetNext(wb);
 
            int countJMB = ;
            WorkerMsg ms;
            WorkerMsgRep mr;
            for (int i = ; i < testStr.Length; i++)
            {
                ms = new WorkerMsg(testStr[i].ToString());
                mr = wj.HandleMsg(ms) as WorkerMsgRep;
                if (mr != null &&
                    true == mr.ExecResult)
                    countJMB++;
            }
 
            string time1 = wb.MentionTime[].ToString("HH:mm:ss:ms");
            string time2 = wb.MentionTime[].ToString("HH:mm:ss:ms");
            ;
        }

例1：

    public class Sunday : IChain<DayOfWeek>  // System.DayOfWeek
    {
        private IChain<DayOfWeek> _next;
 
        private DayOfWeek _token;
        public DayOfWeek Token { get { return _token; } }
 
        public Sunday()
        {
            _token = DayOfWeek.Sunday;
        }
 
        #region  IChain<DayOfWeek> 成员
        void IChain<DayOfWeek>.AddNext(IChain<DayOfWeek> nextChain)
        {
            _next = nextChain;
        }
 
        void IChain<DayOfWeek>.OnChain(DayOfWeek msg)
        {
            if (DayOfWeek.Sunday == msg)  // 此处判断本类是否最适合处理此消息
            {
                Console.WriteLine("Hello! It's {0}, u'd better study!", _token);
            }
            else if (_next != null)  // 传递消息
            {
                _next.OnChain(msg);
            }
            else
            {
                throw new Exception(string.Format("{0} can't handle this msg : {1}", _token, msg));
            }
        }
        #endregion
 
    }
 
    public class DefaultDay : IChain<DayOfWeek>
    {
        private DayOfWeek _token;
        public DayOfWeek Token { get { return _token; } }
 
        public DefaultDay()
        {
            //_token = DayOfWeek.None;   好烦啊，想偷个懒的，意思到就好了8
        }
 
        #region  IChain<DayOfWeek> 成员
        void IChain<DayOfWeek>.AddNext(IChain<DayOfWeek> nextChain)
        {
            throw new NotImplementedException(string.Format("Sorry but i'm at the end of the chain, {0} said.", _token));
        }
 
        void IChain<DayOfWeek>.OnChain(DayOfWeek msg)
        {
            //if (msg != _token)
            //{
            //    throw new Exception(string.Format("It's none of my business about : {0}, {1} said", msg, _token));
            //}
            //else
            //{
                Console.WriteLine("Unbelievable! Today is {0}!", _token);
            //}
 
        }
        #endregion
 
    }
 
    public class ChainImpl
    {
        IChain<DayOfWeek> _prior, _inferior, _default;
 
        public ChainImpl()
        {
            _prior = new Sunday();
            //_inferior = new Monday();
            _default = new DefaultDay();
 
            //_prior.AddNext(_inferior);
            //_inferior.AddNext(_default);
            _prior.AddNext(_default);
        }
 
        public void Work(DayOfWeek today)
        {
            // 不管今天具体是周几，由_prior对象优先去处理
            // 如果_prior对象不能处理，自动转交给它的"下一链"处理直到_default
            _prior.OnChain(today);
        }
    }

　　Strategy Pattern(策略模式)。

适用：

p) 不同算法各自封装，可随意挑选需要的算法。

实现：

方式一，把策略封装在单独的类中。策略决策类和策略类间的耦合较低（当更换策略时，策略决策类与原策略类解耦）；可提供异步获取结果的方法；

方式二，把策略作为一个委托（根据自己理解实现的，自荐）。性能（反射）可能较低；策略决策类与策略（委托，当为其他类中的方法时）所属类间的耦合较高；策略相对轻量级、灵活方便；对于同个问题的策略，可封装在单独类中，结构清晰；

举例：

方式二，具体实现。

using System;
 
    public class StrategyDecision
    {
        protected Delegate _strategy;
 
        public StrategyDecision()
        { }
 
        public StrategyDecision(Delegate strategy)
        {
            _strategy = strategy;
        }
 
        ~StrategyDecision()
        {
            _strategy = null;
        }
 
        public object GetResult(params object[] args)
        {
            try
            {
                return _strategy.DynamicInvoke(args);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
 
        public void ChangeStrategy(Delegate strategy)
        {
            _strategy = strategy;
        }
 
    }

方式二，使用举例。

var obj = new StrategyDecision(
                            new Func<int, int, int>(
                                (oa, ob) =>
                                {
                                    return oa + ob;
 
                                })).GetResult(7, 7);  // Bad example! 图简便 >_<

Creational Pattern 创建型模式

　　所有创建型模式都涉及到创建对象实例的方式。将创建对象过程抽象成一个专门的“创建器”类，会使程序更灵活、更通用。

　　Singleton Pattern(单例模式)，单例模式限制而不是改进类的创建，单例模式保证一个类有且只有一个实例，并提供一个访问它的全局访问点。如果有需要，也可以在类中保存少数几个实例。我常用单例的全局访问功能；在你只持有一个资源，而需要对外开放多个资源访问服务时，用单例是很好的选择。

举例：

    public class Myself
    {
        static readonly Myself _instance;
        public static Myself Instance
        {
            get { return _instance; }
        }
 
        // 应用程序域中第一次发生以下事件时将触发静态构造函数的执行：
        //•    创建类类型的实例。(外部无法创建本类实例)
        //•    引用类类型的任何静态成员。(当Instance属性被引用时)
        static Myself()
        {
            _instance = new Myself();
        }
 
        private Myself()  // 私有构造限制外部创建实例
        { }
    }

备注：

此单例的实现是我根据静态构造的特性实现的，以下称前者；书中的单例用lock方式实现，以下称后者。我用循环1000次调用某单例的两种实现的方法(简单返回字符串)：第一次调用前者用时0毫秒，后者用时2毫秒，也就是说后者用时是在第一次调用(也就是构造函数花费的)时出现的，以后每次调用二者都是0毫秒；值得一提的点，每个1000次调用中，后者总会至少有一次返回空，也就是调用失败或者啥，但前者不会有这种情况，也就是说前者较为安全。有时间我把测试也贴出来。

　　Linkin Park 的《Halfway Right》好听哭了T_T，一定要听！