面向对象（八）

MVC模式
数据模型->显示视图视图模型
Observer模式
Composite模式，都是控件
Strategy模式
Factory模式

项目文件夹
Domain
只有属性的类
控制序列化：XmlElement
XmlArray
XmlArrayItem

不好的代码
（1）重复duplicated
（2）不清楚unclear
（3）复杂complicated

代码需要体现意图intent

重构
（1）在父类实现不变的方法，抽象变化的方法
（2）在子类实现抽象的方法
（3）使用提取方法封装不变的共用逻辑
（4）方法名 – 需要体现命名意图

（1）类是对象的抽象，抽象类是类的抽象
（2）接口是对行为的抽象
（3）不要编写自己猜测的代码，要清楚代码是否有必要
（4）抽象类是由所有子类泛化而成
（5）接口和所有子类无联系，只是定义都具有的行为

软件设计：高度的抽象，提取不变的部分，分离变化的部分，根据实际决定抽象的层次

UML统一建模语言（Unified Modeling Language）

UML四大关系
1关联关系（association）（聚合aggregation）（组合composition）
2依赖（dependency）
3泛化（generalization）
4实现（realization）
UML五类基本视图
1用例视图
2逻辑视图
3构件视图
4并发视图
5配置视图
UML主要模型
1用例图（用例图）（动）
2静态图（类图，对象图）（静）
3行为图（状态图，活动图）（动）
4交互图（序列图，协作图）（动）
5实现图（构件图，配置图）（静）
UML主要图形
1用例图（核心）
2类图（重点）
3对象图
4包图
5状态图
6活动图
7序列图
8协作图
9构件图
10配置图
软件开发模型
1边做边改模型
2瀑布模型
3快速原型模型
4增量模型
5螺旋模型
6演化模型
7喷泉模型
8智能模型
9混合模型

面向对象的多态的特性及意义
面向对象使用派生继承以及虚函数机制，一个指向（基类）的指针，可以指向其派生类
并访问从（基类）继承而来的成员变量和函数。
而虚函数是专门为这个特性设计的，这个函数在每个派生类中都是同一个名字，但函数体却并不一定相同，派生类为实现自己的功能而重写这个虚函数。
这样用一个指针就能够实现对多种不同的派生类的访问，并实现其派生类的特定功能。

抽象类和接口区别
抽象类：是特殊的类，不能被实例化，里面含有声明的抽象方法，在子类必须实现
抽象类：可以继承抽象类。基类，抽象方法可以实现，也可以放在后面实现
抽象类：可以实现多个接口，和继承普通类
接口：不能继承任何类的
接口：可以继承接口。继承多个接口时方法有相同时，只需实现一个方法，当然参数不同就该进行重载

10
接口
接口：可以包含方法，属性，事件，索引器，不能包含字段
接口：只定义，不实现
接口：继承接口必须实现所有定义
接口：对于接口继承接口，实现子接口就实现全部方法，对接口同名方法只需实现一个

11
虚拟实现接口，就是通过添加virtual关键字实现，这样方便后面override

关键字
虚拟virtual，不能私有，必须方法体，后代决定是否override
密封sealed，不能被继承，在override时sealed，禁止后代override，后代可以用new来隐藏前辈的方法

4
类和结构的区别
结构：是值类型
结构：没继承关系（不能继承，也不能被继承）
结构：能实现接口
结构：没默认构造，析构，注意只是没有默认的构造，析构；也就是用户不能定义不带参数的构造

7
类型和实例，父类，子类，子类的子类
由类型决定调用的方法，由实例决定执行的方法体，只有在重写时，父类类型才执行子类实例重写方法，父类类型不能调用子类隐藏（new）的方法
总之，先决定可调用方法，再决定执行的方法体

8
静态构造方法
静态构造：无访问符修饰
静态构造：仅1个且无参
静态构造：不会被继承
静态构造：在静态成员执行后执行，在静态方法执行前执行
静态构造：只执行1次

9
基类，子类，构造函数
从基类开始构造，只要手写了构造函数，默认无参就必须重写才可以用，子类构造函数不指明执行父类的构造函数时，就执行父类默认的无参构造，如果此时父类没有无参的，就报错

12
父类子类构造函数执行顺序，及调用虚方法
这里注意啦，是从父类开始层层构造，抽象虚拟方法只会执行1个实现，从实例开始寻找重写（注意隐藏new）
class Program
{
static void Main(string[] args)
{
A1 t = new A1(); // 1, 0
t.Test(); // 1, -1
}
}
abstract class A
{
protected int x = 1;
protected int y;
protected A() { Test(); }
internal abstract void Test();
}
class A1 : A
{
internal A1() { y = -1; }
internal override void Test()
{
Console.WriteLine("X={0},Y={1}", x, y);
}
}

13
经验：
多样组合，少用继承
针对接口编程，针对抽象编程
面向接口，面向对象，面向方面

14
操建宫元丹，石桥组装外，享待，子命解谍中，备观状策谋，仿！

15
抽访类似，建适Z型，工观迭口，原状代组职解似，单例，桥中（中介与命令区别），装饰，外观，命令*5（与中介区别），备忘，策略，模板

16
创建型
 抽象工厂
提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
 建造者
将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。
Separate the construction of a complex object from its representation so that the same construction process can create different representations.
 工厂方法
定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法模式使一个类的实例化延迟到其子类。
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
工厂里有个方法根据不同的参数制造不同的产品
 原型模式
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
 单例
保证一个类仅有一个实例，并提供一个访问他的全局访问点。
Ensure a class only has one instance, and provide a global point of access to it.
结构型
 适配器模式
将一个类的接口转换成客户希望的另外一个接口，适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
 桥接模式
将抽象部分与他的实现部分分离，使他们都可以独立的变化。
Decouple an abstraction from its implementation so that the two can vary independently.
 组合模式
将对象组合成树型结构以表示部分与整体的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
 装饰模式（2层）
动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
 外观模式
为子系统的一组接口提供一个一致的界面，此模式定义一个高层接口，这个接口使得这一子系统更加容易使用。
Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
 享元
运用共享技术有效的支持大量细粒度的对象。
Use sharing to support large numbers of fine-grained objects efficiently.
 代理模式
为其他对象提供一种代理，以控制对这个对象的访问。
Provide a surrogate or placeholder for another object to control access to it.
行为型
 职责链模式
使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。
Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
 命令模式（类似word里的撤销/重做，举例：加减运算）
将一个请求封装成一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。
Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
 解释器模式
给定一个语言，定义他文法的一种表示，并定义一个解释器，这个解释器使用这个表示来解释语言中的句子。
Given a language, define a represention for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
 迭代器
提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
 中介者模式
用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，从而使其耦合松散，而且可以独立的改变他们之间的交互。
Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.
 备忘录模式
在不破坏封装性的前提下，捕获一个对象内部状态，并在该对象之外保存这个状态，这样以后就可以将该对象恢复到原先保存的状态。
Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.
 观察者
定义一种一对多的依赖关系，让多个观察者同时监听一个主题对象，当这个主题对象的状态发生改变时，会通知所有观察者对象，使他们能够自动更新自己。
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
 状态模式
当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。
Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
 策略模式
定义算法家族，分别封装起来，并且让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。
Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
 模板方法模式
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构，即可重定义该算法的某些特定的步骤。
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
 访问者模式
表示一个作用于某对象结构中各元素的操作，他使你可以在不改变各元素的类的前提下，定义作用于这些元素的新操作。
Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.
1，
泛型实现单例模式
泛型：所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型，
class Program
{
static void Main(string[] args)
{
//GenericTest test = new GenericTest();
GenericTest test = new GenericTest();
}
}
class GenericTest where T : new() // 这里是泛型T约束，表示T必须具有无参的构造函数
{
public string Func()
{
T test = new T();
return test.ToString();
}
}
class Tlegal
{
public Tlegal() { }
}
class Tnotlegal
{
//public Tnotlegal() { } // 如果没有这个方法，将会报错，
public Tnotlegal(string str) { }
}
泛型单例模式：
class Program
{
static void Main(string[] args)
{
GenericTest test1 = new GenericTest();
Console.WriteLine(test1.Time); // 11:20:14 不使用泛型单例
GenericTest test2 = new GenericTest();
Console.WriteLine(test2.Time); // 11:20:15 不使用泛型单例
SingletonTest test3 = new SingletonTest();
Console.WriteLine(test3.Instance.Time); // 11:20:16 使用泛型单例
SingletonTest test4 = new SingletonTest();
Console.WriteLine(test4.Instance.Time); // 11:20:16 使用泛型单例
}
}
class SingletonTest where T : new()
{
public T Instance { get { return SingletonCreator.instance; } }
class SingletonCreator // 泛型单例内部类
{
internal static readonly T instance = new T(); // 重点
}
}
class GenericTest
{
private DateTime _time;
public GenericTest()
{
System.Threading.Thread.Sleep(1000);
_time = DateTime.Now;
}
public string Time { get { return _time.ToString(); } }
}
2，
抽象工厂模式
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
IAbstractFactory factory1 = new ConcreteFactory1();
Client test1 = new Client(factory1);
test1.Run();
IAbstractFactory factory2 = new ConcreteFactory2();
Client test2 = new Client(factory2);
test2.Run();
}
}
class Client
{
private AbstractProductA _abstractProductA;
private AbstractProductB _abstractProductB;
public Client(IAbstractFactory factory)
{
_abstractProductA = factory.CreateProductA();
_abstractProductB = factory.CreateProductB();
}
public void Run()
{
Console.WriteLine(_abstractProductA.ToString());
Console.WriteLine(_abstractProductB.ToString());
}
}
interface IAbstractFactory { AbstractProductA CreateProductA(); AbstractProductB CreateProductB(); }
class ConcreteFactory1 : IAbstractFactory
{
#region IAbstractFactory 成员

    public AbstractProductA CreateProductA()
    {
        return new ProductA1();
    }

    public AbstractProductB CreateProductB()
    {
        return new ProductB1();
    }

    #endregion
}
class ConcreteFactory2 : IAbstractFactory
{
    #region IAbstractFactory 成员

    public AbstractProductA CreateProductA()
    {
        return new ProductA2();
    }

    public AbstractProductB CreateProductB()
    {
        return new ProductB2();
    }

    #endregion
}
abstract class AbstractProductA { }
class ProductA1 : AbstractProductA { }
class ProductA2 : AbstractProductA { }
abstract class AbstractProductB { }
class ProductB1 : AbstractProductB { }
class ProductB2 : AbstractProductB { }

}

3，
观察者模式
class Program
{
static void Main(string[] args)
{
ConcreteSubject s = new ConcreteSubject();
s.Attach(new ConcreteObserver(s, "X"));
s.Attach(new ConcreteObserver(s, "Y"));
s.Attach(new ConcreteObserver(s, "Z"));
s.SubjectState = "ABC";
s.Notify();
}
}
abstract class Subject
{
private List _observers = new List();
public void Attach(Observer observer) { _observers.Add(observer); }
public void Detach(Observer observer) { _observers.Remove(observer); }
public void Notify() { foreach (Observer observer in _observers) { observer.Update(); } }
}
class ConcreteSubject:Subject
{
private string _subjectState;

    public string SubjectState
    {
        get { return _subjectState; }
        set { _subjectState = value; }
    }
}
abstract class Observer { public abstract void Update();}
class ConcreteObserver : Observer
{
    private string _name;
    private string _observerState;
    private ConcreteSubject _subject;

    internal ConcreteSubject Subject
    {
        get { return _subject; }
        set { _subject = value; }
    }

    public ConcreteObserver(ConcreteSubject subject, string name)
    {
        this._subject = subject;
        this._name = name;
    }

    public override void Update()
    {
        _observerState = _subject.SubjectState;
        Console.WriteLine("Observer {0}'s new state is {1}", _name, _observerState);
    }

}
4，
工厂方法模式
class Program
{
static void Main(string[] args)
{
Creator t = new ConcreteCreator();
Product p = t.FactoryMethod();
}
}
abstract class Creator { public abstract Product FactoryMethod();}
class ConcreteCreator : Creator
{
public override Product FactoryMethod()
{
return new ConcreteProduct("factory method creat product");
}
}
abstract class Product { }
class ConcreteProduct : Product { public ConcreteProduct(string str) { Console.WriteLine(str); } }

5，
迭代器模式
class Program
{
static void Main(string[] args)
{
ConcreteAggregate a = new ConcreteAggregate();
a[0] = "ItemA";
a[1] = "ItemB";
a[2] = "ItemC";
a[3] = "ItemD";
Iterator i = new ConcreteIterator(a);
object o = i.First();
while (o != null) { Console.WriteLine(o); o = i.Next(); }
}
}
class Client
{
// ... for UML use
}
abstract class Iterator
{
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}
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;
    }

    public override object CurrentItem()
    {
        return _aggregate[_current];
    }
}
abstract class Aggregate
{
    public abstract Iterator CreateIterator();
}
class ConcreteAggregate : Aggregate
{
    private ArrayList _items = new ArrayList();
    public override Iterator CreateIterator()
    {
        return new ConcreteIterator(this);
    }
    public int Count { get { return _items.Count; } }
    public object this[int index] // 索引器
    {
        get { return _items[index]; }
        set { _items.Insert(index, value); }
    }

}
6，
外观模式
class Program
{
static void Main(string[] args)
{
Facade f = new Facade();
f.MethodA();
Console.WriteLine("------------");
f.MethodB();
}
}
class Client { } // for UML use
class Facade
{
private SubSystemOne _one;
private SubSystemTwo _two;
private SubSystemThree _three;
private SubSystemFour _four;
public Facade() { _one = new SubSystemOne(); _two = new SubSystemTwo(); _three = new SubSystemThree(); _four = new SubSystemFour(); }
public void MethodA() { _one.MethodOne(); _two.MethodTwo(); _four.MethodFour(); }
public void MethodB() { _two.MethodTwo(); _four.MethodFour(); }
}
class SubSystemOne { public void MethodOne() { Console.WriteLine("one"); } }
class SubSystemTwo { public void MethodTwo() { Console.WriteLine("two"); } }
class SubSystemThree { public void MethodThree() { Console.WriteLine("three"); } }
class SubSystemFour { public void MethodFour() { Console.WriteLine("four"); } }
7，
组合模式
class Program
{
static void Main(string[] args)
{
Composite root = new Composite("root");
root.Add(new Leaf("leaf a"));
root.Add(new Leaf("leaf b"));
Composite comp = new Composite("composite X");
comp.Add(new Leaf("leaf xa"));
comp.Add(new Leaf("leaf xb"));
root.Add(comp);
root.Display(1);
}
}
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(int depth);
}
class Composite : Component
{
private List _children = new List();
public Composite(string name) : base(name) { }
public override void Add(Component component) { _children.Add(component); }
public override void Remove(Component component) { _children.Remove(component); }
public override void Display(int depth)
{
Console.WriteLine(new string('-', depth) + name);
foreach (Component component in _children) { component.Display(depth + 2); }
}
}
class Leaf : Component
{
public Leaf(string name) : base(name) { }
public override void Add(Component c) { Console.WriteLine("can not add to a leaf"); }
public override void Remove(Component c) { Console.WriteLine("can not remove from a leaf"); }
public override void Display(int depth) { Console.WriteLine(new string('-', depth) + name); }
}
8，
策略模式
class Program
{
static void Main(string[] args)
{
Context context;
context = new Context(new ConcreteStrategyA());
context.ContextInterface();
context = new Context(new ConcreteStrategyB());
context.ContextInterface();
context = new Context(new ConcreteStrategyC());
context.ContextInterface();
}
}
abstract class Strategy { public abstract void AlgorithmInterface();}
class ConcreteStrategyA : Strategy
{
public override void AlgorithmInterface()
{
Console.WriteLine("called strategy a");
}
}
class ConcreteStrategyB : Strategy
{
public override void AlgorithmInterface()
{
Console.WriteLine("called strategy b");
}
}
class ConcreteStrategyC : Strategy
{
public override void AlgorithmInterface()
{
Console.WriteLine("called strategy c");
}
}
class Context
{
private Strategy _strategy;
public Context(Strategy strategy) { this._strategy = strategy; }
public void ContextInterface() { _strategy.AlgorithmInterface(); }
}
9，
代理模式
class Program
{
static void Main(string[] args)
{
Proxy proxy = new Proxy();
proxy.Request();
}
}
class Client { }
abstract class Subject { public abstract void Request(); }
class RealSubject : Subject
{
public override void Request()
{
Console.WriteLine("real request");
}
}
class Proxy : Subject
{
private RealSubject _realSubject;
public override void Request()
{
if (_realSubject == null) { _realSubject = new RealSubject(); }
_realSubject.Request();
}
}
10，
适配器模式
class Program
{
static void Main(string[] args)
{
Target t = new Adapter();
t.Request();
}
}
class Client { } // for UML use
class Target { public virtual void Request() { Console.WriteLine("this is the target class"); } }
class Adapter : Target
{
private Adaptee _adaptee;
public Adapter() { if (_adaptee == null) { _adaptee = new Adaptee(); } }
public override void Request()
{
_adaptee.SpecificRequest(); // 虚方法多态适配接口
}
}
class Adaptee { public void SpecificRequest() { Console.WriteLine("Called SpecificRequest!"); } }

1、Transaction script

控制反转IOC（Inversion of control）
A依赖B，B不用new，由A自己控制，这就实现了控制反转
自动装配完成依赖注入

解决的问题：
抽象接口，具体实现，
通常无论怎么抽象，使用者都需要实例化具体实现，
这个创建具体实现的过程会对具体实现具有依赖性，为了消除这种依赖性，
我们采取依赖注入，
就是把依赖移除到程序外部（比如配置文件），然后使用依赖注入，这样可以适应需求的变化，
三种注入：
构造子注入(Constructor Injection)
设值方法注入(Setter Injection)
接口注入（Interface injection）

IOC步骤：Castle
建立容器，IWindsorContainer
加入组件
获取组件
使用组件

UML的五类基本视图
1用例视图：从系统外部执行者的角度理解、展示系统功能。
2逻辑视图：从系统的静态结构和动态行为的角度展示系统内部功能性设计。
3构件视图：展示代码构件的组织结构。
4并发视图：展示系统的并发性，刻画并发系统中的通讯和同步问题。
5配置视图：展示系统的物理的体系结构，其中用到的计算机和各种设备称作节点。

关联（朋友关系）：实线
表示引用，没生命依赖，双向关联，单向关联，自身关联，关联的两个东西是平等的，
聚合（aggregation）：实线空心菱形
聚合就是has-a，聚在一起可以分开，聚合的两个东西是整体与部分，不平等
组合（composition）：实线实心菱形
组合就是contains-a，有生命的依赖，也是整体与部分，不平等
泛化（generalization）：实线空三角
就是继承
实现（realization）：虚线空三角
就是实现接口
依赖（dependency）：虚线箭头
是一种弱的关联

UML主要图形
1用例图：核心，比较//High Level的图，从图上，可以看出系统的功能，方便客户是否需要增加功能，或取消功能，描述用户需求。
2类图：重点，描述系统具体实现，描述具体模块结构，抽象层次一般。类图就是实体类之间的逻辑关系，系统的静态结构图。公有元素用+号，私有元素用-号，#表示保护元素，用:号来分开名称和类型，属性和操作一样，操作还有参数列表，抽象类用斜体表示。
3对象图：描述具体模块的实现，抽象层次较低。对象图是类图的实例，显示的是对象实例，存在生命周期，只能在系统某一时间段存在。
4包图：
5状态图：状态图是对类图的补充。
6活动图：描述满足用例图进行的活动。
7序列图：描述系统的行为，对象间消息发送顺序。
8协作图：对象间动态合作关系。
9构件图：描述系统模块结构，抽象层次高。
10配置图：定义系统中软硬件的体系结构。

迭代
按照确定的计划执行的一组有顺序的活动。当满足确定的评价准则时，迭代结束。每次迭代都有一个可执行的提交。

概要理解
抽象工厂生产复杂的抽象产品
--IAbstractFactory factory = new ConcreateFactory();
--IComplexObject complex = factory.CreateComplexObject();
适配器模式从交流220伏转直流5伏电压
--Target target = new Adapter();
--Adapter需要关联被适配的对象
工厂方法，通过工厂类的方法根据传入参数条件，来创建具体产品
--IProduct product = OperationFactory.CreateConcreateProduct("+");

单例，私有的构造
--Singleton singleton = Singleton.GetInstance();

代理，房东将房子给中介去代理租售
--Proxy proxy = new Proxy("0-500");
--string s1 = proxy.DoSomething();
状态，订单状态不同，处理方式不同
--Order order = new Order(new NewState());
--order.Handle();
模板方法，模板的不同实现
--Template template = new TemplateA();
--template.Method();
职责链，ASP.NET的管道处理模型，就类似职责链，传递HttpContext
--Handler handler = HandlerFactory.GetHandlers(); // 已经形成职责链
--handler.Handle(request);
组合模式，ASP.NET的控件树
BaseComponent tree = new CompositeContainer("root");
tree.Add(new Leaf("leafA"));//添加个页子节点
tree.Add(new CompositeContainer("branch"));//添加个分支节点

面向对象（八）

你可能感兴趣的:(面向对象（八）)