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);
    }

 

Specify：

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

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

Apply：

    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);
        }
    }

View Code

Creational Pattern 创建型模式

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

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

Apply：

    public class Myself
    {
        static readonly Myself _instance;
        public static Myself Instance
        {
            get { return _instance; }
        }

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

        private Myself()  // 私有构造限制外部创建实例
        { }
    }

 

转载于:https://www.cnblogs.com/xuanhu/p/10459407.html