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."); } } }
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。