生成器模式: 封装一个产品的构造过程, 并允许按步骤构造.
现又一个度假计划指定, 需要指定度假每一天的活动, 旅馆, 用餐, 门票等等事情, 但是每个客人的度假计划可能不太一样. 例如天数, 活动类型, 用餐等等.
我们需要一个弹性的数据结构, 代表客人的规划, 以及不同的变化, 也需要一系列潜在复杂顺序, 创建这样的规划. 如何提供一种方式来创建复杂的结构, 也不会和创建它的步骤混在一起. 迭代器的过程就是封装进一个独立的对象中, 向客户隐藏集合的内部表现. 这里我们也采用同样的思路: 我们将旅游规划的创建过程, 封装到一个对象中 (此对象称为生成器), 然后让客户调用生成器为它创建旅游规划.
设计类图:
实现代码:
1存储数据结构类
- public class Vacation
- {
- public int Day { get; set; }
- public string Hotel { get; set; }
- public string Park { get; set; }
- public string Activity { get; set; }
- public string Meal { get; set; }
- }
2抽象生成器
- public abstract class AbstractBuilder
- {
- public abstract void BuildDay(int day);
- public abstract void Hotel(string hotel);
- public abstract void Park(string park);
- public abstract void Activity(string activity);
- public abstract void Meal(string meal);
- public abstract Vacation GetVacationPlanner();
- }
3具体生成器, 具体生成器可以多个实现.
- public class VacationBuilder : AbstractBuilder
- {
- private Vacation vacation=new Vacation();
- public override void BuildDay(int day)
- {
- vacation.Day = day;
- }
- public override void Hotel(string hotel)
- {
- vacation.Hotel = hotel;
- }
- public override void Activity(string activity)
- {
- vacation.Activity = activity;
- }
- public override void Meal(string meal)
- {
- vacation.Meal = meal;
- }
- public override void Park(string park)
- {
- vacation.Park = park;
- }
- public override Vacation GetVacationPlanner()
- {
- return vacation;
- }
- }
4客户使用生成器
优点:
1, 将复杂对象创建过程封装起来.
2, 允许对象通过多个步骤来创建, 并且可以改变过程.
3, 向客户隐藏产品内部表现.
4, 产品的实现可以被替换, 因为客户只看到一个抽象的接口.
用途与缺点:
1, 经常用来创建组合结构.
2, 与工厂模式相比, 采用生成器创建对象的客户需要更多的领域知识, 才能正确的创建对象.
责任链
责任链模式: 让一个以上的对象有机会能够处理某个请求的时候, 就使用责任链模式.
有这样一个场景, 公司专门接受邮件处理的人员需要将每天接收到的邮件进行处理, 一类是需要转给部门经理处理的邮件, 一类是给自己处理的, 还有一类垃圾邮件直接删除. 如果这样的一个场景, 我们就可以通过责任链模式, 为处理创建一个对象链. 每个对象依序检查邮件请求, 并进行处理, 或者将它传递给链中的下一个对象.
设计类图:
实现代码:
1责任链抽象类
- /// <summary>
- /// 邮件类型
- /// </summary>
- public enum EmailType
- {
- Self=1,
- Manager=2,
- Del=3
- }
- public abstract class Handler
- {
- public Handler nextHandler;
- public EmailType type;
- public Handler(EmailType type) {
- this.type = type;
- }
- public void SetNextHandler(Handler nextHandler)
- {
- this.nextHandler = nextHandler;
- }
- public abstract void HandleRequest(EmailType requsetType);
- }
2责任链处理类
- /// <summary>
- /// 自己处理
- /// </summary>
- class SelfHandler : Handler
- {
- public SelfHandler() : base(EmailType.Self)
- {
- }
- public override void HandleRequest(EmailType requsetType)
- {
- if (EmailType.Self == requsetType)
- {
- Console.WriteLine("邮件由自己处理");
- }
- else
- {
- if (nextHandler != null)
- {
- nextHandler.HandleRequest(requsetType);
- }
- }
- }
- }
- /// <summary>
- /// 转发经理
- /// </summary>
- class ManagerHandler : Handler
- {
- public ManagerHandler() : base(EmailType.Manager)
- {
- }
- public override void HandleRequest(EmailType requsetType)
- {
- if (EmailType.Manager == requsetType)
- {
- Console.WriteLine("邮件转到经理处理");
- }
- else
- {
- if (nextHandler != null)
- {
- nextHandler.HandleRequest(requsetType);
- }
- }
- }
- }
- /// <summary>
- /// 删除垃圾邮件
- /// </summary>
- class DelHandler : Handler
- {
- public DelHandler() : base(EmailType.Del)
- {
- }
- public override void HandleRequest(EmailType requsetType)
- {
- if (EmailType.Del == requsetType)
- {
- Console.WriteLine("垃圾邮件已删除");
- }
- else
- {
- if (nextHandler != null)
- {
- nextHandler.HandleRequest(requsetType);
- }
- }
- }
- }
3测试责任链
- class Program
- {
- static void Main(string[] args)
- {
- // 组装责任链
- Handler handler = new SelfHandler();
- Handler handler1 = new ManagerHandler();
- Handler handler2 = new DelHandler();
- handler.SetNextHandler(handler1);
- handler1.SetNextHandler(handler2);
- // 测试
- handler.HandleRequest(EmailType.Del);
- handler.HandleRequest(EmailType.Manager);
- handler.HandleRequest(EmailType.Self);
- Console.ReadKey();
- }
- }
优点:
1, 请求的发送者和接收者解耦.
2, 简化对象, 因为不需要知道链的结构.
3, 通过改变链内的成员或调动他们的次序, 允许你动态地新增或者删除责任.
用途和缺点:
1, 经常被用在窗口系统中, 处理鼠标和键盘之类的事件.
2, 并不保证请求一定被执行, 如果没有任何对象处理它, 可能会落到链尾端之外.
3, 不容易观察允许特征, 不好排查问题.
来源: https://www.cnblogs.com/SunSpring/p/12479694.html