MyException - 我的异常网
当前位置:我的异常网» 设计模式 » C# 设计模式·举动型模式

C# 设计模式·举动型模式

www.MyException.Cn  网友分享于:2013-08-09  浏览:0次
C# 设计模式·行为型模式


这里列举行为型模式·到此23种就列完了···这里是看着菜鸟教程来实现··,他里边列了25种,其中过滤器模式和空对象模式应该不属于所谓的23种模式
责任链模式:为请求创建一个接收者对象的链,对请求的发送者和接收者进行解耦,大部分用于web中吧。。
Task中的continuewith和微软的tpl数据流应该是类似这种模式的实现吧

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//责任链模式
namespace ExercisePrj.Dsignmode
{
    public abstract class AbstractLogger
    {
        public static int INFO = 1;
        public static int DEBUG = 2;
        public static int ERROR = 3;
        protected int level;
        //责任链中的下一个对象
        protected AbstractLogger nextLogger;
        public void SetNextLogger(AbstractLogger next)
        {
            nextLogger = next;
        }
        public void LogMessage(int level,string message)
        {
            if(this.level<=level)
            {
                Write(message);
            }
            if(nextLogger!=null)
            {
                nextLogger.LogMessage(level, message);
            }
        }
        protected abstract void Write(string message);
    }
    public class ConsoleLogger : AbstractLogger
    {

       public ConsoleLogger(int level)
        {
            this.level = level;
        }

       protected  override void Write(string message)
        {
            Console.WriteLine("Standard Console::Logger: " + message);
        }
    }
    public class ErrorLogger : AbstractLogger
    {

       public ErrorLogger(int level)
        {
            this.level = level;
        }

       protected override void Write(String message)
        {
            Console.WriteLine("Error Console::Logger: " + message);
        }
    }
    public class FileLogger : AbstractLogger
    {
       public FileLogger(int level)
        {
            this.level = level;
        }

       protected override void Write(String message)
        {
            Console.WriteLine("File::Logger: " + message);
        }
    }
}

命令模式(Command Pattern):请求以命令的形式执行,CAD的的命令应该就是以这种方式执行的·二次开发的时候通过特性标识和继承他的接口来添加命令,非常方便

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//命令模式
namespace ExercisePrj.Dsignmode
{
    public interface IOrder
    {
        void Execute();
    }
    public class Stock
    {
        private string name = "ABC";
        private int quantity = 10;

        public void Buy()
        {
            Console.WriteLine("Stock name:{0},quantity:{1},bought",name,quantity);
        }
        public void Sell()
        {
            Console.WriteLine("Stock name:{0},quantity:{1}sold", name, quantity);
        }
    }
    //请求类
    public class BuyStock : IOrder
    {
       private Stock abcStock;

        public BuyStock(Stock abcStock)
        {
            this.abcStock = abcStock;
        }

        public void Execute()
        {
            abcStock.Buy();
        }
    }
    //继承接口的实体
    public class SellStock : IOrder
    {
       private Stock abcStock;

        public SellStock(Stock abcStock)
        {
            this.abcStock = abcStock;
        }

        public void Execute()
        {
            abcStock.Sell();
        }
    }

    //命令调用类
    public class Broker
    {
        private List<IOrder> orderList = new List<IOrder>();

        public void takeOrder(IOrder order)
        {
            orderList.Add(order);
        }

        public void placeOrders()
        {
            foreach (IOrder order in orderList)
            {
                order.Execute();
            }
            orderList.Clear();
        }
    }

}

解释器模式:就是实现一种表达式接口,C#的各种表达式就是这种实现吧··这玩意跟富文本编辑器一样是个大坑吧··,做好了确实很好使,一不小心就得跪

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//解释器模式
namespace ExercisePrj.Dsignmode
{
    public interface Expression
    {
         bool Interpret(string context);
    }
    public class TerminalExpression : Expression
    {
       private string data;

        public TerminalExpression(string data)
        {
            this.data = data;
        }

       public  bool Interpret(string context)
        {
            if (context.Contains(data))
            {
                return true;
            }
            return false;
        }
    }
    public class OrExpression : Expression
    {
        private Expression expr1 = null;
        private Expression expr2 = null;
        public OrExpression(Expression expr1, Expression expr2)
        {
            this.expr1 = expr1;
            this.expr2 = expr2;
        }
        public bool Interpret(String context)
        {
            return expr1.Interpret(context) || expr2.Interpret(context);
        }
    }
    public class AndExpression : Expression
    {
        private Expression expr1 = null;
        private Expression expr2 = null;

        public AndExpression(Expression expr1, Expression expr2)
        {
            this.expr1 = expr1;
            this.expr2 = expr2;
        }
        public bool Interpret(String context)
        {
            return expr1.Interpret(context) && expr2.Interpret(context);
        }
        }
}


迭代器模式(Iterator Pattern):.NET自带接口···,直接实现就行了··注意又泛型接口和非泛型接口··非泛型接口迭代对象返回的是object,泛型接口返回的直接就是对象了,还有通过yield的简化写法不用额外去实现IEnumerator接口

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    public class IteratorEx : IEnumerable //<IteratorEx>
    {
        public string Name;
        private List<IteratorEx> list = new List<IteratorEx>();

        //public IEnumerator<IteratorEx> GetEnumerator()
        //{
        //    foreach (var l in list)
        //    {
        //        yield return l;
        //    }
        //}

        public void SetList(List<IteratorEx> data)
        {
            list = data;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            foreach (var l in list)
            {
                yield return l;
            }
            //return new IteratorExEnum(list.ToArray());
        }
    }
    public class IteratorExEnum : IEnumerator
    {
        private IteratorEx[] list;
        private int position = -1;
        public IteratorExEnum(IteratorEx[] data)
        {
            list = data;
        }
        public object Current
        {
            get
            {
                try
                {
                    return list[position];
                }
                catch (IndexOutOfRangeException)
                {
                    throw new InvalidOperationException();
                }
            }
        }

        public bool MoveNext()
        {
            position++;
            return position < list.Length;
        }

        public void Reset()
        {
            position = -1;
        }
    }

}

 
中介者模式(Mediator Pattern):用一个中介对象封装一些对象的交互,中介者使对象不用显式的互相引用,MVC和mvp 的c和p都是类似这玩意的实现吧

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    //中介类
    public class ChatRoom
    {
        public static void ShowMessage(User user, string msg)
        {
            Console.WriteLine(new DateTime().ToString()+"["+ user.Name + "] : " + msg);
        }
    }
    public class User
    {
        public string Name { get; set; }

        public User(string name)
        {
            Name = name;
        }

        public void SendMessage(String message)
        {
            ChatRoom.ShowMessage(this, message);
        }
    }


}

备忘录模式(Memento Pattern):在不破坏封装的前提下,捕获一个对象的内部状态,并在对象之外保存,

大部分支持回退的操作场景下应该都是这种模式··之前做的软件中有画图的操作···支持后退,实现方式非常简单粗暴··,直接吧图层的画图对象克隆一份保存··只支持5还是10步,讲道理这么实现确实有点那啥了···

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    public class Memento
    {
        public string State { get; }
        public Memento(string state)
        {
            State = state;
        }
    }
    public class Originator
    {
        public string State { get; set; }

        public Memento SaveStateToMemento()
        {
            return new Memento(State);
        }

        public void GetStateFromMemento(Memento Memento)
        {
            State = Memento.State;
        }
    }
    public class CareTaker
    {
        private List<Memento> mementoList = new List<Memento>();

        public void Add(Memento state)
        {
            mementoList.Add(state);
        }

        public Memento Get(int index)
        {
            return mementoList[index];
        }
    }

}

观察者模式(Observer Pattern):.net自带的有接口提供来实现观察者模式···这里照着msdn来实现一遍,自带的接口里边还实现了资源的释放··,之前并发编程里边的rx也是这个模式的具体实现·

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

//观察者模式
namespace ExercisePrj.Dsignmode
{

    public class Subject: IObservable<Subject>
    {
        public int State {get; set;}
        public Subject(int state)
        {
            State = state;
        }
        private List<IObserver<Subject>> observers = new List<IObserver<Subject>>();

        public IDisposable Subscribe(IObserver<Subject> observer)
        {
            if (!observers.Contains(observer))
                observers.Add(observer);
            return new Unsubscriber(observers, observer);
        }
        private class Unsubscriber : IDisposable
        {
            private List<IObserver<Subject>> _observers;
            private IObserver<Subject> _observer;

            public Unsubscriber(List<IObserver<Subject>> observers, IObserver<Subject> observer)
            {
                this._observers = observers;
                this._observer = observer;
            }

            public void Dispose()
            {
                if (_observer != null && _observers.Contains(_observer))
                    _observers.Remove(_observer);
            }
        }

        public void TrackLocation(Subject ob)
        {
            Console.WriteLine("start");
            foreach (var observer in observers)
            {
                if (ob==null)
                    observer.OnError(new Exception("unknowExeption"));
                else
                    observer.OnNext(ob);
            }
        }

        public void EndTransmission()
        {
            foreach (var observer in observers.ToArray())
                if (observers.Contains(observer))
                    observer.OnCompleted();

            observers.Clear();
        }

    }


    public class BinaryObserver : IObserver<Subject>
    {
        public void OnCompleted()
        {
            Console.WriteLine("complete");
        }

        public void OnError(Exception error)
        {
            Console.WriteLine(error.Message);
        }

        public void OnNext(Subject value)
        {
            Console.WriteLine("Binary String: " + Convert.ToString(value.State, 2));
        }
    }
    public class OctalObserver : IObserver<Subject>
    {
        public void OnCompleted()
        {
            Console.WriteLine("complete");
        }

        public void OnError(Exception error)
        {
            Console.WriteLine(error.Message);
        }

        public void OnNext(Subject value)
        {
            Console.WriteLine("Octal String: " + Convert.ToString(value.State, 8));
        }

    }
    public class HexaObserver : IObserver<Subject>
    {
        public void OnCompleted()
        {
            Console.WriteLine("complete");
        }

        public void OnError(Exception error)
        {
            Console.WriteLine(error.Message);
        }

        public void OnNext(Subject value)
        {
            Console.WriteLine("Hex String: " + Convert.ToString(value.State,16));
        }
    }
}


状态模式(State Pattern):当对象内部状态发生改变时,行为也跟着改变

这个模式是为了解决类里边的大量if和swicth语句,讲道理例子写的有点怪···主体是context

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    public class Context
    {
        public State State { get; set; }

        public Context()
        {
            State = null;
        }
    }
    public interface State
    {
         void DoAction(Context context);
    }

    public class StartState : State
    {
       public void DoAction(Context context)
        {
            Console.WriteLine("Player is in start state");
            context.State = this;
        }

        public override string ToString()
        {
            return "Start State";
        }
    }
    public class StopState : State
    {

       public void DoAction(Context context)
        {
            Console.WriteLine("Player is in stop state");
            context.State = this;
        }

        public override string  ToString()
        {
            return "Stop State";
        }
    }
}

空对象模式(Null Object Pattern):就是吧对空值的判断定义一个啥也不做的实体对象出来··C#的Nullable就是这个的实现···这玩意不在23种设计模式里边···

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    public abstract class AbstractCustomer
    {
        public abstract bool IsNull();
        public abstract string Name { get; }
    }
    public class RealCustomer : AbstractCustomer
    {
        public override string Name { get; }

        public RealCustomer(string name)
        {
            Name = name;
        }
        public override bool IsNull()
        {
            return false;
        }
    }
    public class NullCustomer : AbstractCustomer
    {
            public override string Name { get { return "Not Available in Customer Database"; } }
            public override bool IsNull()
            {
                return true;
            }
    }
    public class CustomerFactory
    {
        public static  string[] names = {"Rob", "Joe", "Julie"};
         public static AbstractCustomer getCustomer(string name)
        {
            if(names.Contains(name))
            {
                return new RealCustomer(name);
            }
            return new NullCustomer();
        }
    }
}

策略模式(Strategy Pattern):定义一系列算法,封装成类,可以相互替换,通过构造不同的类,执行不同的操作。这样做方便调用,添加新的算法也方便,

最后加了自己之前对这个模式的奇葩写法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    public interface IStrategy
    {
         int DoOperation(int num1, int num2);
    }
    public class OperationAdd : IStrategy
    {
        
       public int DoOperation(int num1, int num2)
        {
            return num1 + num2;
        }
    }

    public class OperationSubstract : IStrategy
    {

        public int DoOperation(int num1, int num2)
        {
            return num1 - num2;
        }
    }
    public class OperationMultiply : IStrategy
    {

        public int DoOperation(int num1, int num2)
        {
             return num1 * num2;
        }
    }

    public class ContextEx
    {
        private IStrategy strategy;

        public ContextEx(IStrategy strategy)
        {
            this.strategy = strategy;
        }

        public int ExecuteStrategy(int num1, int num2)
        {
            return strategy.DoOperation(num1, num2);
        }

        //奇葩的写法简单粗暴
        private Dictionary<string, Func<int, int, int>> funcs = new Dictionary<string, Func<int, int, int>>();
        public int ExecuteStrategy(string name, int num1, int num2)
        {
            if(funcs.Count==0)
            {
                //反射写法
                var assembly = Assembly.GetExecutingAssembly();
                var types = assembly.GetTypes();
                foreach (var t in types)
                {
                    if (t.GetInterface("IStrategy") != null)
                    {
                        var instance = assembly.CreateInstance(t.FullName) as IStrategy;
                        funcs.Add(t.Name, instance.DoOperation);
                    }
                }
                //直接添加
                //funcs.Add("OperationAdd", new Func<int, int, int>((n1, n2) => { return n1 + n2; }));
                //funcs.Add("OperationSubstract", new Func<int, int, int>((n1, n2) => { return n1 - n2; }));
                //funcs.Add("OperationMultiply", new Func<int, int, int>((n1, n2) => { return n1 * n2; }));
            }
            return funcs[name](num1, num2);
        }


    }
}

模板模式(Template Pattern):.net的泛型就是这个模式的实现吧··照着模子写就行了

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{
    public abstract class Game
    {
       public  abstract void Initialize();
        public  abstract void StartPlay();
        public abstract void EndPlay();

        //模板
        public void play()
        {

            //初始化游戏
            Initialize();
            //开始游戏
            StartPlay();
            //结束游戏
            EndPlay();
        }
    }
    public class Cricket : Game
    {
        public override void EndPlay()
        {
            Console.WriteLine("Cricket Game Finished!");
        }

        public override void Initialize()
        {
            Console.WriteLine("Cricket Game Initialized! Start playing.");
        }


        public override void StartPlay()
        {
            Console.WriteLine("Cricket Game Started. Enjoy the game!");
        }
    }
}

访问者模式(Visitor Pattern):在被访问的类里边加一个对外提供接待访问的接口
 吧数据结构和对应的操作分开·添加操作很容易,但是如果结构变化多的化,改起来就麻烦了··
 没研究没用过····

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExercisePrj.Dsignmode
{

    public interface IComputerPartVisitor
    {
        void Visit(Computer computer);
        void Visit(Mouse mouse);
        void Visit(Keyboard keyboard);
        void Visit(Monitor monitor);
    }

    public interface IComputerPart
    {
        void Accept(IComputerPartVisitor computerPartVisitor);
    }

    public class Keyboard  : IComputerPart
    {

       public void Accept(IComputerPartVisitor computerPartVisitor)
        {
            computerPartVisitor.Visit(this);
        }
    }
    public class Monitor  : IComputerPart
    {

       public void Accept(IComputerPartVisitor computerPartVisitor)
        {
            computerPartVisitor.Visit(this);
        }
}
    public class Mouse  : IComputerPart
    {
       public void Accept(IComputerPartVisitor computerPartVisitor)
        {
            computerPartVisitor.Visit(this);
        }
    }
    public class Computer : IComputerPart
    {
        IComputerPart [] parts;
        public Computer()
        {
            parts = new IComputerPart[] { new Mouse(), new Keyboard(), new Monitor() };
        }
        public void Accept(IComputerPartVisitor computerPartVisitor)
        {
            for (int i = 0; i < parts.Length; i++)
            {
                parts[i].Accept(computerPartVisitor);
            }
            computerPartVisitor.Visit(this);
        }
    }

    public class ComputerPartDisplayVisitor : IComputerPartVisitor
    {
        public void Visit(Computer computer)
        {
            Console.WriteLine("Displaying Computer.");
        }
        public void Visit(Mouse mouse)
        {
            Console.WriteLine("Displaying Mouse.");
        }
        public void Visit(Keyboard keyboard)
        {
            Console.WriteLine("Displaying Keyboard.");
        }
        public void Visit(Monitor monitor)
        {
            Console.WriteLine("Displaying Monitor.");
        }
    }
}

 

文章评论

Java程序员必看电影
Java程序员必看电影
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
10个调试和排错的小建议
10个调试和排错的小建议
旅行,写作,编程
旅行,写作,编程
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
那些性感的让人尖叫的程序员
那些性感的让人尖叫的程序员
为什么程序员都是夜猫子
为什么程序员都是夜猫子
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
漫画:程序员的工作
漫画:程序员的工作
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
每天工作4小时的程序员
每天工作4小时的程序员
代码女神横空出世
代码女神横空出世
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
编程语言是女人
编程语言是女人
总结2014中国互联网十大段子
总结2014中国互联网十大段子
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
中美印日四国程序员比较
中美印日四国程序员比较
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
老程序员的下场
老程序员的下场
聊聊HTTPS和SSL/TLS协议
聊聊HTTPS和SSL/TLS协议
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
程序员都该阅读的书
程序员都该阅读的书
 程序员的样子
程序员的样子
程序员应该关注的一些事儿
程序员应该关注的一些事儿
鲜为人知的编程真相
鲜为人知的编程真相
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
程序员的鄙视链
程序员的鄙视链
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
那些争议最大的编程观点
那些争议最大的编程观点
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
程序员必看的十大电影
程序员必看的十大电影
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
Google伦敦新总部 犹如星级庄园
Google伦敦新总部 犹如星级庄园
我的丈夫是个程序员
我的丈夫是个程序员
程序员和编码员之间的区别
程序员和编码员之间的区别
一个程序员的时间管理
一个程序员的时间管理
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有