jiangdmdr

大话设计模式读书笔记

程杰

着重从c#代码角度分析
学习心得: 学设计模式，不需要是否能立刻理解和记忆，无需着力
- 首先是UML图
  - 再从设计模式到UML图
  - 从UML图到代码
- 其次知道各种模式的应用场景即可
- 第三寻找到各种模式的经典应用实例
设计模式心得
第29章 OOTV杯超级模式大赛–模式总结

Preface

src code
菜鸟教程 C#

关于本书学习的疑问解答

作者谈了自己对design patterns学习理解，可供参考

Ref
- GoF
- Java与模式，阎宏

第1章代码无错就是优？——简单工厂模式

C#
- solution(方案)可包括多个project(项目)

1.8 业务的封装

业务逻辑与界面逻辑相分离

1.10 简单工厂模式

为了简化程序，计算器程序采用 c# 多个button 对应同一消息处理方法

//各个button共用同一个事件处理函数
button1.click = new System.EventHandler(button_Click); 
button2.click = new System.EventHandler(button_Click); 
button3.click = new System.EventHandler(button_Click); 
...

private void button_Click(objet sender ,EventArgs e)
{
    Button btn =(Button)sender ; //实例化按钮，从而获取当前单击按钮的值 
    this.txtvalue.Text = btn.Text; //窗体中有txtvalue控件并给它赋值
}

简单工厂模式
- factory类:
- abstract product:
- concrete product

1.11 UML类图

类图: class
接口: interface

interface IFly
{
    void Fly();
}

继承
- 类继承
- 接口继承

//类继承
class Bird : Animal
{}

//接口继承
class WideGoose : IFly
{}

组合
- 关联 association
- 聚合 aggregation
- 合成 composition

//关联
class Penguin : Bird
{
    private Climate climate;``
}`

//聚合
class WideGooseAggregate
{
    private WideGoose[] arrayWideGoose;
}

//合成
class Bird
{
    private Wing wing;

    public Bird(){
        wing = new Wing();
    }       
}

依赖

//依赖
abstract class Animal
{
    public Metabolism(Oxygen oxygen, Water water){}
}

对比UML图，理解代码；或反之

工厂模式: 实例化具有共同父类的不同对象
- 应用: EJB,RMI,CORBA
- 可根据不同条件产生不同实例
  - switch-case 或反射
- 要素
  - 工厂: 虚拟构造器
分类
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式

简单工厂模式的结构

工厂方法模式

深入浅出UML类图: 有价值，理解UML作用

第2章商场促销——策略模式

2.1 商场收银软件

//初始化 Combox
cbxType.Items.AddRange(new object[] {"正常收费","打八折","打七折","打五折"});

2.2 增加打折

2.3 简单工厂实现

2.4 策略模式

strategy pattern: 定义算法族
- 封装变化点
- vs. 简单工厂
  - 策略选择权在客户端
  - 工厂模式相当于黑盒子，策略模式相当于白盒子
- 工厂模式：有一天你决定去吃披萨，一看菜单，哦，种类很多呀，就点了个培根披萨，过了二十分钟，你的披萨就来了就可以吃到了。但这个披萨是怎么做的，到底面粉放了多少，培根放了多少，佐料放了多少，有多少到工序，你是不需要管的，你需要的是一个美味培根披萨。
- 策略模式：同样还是在披萨店，你要一个培根披萨，老板说想吃自己去做吧。原料有培根、面粉、佐料。工序有1、2、3工序，你自己去做吧。然后你就需要自己去做，到底放多少培根，放多少面粉，放多少佐料，这都你自己来决定，工序1、2、3，你是怎么实现的，都你自己决定。最后你得到了披萨。

Strategy 类和Context类为aggregate关系，即Strategy将作为构造函数的参数传递给`Context类

//抽象算法类
abstract class Strategy
{
    //算法方法
    public abstract void algorithmInterface();
}

//上下文
class Context
{
    Strategy strategy;

    public Context(Strategy strategyIn) {}      
}

2.5 策略模式实现

2.6 策略与简单工厂结合

Context类控制 -> switch-case选择,即具体策略的选择也交予Context类处理
策略模式Context

public CashContext(CashSuper csuper)
{
        this.cs = csuper;
}

策略+简单工厂

class CashContext
{
    CashSuper cs = null;

    //根据条件返回相应的对象
    public CashContext(string type)
    {
        switch (type)
        {
            case "正常收费":
                CashNormal cs0 = new CashNormal();
                cs = cs0;
                break;
            ...
        }
    }

反射
- 依赖注入（Dependency Injection）
- 不管工厂模式，还是策略模式，switch-case依然去不掉。原因在哪里?

Assembly.Load("程序集名称").CreateInstance("名称空间.类名称")

2.7 策略模式解析

反射(reflect)

第3章拍摄UFO–单一职责原则

3.1 新手机

3.2 拍摄

3.3 没用的东西

3.4 单一职责原则

单一职责原则（SRP：Single responsibility principle）

案例

六大原则之SRP笔记

3.5 方块游戏的设计

3.6 手机职责过多吗？

第4章考研求职两不误–开放-封闭原则

4.1 考研失败

4.2 开放-封闭原则

4.3 何时应对变化

抽象 -> 隔离 -> 变化

4.4 两手准备，并全力以赴

第5章会修电脑不会修收音机？–依赖倒转原则

5.1 MM请求修电脑

5.2 电话遥控修电脑

5.3 依赖倒转原则

error: 高层模块依赖于低层模块
- solution: 抽象 -> 接口

5.4 里氏代换原则

子类型可替换性

依赖倒转 IOC

5.5 修收音机

第6章穿什么有这么重要？–装饰模式

6.1 穿什么有这么重要？

6.2 小菜扮靓第一版

6.3 小菜扮靓第二版

aim: 所需功能按照正确顺序串联执行，

有点像pipeline?

GOF: 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

6.4 装饰模式

Component class

abstract class Component{
    public abstract void Operation();
}

ConcreteComponentclass

class ConcreteComponent : Component{
    public override void Operation(){
        Console.WriteLine("具体对象操作");
    }
}

Decorator class

abstract class Decorator : Component{
    protected Component component;

    public void setComponent(Component component) {
            this.component = component; //设置Component
    }
    //
    public override void Operation(){
        if(component != NULL){ component.Operation();}
    }
}

ConcreteDecoratorA class

class ConcreteDecoratorA : Decorator {
    private string addState;

    public override void Operation(){
        base.Operation();
        ...
    }       
}

ConcreteDecoratorB class
Client code

static void Main(stringp[] args){
    ConcreteComponent c = new ConcreteComponent();
    ConcreteDecoratorA d1 = new ConcreteDecoratorA();
    ConcreteDecoratorB d2 = new ConcreteDecoratorB();

    //Pipeline?
    d1.setComponent(c);
    d2.setComponent(d1);
    d2.Operation();
}

我认为客户端代码就是 pipeline

6.5 小菜扮靓第三版

6.6 装饰模式总结

装饰模式的装饰顺序重要！

Example: 加密数据和过滤词汇是数据处理模块的装饰功能，若先加密再过滤，则不妥！

装饰模式 vs. 桥接模式
??
vs. 责任链模式
- 责任链: 表示上下级审批权限
- 装饰: pipeline
实际应用: Java IO 流是典型的装饰模式

第7章为别人做嫁衣–代理模式

7.1 为别人做嫁衣！

7.2 没有代理的代码

结构图

//追求者类
class Pursuit
{
    SchoolGirl mm;

    public Pursuit(SchoolGirl mm) {this.mm = mm; }

    public void GiveDolls() {}
    public void GiveFlows() {}
    public void GiveChocolate() {}  
}

//被追求者类
class SchoolGirl 
{
    private string name;

    public string Name
    {
        get {return name; }
        set {name = value; }
    }
}

//客户端调用代码
static void Main(string[] args)
{
    SchoolGirl mm = new SchoolGirl();
    mm.name = "妹妹";

    Pursuit zhuojiayi = new Pursuit(mm);

    zhuojiayi.GiveDolls();
    ...
}

7.3 只有代理的代码

结构图

7.4 符合实际的代码

//代理接口
interface IGiveGift {   
    public void GiveDolls();
    public void GiveFlows();
    public void GiveChocolate();
}

//追求者类
class Pursuit : IGiveGift
{
    SchoolGirl mm;
    public Pursuit(SchoolGirl mm) {this.mm = mm; }

    public void GiveDolls() {}
    public void GiveFlows() {}
    public void GiveChocolate() {}
}

//代理类
class Proxy : IGiveGift
{
    private Pursuit gg;  //被代理者

    public Proxy(SchoolGirl mm) {gg = new Pursuit(mm); }

    public void GiveDolls() { gg.GiveDolls(); }
    public void GiveFlows() { gg.GiveFlows(); }
    public void GiveChocolate() { gg.GiveChocolate(); } 
}

//客户端
static void Main(String[] args)
{
    SchoolGirl jiaojiao = new SchoolGirl();

    //代理
    Proxy daili = new Proxy(jiaojiao);

    daili.GiveDolls();
    ...
}

7.5 代理模式

代理模式原理及实例讲解

代理模式角色分为 4 种：

主题接口：定义代理类和真实主题的公共对外方法，也是代理类代理真实主题的方法；
真实主题：真正实现业务逻辑的类；
代理类：用来代理和封装真实主题；
Main：客户端，使用代理类和主题接口完成一些工作。

Subject类: 定义RealSubject和Proxy的公用接口

abstract class Subject
{
    public abstract void Request();
}

RealSubject类: 定义Proxy所代表的真正实体

class RealSubject : Subject
{
    public override void Request(){}
}

Proxy类:

class Proxy : Subject
{
    RealSubject real;
    public override void Request(){
        if(real == NULL) real = new RealSubject();
    }
}

客户端代码

static void Main(string[] args)
{
    Proxy proxy = new Proxy(); //代理
    proxy.Request();
}

7.6 代理模式应用

远程代理
虚拟代理
安全代理

7.7 秀才让小六代其求婚

第8章雷锋依然在人间–工厂方法模式

8.1 再现活雷锋

8.2 简单工厂模式实现

class OperationFactory{
    public static Operation createOperate(String operate){
        Operation oper = NULL;

        switch(operate){
        case "+": 
            oper = new OperationAdd();
            break;
        case "-": 
            oper = new OperationSub();
            break;
        case "*": 
            oper = new OperationMul();
            break;
        case "/": 
            oper = new OperationDiv();
            break;  
        }

        return oper;
    }
}

客户端

Operation oper;
oper = OperarionFactory.createOperate("+");
oper.NumberA=1;
oper.NumberB=2;
double result = oper.GetResult();

8.3 工厂方法模式实现

工厂接口

interface IFactory{
    Operator CreateOperation();
}

具体工厂类

//加法工厂
Class AddFactory : IFactory{
    public Operation CreateOperation{
        return new OperationAdd();
    }
}
...
//除法工厂
Class DivFactory : IFactory{
    public Operation CreateOperation{
        return new OperationDiv();
    }
}

客户端

IFactory operFactory = new AddFactory();
Operation oper = operFactory.CreateOperation();
Operation oper;
oper = OperarionFactory.createOperate("+");
oper.NumberA=1;
oper.NumberB=2;
double result = oper.GetResult();

8.4 简单工厂vs.工厂方法

工厂方法模式:
- 创建对象的接口，让子类去决定具体实例化的对象，把简单的内部逻辑判断移到了客户端代码。(延迟实例化)
- 只需修改客户端即可: Open-Close Principle

8.5 雷锋工厂

反射

第9章简历复印–原型模式

9.1 夸张的简历

9.2 简历代码初步实现

传值 vs 传引用
clone

9.3 原型模式

原型类

abstract class Prototype{
    private string id;
    public Prototype(string id) {this.id = id;}
    public string Id {
        get {return id;}
    }
    //抽象类的关键
    public abstract Prototype Clone();
}`

具体原型类

class ConcretePrototype : Prototype{
    pulic ConcretePrototype(string id) : base(id) {}

    public override Prototype Clone(){
        //创建当前对象的浅表副本
        return (Prototype) this.MemberwiseClone();
    }
}

客户端

MemberWiseClone: 浅clone方法，通过创建一个新对象，并把所有当前对象中非静态域复制到新对象中，从而创建一个浅拷贝。对于值类型的域，进行的是按位拷贝。对于引用类型的域，引用会被赋值而引用的对象则不会。因此，原始对象及其克隆都会引用同一个对象。注意，这种方法对派生类都是有效的，也就是说，你只需在基类中定义一次Clone方法。

static void Main(string[] args){
    ConcretePrototype p1 = new ConcretePrototype("I");
    ConcretePrototype c1.p1.Clone();
    ...
}

Clone 分浅拷贝和深拷贝
- 两者区别：当有引用类型成员时，浅拷贝复制的是成员的引用，深拷贝复制的是成员对象。
ICloneable接口

9.4 简历的原型实现

简历类

class Resume : ICloneable{
    public Object Clone(){
        return (Object) this.MemberwiseClone();
    }
}

9.5 浅复制与深复制

- MemberwiseClone: 复制时，对于类中的值类型会创建新的变量，而对于引用变量来说，会指向原来的引用并不创建新的引用变量

9.6 简历的深复制实现

//也实现ICloneable接口
class WorkExperience : ICloneable {
    public Object Clone(){
        return (Object) this.MemberwiseClone();
    }
}

简历类

class Resume : IClonealbe{
    ...
    private Resume(WorkExprience work){
    this.work = (WorkExprience) work.Clone();
    }

    ...
    public Object Clone(){
        Resume obj = new Resume(this.work);
    }
}

9.7 复制简历vs.手写求职信

第10章考题抄错会做也白搭–模板方法模式

10.1 选择题不会做，蒙呗！

10.2 重复=易错+难改

继承 -> template
- 虚方法 virtual

10.3 提炼代码

10.4 模板方法模式

抽象类AbstractClass

abstract class AbstractClass{
    public abstract void PrimitiveOperation1();
    public abstract void PrimitiveOperation2();

    public void templateMethod(){
        PrimitiveOperation1();
        PrimitiveOperation1();
        Console.WriteLine("");
    }
}

ConcreteClass

class ConcreteClassA : AbstractClass{
    public override void PrimitiveOperation1(){
        Console.WriteLine("具体A类方法 1 实现");
    }
    public abstract void PrimitiveOperation2(){
        Console.WriteLine("具体A类方法 2 实现");
    }
}

10.5 模板方法模式特点

10.6 主观题，看你怎么蒙

对比C#模板
C#设计模式总结

第11章无熟人难办事？–迪米特法则

11.1 第一天上班

11.2 无熟人难办事

方法: 通过引入一个合理的第三者来降低现有对象之间的耦合度

11.3 迪米特法则

迪米特法则（Law of Demeter）: 又叫作最少知识原则（Least Knowledge Principle, LKP），就是说一个对象应当对其他对象有尽可能少的了解,不和陌生人说话。英文简写为: LoD.
talk only to your immediate friends

设计模式的门面模式（Facade）和中介模式（Mediator），都是迪米特法则应用的例子

第12章牛市股票还会亏钱？–外观模式

12.1 牛市股票还会亏钱？

12.2 股民炒股代码

12.3 投资基金代码

12.4 外观模式

12.5 何时使用外观模式

分层设计
- 业务层与数据访问层解耦合
- 增加 Facade 以提供一个简单接口

Facade相当于增加一个接口层，向client提供简洁API接口，同时屏蔽低层复杂的遗留代码

第13章好菜每回味不同–建造者模式

13.1 炒面没放盐

essence
- 抽象流程不变
- 流程中各组件的具体实现细节则是经常变化

example

建筑流程是确定，往往建筑一座楼房包括下面步骤：（1）打桩，建立基础（2）建立框架等。建造者模式的本质和建造楼房是一致的：即流程不变，但每个流程实现的具体细节则是经常变化。
建造者模式的好处就是保证流程不会变化，流程即不会增加、也不会遗漏或者产生流程次序错误，这是非常重要的。
- check list 实现么？

13.2 建造小人一

复杂对象的组装与创建——建造者模式

13.3 建造小人二

13.4 建造者模式

13.5 建造者模式解析

Director: 控制流程
Builder: 抽象服务
ConcreteBuilder: 具体服务
Product: 产品

13.6 建造者模式基本代码

Product: 产品类，由多个部件组成

class Product {
    IList<string> parts = new IList<string>();

    //添加产品部件
    public void Add(string part) {
        parts.Add(part);
    }
}

Builder: 抽象建造者类，确定产品组成： PartA与PartB，并返回结果。

abstract class Builder{
    public abstract void BuilderPartA();
    public abstract void BuilderPartB();
    public abstract Product GetResult();
}

注意: Builder只生产，不规定流程次序；而Dirctor强调规定流程次序

ConcreteBuilder:
注意: ConcreteBuilder与Product为关联关系

class ConcreteBuilder1 : Builder {
    private Product product = new Product();
    public override void BuildPartA() {}
    ...     
}

Director: 指挥者类，规定流程次序！

class Director{
    public void Construct(Builder builder) {
        //生产次序，important
        builder.BuildPartA();
        builder.BuildPartB();
    }
}

客户端

static void Main(string[] args){
    Director director = new Director();
    Builder b1 = new ConcreteBuilder1();

    director.Constructor(b1);
    Product p1 = b1.GetResult();
    ...
}

第14章老板回来，我不知道–观察者模式

14.1 老板回来？我不知道！

14.2 双向耦合的代码

观察者模式

前台秘书类

class Secretary
{
    //同事列表
    private IList investors = new List;
    //添加成员
    public void Attach(Investor invest) { investors.Add(invest); }

    //发送通知
    public void Notify()
    { foreach( Investor i in investors ) i.Update(); }

    //前台状态
    public string SecretaryAction {
        get { return action; }
        set { action = value; }
    }
}

看股票同事类

class Investor {
    private string name;
    private Secretary sub;

    public Investor(string name, Secretary sub){...}
    public Update() {}
}

客户端代码

static void Main(string[] args){    
    Secretary mm = new Secretary(); //前台小姐mm
    //看股票的同事
    Investor one = new Investor("One",mm);
    Investor two = new Investor("Two",mm);

    //前台记录下两个待通知的同事
    mm.Attach(one);
    mm.Attach(two);

    mm.Notify(); //通知同事
}

14.3 解耦实践一

增加抽象的观察者

abstract class Observer {
    protected string name;
    protected Secretary sub;

    public Observer(string name, Secretary sub) {}
}

增加两个具体观察者

//看股票
class StockObserver : Observer {
    public StockObserver(string name, Secretary sub) : base(name,sub) {}
    public override void Update() {}
}

//看NBA
class NBAObserver : Observer {
    public NBAObserver(string name, Secretary sub) : base(name,sub) {}
    public override void Update() {}
}

前台秘书类

class Secretary {
    //同事列表
    private IList observers = new List();
    private string action;

    //增加 -> 针对抽象接口编程
    public void Attach(Observer observer) { observer.Add(observer); }
    //减少
    public void Detach(Observer observer) { observer.Remove(observer); }
    //通知
    public void Notify() {
        foreach(Observer o in observers)
            o.Update();
    }
    //前台状态
    public string SecretaryAction {
        get { return action; }
        set { action = value; }
    }   
}

14.4 解耦实践二

增加抽象通知者接口

interface Subject {
    void Attach(Observer observer);
    void Detach(Observer observer);
    void Notify();
    string SubjectState {
        get;
        set;
    }   
}

具体通知者: 老板(boss) 或秘书

class Boss : Subject {
    //同事列表
    private IList observers = new List();
    private string action;
    ...
}

抽象观察者

abstract class Observer {
    protected string name;
    protected Subject sub;
    //原来“前台” -> 现改为"抽象通知者"
    public Observer(string name, Subject sub) {...}
}

客户端代码

//老板
Boss dog = new Boss();

//看股票的同事
StockObserver one = new StockObserver("one",dog);
//看NBA的同事
StockObserver two = new StockObserver("two",dog);

dog.Attach(one);
dog.Attach(two);

dog.Detach(one);

dog.SubjectState = "Boss来了";
dog.Notify();   //发送通知

结构图

14.5 观察者模式

观察者模式: 又称发布/订阅(Publish/Subscribe)模式
Subject类: 抽象通知者

abstract class Subject {
    private IList observers = new List();
    //增加观察者
    public void Attach(Observer observer) { observers.Add(observer); }
    //移除观察者
    public void Detach(Observer observer) { observers.Remove(observer); }
    //通知
    public void Notify(){
        foreach(Observer o in observers) { o.Update(); }
    }
}

Observer类: 抽象观察者

abstract class Observer{
    public abstract void Update();
}

ConcreteSubject类: 具体通知者

class ConcreteSubject : Subject {
    private string subjectState; //状态
    public string SubjectState {
        get { return subjectState; }
        set { subjectState = value; }
    }
}

ConcreteObserver类: 具体观察者
客户端代码

14.6 观察者模式特点

维护对象之间的一致性
观察者模式：在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。
- java回调机制 vs. 观察者模式:
  - I thinkL java回调机制近似于观察者模式一个特例(一对一)

14.7 观察者模式的不足

14.8 事件委托实现

14.9 事件委托说明

14.10 石守吉失手机后的委托

第15章就不能不换DB吗？–抽象工厂模式

15.1 就不能不换DB吗？

数据库选型
- e.g., SQL Server, Acess

15.2 最基本的数据访问程序

class User{
    private int _id;
    public int ID {
        get {return _id; }
        set { _id = value; }
    }

    private string _name;
    public string Name{
        get { return _name; }
        set { _name = value; }
    }
}

SQL

class SqlserverUser{
    public void insert(User user) {
        Console.WriteLine("SQL Server insert a record");
    }

}

15.3 用了工厂方法模式的数据访问程序

IUser 接口

interface IUser{
    void Insert(User user);
    User GetUser(int id);
}

SqlserverUser类：访问SQL Server的User

class SqlserverUser : IUser{
    public void Insert(User user){
        Console.WriteLine("insert a record into SQL Server Database");
    }

    public User GetUser(int id){
        Console.WriteLine("get User's a record from SQL Server according to ID");
        return null;
    }
}

AccessUser类: 用于访问Acess的User

class AccessUser : IUser{
    public void Insert(User user){
        Console.WriteLine("insert a record into Access Database");
    }

    public User GetUser(int id){
        Console.WriteLine("get User's a record from Access according to ID");
        return null;
    }
}

IFactory接口: 定义访问User的抽象工厂接口

interface IFactory{
    IUser CreateUser();
}

SqlServerFactory类: 实现IFactory接口

class SqlServerFactory{
    public IUser CreateUser(){
        return new SqlserverUser();
    }
}

AccessFactory类: 实现IFactory接口

class AccessFactory{
    public IUser CreateUser(){
        return new AccessUser();
    }
}

客户端

static void Main(string args){
    User user = new User();
    IFactory factory = new SqlServerFactory();
    IUser iu = factory.CreateUser();

    iu.Insert(user);
    iu.GetUser(1);

    Console.Read();
}

15.4 用了抽象工厂模式的数据访问程序

增加了部门表Department的处理

interface IDepaerment{
    void insert(Department department);

    Department GetDepartment(int i);
}

SqlserverDepartment类: 用于访问SQL Server的Department

class SqlserverDepartment : IDepartment{
    ...
}

修改IFactory类，增加了访问Department表的抽象工厂接口

interface IFactory{
    IUser CreateUser();
    IDepartment CreateDepartment(); //增加新接口
}

SqlServerFactory类: 实现IFactory接口

class SqlServerFactory : IFactory{
    public IUser CreateUser(){
        return new SqlserverUser();
    }

    public IDepartment CreateDepartment() {
        return new SqlserverDepartment();
    }
}

客户端

static void Main(string[] args)
{
    User user = new User();
    Department dept = new Department();

    //AbstractFactory factory = new SqlServerFactory();
    IFactory factory = new AccessFactory();
    IUser iu = factory.CreateUser();

    iu.Insert(user);
    iu.GetUser(1);

    IDepartment id = factory.CreateDepartment();
    id.Insert(dept);
    id.GetDepartment(1);

    Console.Read();
}

15.5 抽象工厂模式

抽象工厂: 可理解为抽象工厂生产抽象产品
- 具体工厂生产具体产品

15.6 抽象工厂模式的优点与缺点

15.7 用简单工厂来改进抽象工厂

class DataAccess
{
    private static readonly string db = "Sqlserver";
    //private static readonly string db = "Access";

    public static IUser CreateUser()
    {
        IUser result = null;
        switch (db)
        {
            case "Sqlserver":
                result = new SqlserverUser();
                break;
            case "Access":
                result = new AccessUser();
                break;
        }
        return result;
    }

    public static IDepartment CreateDepartment()
    {
        IDepartment result = null;
        switch (db)
        {
            case "Sqlserver":
                result = new SqlserverDepartment();
                break;
            case "Access":
                result = new AccessDepartment();
                break;
        }
        return result;
    }
}

客户端

static void Main(string[] args)
{
    User user = new User();
    Department dept = new Department();

    IUser iu = DataAccess.CreateUser();

    iu.Insert(user);
    iu.GetUser(1);

    IDepartment id = DataAccess.CreateDepartment();
    id.Insert(dept);
    id.GetDepartment(1);

    Console.Read();
}

15.8 用反射+抽象工厂的数据访问程序

依赖注入(Dependency Injection)
- IoC
C# 反射技术: Assembly.Load(AssemblyName).CreateInstance(className);

using System.Reflection;

class DataAccess
{
    private static readonly string AssemblyName = "抽象工厂模式";
    private static readonly string db = "Sqlserver";
    //private static readonly string db = "Access";

    public static IUser CreateUser()
    {
        string className = AssemblyName + "." + db + "User";
        return (IUser)Assembly.Load(AssemblyName).CreateInstance(className);
    }

    public static IDepartment CreateDepartment()
    {
        string className = AssemblyName + "." + db + "Department";
        return (IDepartment)Assembly.Load(AssemblyName).CreateInstance(className);
    }
}

new issue: 更换数据库访问时，还需改变db

15.9 用反射+配置文件实现数据访问程序

solution: 添加app.config
- 通过配置文件来解决


<configuration>
    <appSettings>
        <add key="DB" value="Sqlserver"/>
    appSettings>
configuration>

C#读取配置文件

private static readonly string db = ConfigurationManager.AppSettings["DB"];

15.10 无痴迷，不成功

Application: 反射应用于 WCF，比如 app.config

第16章无尽加班何时休–状态模式

16.1 加班，又是加班！

16.2 工作状态-函数版

面向对象
- 程序 -> 类 + 方法
面向过程

16.3 工作状态-分类版

16.4 方法过长是坏味道

Martin Flow: Long Method -> 坏味道
过多判断，过多分支 -> 责任分解不到位

16.5 状态模式

State类: 抽象状态类

abstract class State {
    public abstract void Handle(Context context);
}

ConcreteState类: 具体状态，每一子类实现与一个Context的状态相关行为

class ConcreteStateA : State {
    public override void Handle(Context context) {
        //下一状态为ConcretexStateB
        //自动机状态 -> 变迁
        context.State = new ConcretexStateB();
    }
}

class ConcreteStateB : State {
    public override void Handle(Context context) {
        //下一状态为ConcretexStateA
        //自动机状态 -> 变迁
        context.State = new ConcretexStateA();
    }
}

Context类: 维护一个ConcreteState子类的实例，该实例定义当前状态

class Context {
    private State state;
    public Context(State state) {this.state = state;}

    public State State {
        get {return state;}
        set {
            state = value;
            ...
        }
    }

    public void Request() {state.Handle(this);}
}

16.6 状态模式好处与用处

16.7 工作状态-状态模式版

注意 uml图中虚线箭头的含义，对照代码

//工作
public class Work {
    private State state;
    ...
    public void WriteProgram() {current.WriteProgram(this);}
}

第17章在NBA我需要翻译–适配器模式

17.1 在NBA我需要翻译！

Adapter

17.2 适配器模式

类适配器
- 通过多重继承，实现接口间匹配
- C#,Java不支持多重继承，仅C++支持
对象适配器

Target: 客户端适配接口

class Target {
    public virtual void Request() {}
}

Adaptee: 待适配类

class Adaptee {
    public virtual void SpecificRequest() {}
}

Adapter: 实际适配类，内部包装一个Adaptee对象，实现接口转换

class Adapter : Target {
    //包装
    private Adaptee adaptee = new Adaptee();
    public virtual void Request() {
        adaptee.SpecificRequest(); //转换
    }
}

客户端代码

static void Main(string[] args){
    Target target = new Adapter();
    target.Request();
}

17.3 何时使用适配器模式

17.4 篮球翻译适配器

我认为本节示例有不合理成分，比如外籍中锋为中锋的子类，又比如有外籍后卫呢？

我认为应该改为下图所示: 即 + 组合模式(第19章)

17.5 适配器模式的.NET应用

.NET: DataAdapter

17.6 扁鹊的医术

第18章如果再回到从前–备忘录模式

18.1 如果再给我一次机会……

18.2 游戏存进度

18.3 备忘录模式

Originator: 负责创建备忘录，以记录其内部当前时刻状态
Memento: 备忘录，负责存储Originator对象内部状态
Caretaker: 负责保存好备忘录

18.4 备忘录模式基本代码

发起者(Originator)

class Originator {
    private string state;
    public string State {
        get {return state;}
        set {state = value;}
    }

    public Memento CreateMemeto() {
        return Memetor(state);
    }

    public void SetMemento(Memento memento){
        state = memento.State;
    }

    public void Show(){
        Console.WriteLine("State=" + state);
    }
}

备忘录(Memento)类

class Memento {
    private string state;

    public Memento(string state) {this.state = state;}

    public string State {
        get {return state;}
    }
}

管理者(Caretaker):

class Caretaker {
    private Memento memento;

    public Memento Memento {
        get {return memento;}
        set {memento = value;}
    }
}

18.5 游戏进度备忘

JAVA与模式博文

博文写得很好，还有时序图，比书上介绍的更清楚！
本书作者程杰示意图没有引入 Client行为时序图，很难表现 Design pattern使用方式！

第19章分公司=一部门–组合模式

19.1 分公司不就是一部门吗？

树结构 -> 层次化
整体 vs 部分

19.2 组合模式

Component: 组合中对象声明接口

abstract class Component {
    protected string name;

    public Component(string name) {this.name = name;}

    public abstract void Add(Component c);
    public abstract void Remove(Component c);
    public abstract void Display(Component c);
}

Leaf: 表示组合中叶节点 -> 无子节点

class Leaf : Component {
    pulic Leaf(string name) : base(name) {}
    ...
}

Composite: 表示枝节点，有子节点

class Composite : Component {
    //保存下属的枝/叶节点
    private List children = new List();
}

19.3 透明方式与安全方式

19.4 何时使用组合模式

ASP.net: TreeView控件

19.5 公司管理系统

19.6 组合模式好处

第20章想走？可以！先买票–迭代器模式

20.1 乘车买票，不管你是谁！

20.2 迭代器模式

Iterator -> 遍历

20.3 迭代器实现

Iterator迭代器抽象类

abstract class Iterator {
    public abstract object First();
    public abstract object Next();
    public abstract bool IsDone();
    public abstract object CurrentItem();
}

Aggregate聚焦抽象类

abstract class aggregate {
    public abstract Iterator createIterator(); //创建迭代器
}

ConcreteIterator: 具体迭代器类

class ConcreteIterator : Iterator {
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    public override Object First(){
        return aggregate[0];
    }

    public override Object Next(){
        Object ret = null;
        current++;

        if(current < aggregate.Count)
            ret = aggregate[current];

        return ret;
    }

    public override bool IsDone(){
        return current >= aggregate.Count? true : false;
    }

    public override object CurrentItem(){
        return aggregate[current];
    }
}

ConcreteAggregate: 具体聚集类

class Concreteaggregate : Aggregate {
    private IList<object> items = new List

大话设计模式 读书笔记

大话设计模式 读书笔记

Preface

关于本书学习的疑问解答

第1章 代码无错就是优？——简单工厂模式

1.8 业务的封装

1.10 简单工厂模式

1.11 UML类图

第2章 商场促销——策略模式

2.1 商场收银软件

2.2 增加打折

2.3 简单工厂实现

2.4 策略模式

2.5 策略模式实现

2.6 策略与简单工厂结合

2.7 策略模式解析

第3章 拍摄UFO–单一职责原则

3.1 新手机

3.2 拍摄

3.3 没用的东西

3.4 单一职责原则

3.5 方块游戏的设计

3.6 手机职责过多吗？

第4章 考研求职两不误–开放-封闭原则

4.1 考研失败

4.2 开放-封闭原则

4.3 何时应对变化

4.4 两手准备，并全力以赴

第5章 会修电脑不会修收音机？–依赖倒转原则

5.1 MM请求修电脑

5.2 电话遥控修电脑

5.3 依赖倒转原则

5.4 里氏代换原则

5.5 修收音机

第6章 穿什么有这么重要？–装饰模式

6.1 穿什么有这么重要？

6.2 小菜扮靓第一版

6.3 小菜扮靓第二版

6.4 装饰模式

6.5 小菜扮靓第三版

6.6 装饰模式总结

第7章 为别人做嫁衣–代理模式

7.1 为别人做嫁衣！

7.2 没有代理的代码

7.3 只有代理的代码

7.4 符合实际的代码

7.5 代理模式

7.6 代理模式应用

7.7 秀才让小六代其求婚

第8章 雷锋依然在人间–工厂方法模式

8.1 再现活雷锋

8.2 简单工厂模式实现

8.3 工厂方法模式实现

8.4 简单工厂vs.工厂方法

8.5 雷锋工厂

第9章 简历复印–原型模式

9.1 夸张的简历

9.2 简历代码初步实现

9.3 原型模式

9.4 简历的原型实现

9.5 浅复制与深复制

9.6 简历的深复制实现

9.7 复制简历vs.手写求职信

第10章 考题抄错会做也白搭–模板方法模式

10.1 选择题不会做，蒙呗！

10.2 重复=易错+难改

10.3 提炼代码

10.4 模板方法模式

10.5 模板方法模式特点

10.6 主观题，看你怎么蒙

第11章 无熟人难办事？–迪米特法则

11.1 第一天上班

11.2 无熟人难办事

11.3 迪米特法则

第12章 牛市股票还会亏钱？–外观模式

12.1 牛市股票还会亏钱？

12.2 股民炒股代码

12.3 投资基金代码

12.4 外观模式

12.5 何时使用外观模式

大话设计模式读书笔记

大话设计模式读书笔记

第1章代码无错就是优？——简单工厂模式

第2章商场促销——策略模式

第3章拍摄UFO–单一职责原则

第4章考研求职两不误–开放-封闭原则

第5章会修电脑不会修收音机？–依赖倒转原则

第6章穿什么有这么重要？–装饰模式

第7章为别人做嫁衣–代理模式

第8章雷锋依然在人间–工厂方法模式

第9章简历复印–原型模式

第10章考题抄错会做也白搭–模板方法模式

第11章无熟人难办事？–迪米特法则

第12章牛市股票还会亏钱？–外观模式

第13章好菜每回味不同–建造者模式

第14章老板回来，我不知道–观察者模式

第15章就不能不换DB吗？–抽象工厂模式

第16章无尽加班何时休–状态模式

第17章在NBA我需要翻译–适配器模式

第18章如果再回到从前–备忘录模式

第19章分公司=一部门–组合模式

第20章想走？可以！先买票–迭代器模式

第21章有些类也需计划生育–单例模式