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 = 0;
            WorkerMsg ms;
            WorkerMsgRep mr;
            for (int i = 0; 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[0].ToString("HH:mm:ss:ms");
            string time2 = wb.MentionTime[1].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，一定要听！