C#设计模式之总结篇

 1 /// <summary>
 2     /// 单例模式的实现
 3     </summary>
 4     public sealed class Singleton
 5     {
 6         // 定义一个静态变量来保存类的实例
 7         private static volatile Singleton uniqueInstance;
 8  
 9          定义一个标识确保线程同步
10         readonly object locker = new object();
11  
12          定义私有构造函数，使外界不能创建该类实例
13         private Singleton()
14         {
15         }
16  
17         18          定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
19         20         <returns></returns>
21         static Singleton GetInstance()
22 23              当第一个线程运行到这里时，此时会对locker对象 "加锁"，
24              当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
25              lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
26              双重锁定只需要一句判断就可以了
27             if (uniqueInstance == null)
28             {
29                 lock (locker)
30                 {
31                      如果类的实例不存在则创建，否则直接返回
32                     33                     {
34                         uniqueInstance = new Singleton();
35                     }
36                 }
37             }
38             return uniqueInstance;
39 40     }

  1   2          下面以不同系列房屋的建造为例子演示抽象工厂模式
  3          因为每个人的喜好不一样，我喜欢欧式的，我弟弟就喜欢现代的
  4          客户端调用
  5           6          Client
  7   8             void Main(string[] args)
  9  10                 哥哥的欧式风格的房子
 11                AbstractFactory europeanFactory=  EuropeanFactory();
 12                europeanFactory.CreateRoof().Create();
 13                europeanFactory.CreateFloor().Create();
 14                europeanFactory.CreateWindow().Create();
 15                europeanFactory.CreateDoor().Create(); 
 16 
 17    
 18                弟弟的现代风格的房子
 19                AbstractFactory modernizationFactory =  ModernizationFactory();
 20                modernizationFactory.CreateRoof().Create();
 21                modernizationFactory.CreateFloor().Create();
 22                modernizationFactory.CreateWindow().Create();
 23                modernizationFactory.CreateDoor().Create();
 24                Console.Read();
 25           }
 26     }
 27    
 28        29        抽象工厂类，提供创建不同类型房子的接口
 30       31       abstract  AbstractFactory
 32      {
 33           抽象工厂提供创建一系列产品的接口，这里作为例子，只给出了房顶、地板、窗户和房门创建接口
 34          abstract Roof CreateRoof();
 35           Floor CreateFloor();
 36           Window CreateWindow();
 37           Door CreateDoor();
 38      }
 39   
 40       41      欧式风格房子的工厂，负责创建欧式风格的房子
 42      43      EuropeanFactory : AbstractFactory
 44  45           制作欧式房顶
 46          override Roof CreateRoof()
 47          {
 48               return  EuropeanRoof();
 49  50   
 51           制作欧式地板
 52           Floor CreateFloor()
 53  54               EuropeanFloor();
 55          }
 56  
 57          制作欧式窗户
 58          Window CreateWindow()
 59  60               EuropeanWindow();
 61  62  
 63          制作欧式房门
 64          Door CreateDoor()
 65  66               EuropeanDoor();
 67  68  69   
 70       71      现在风格房子的工厂，负责创建现代风格的房子
 72      73      ModernizationFactory : AbstractFactory
 74  75           制作现代房顶
 76          77  78               ModernizationRoof();
 79  80 
 81          制作现代地板
 82         83        {
 84              ModernizationFloor();
 85        }
 86  
 87         制作现代窗户
 88        89       {
 90             ModernizationWindow();
 91       }
 92  
 93        制作现代房门
 94       95  96             ModernizationDoor();
 97  98   }
 99    
100     101      房顶抽象类，子类的房顶必须继承该类
102    103     Roof
104 105          106          创建房顶
107        108        void Create();
109    }
110   
111    112    地板抽象类，子类的地板必须继承该类
113   114    Floor
115    {
116         117         创建地板
118       119      120 121   
122    123    窗户抽象类，子类的窗户必须继承该类
124   125     Window
126 127         128         创建窗户
129       130       131 132  
133    134     房门抽象类，子类的房门必须继承该类
135    136     Door
137 138         139         创建房门
140       141       142 143   
144    145    欧式地板类
146   147    EuropeanFloor : Floor
148 149       override  Create()
150 151           Console.WriteLine("创建欧式的地板");
152 153 154   
155   
156     157     欧式的房顶
158    159     EuropeanRoof : Roof
160 161          162 163             Console.WriteLine(创建欧式的房顶164 165 166   
167  
168     169     欧式的窗户
170     171      EuropeanWindow : Window
172 173          174 175              Console.WriteLine(创建欧式的窗户176 177 178   
179   
180      181      欧式的房门
182    183      EuropeanDoor : Door
184 185         186 187             Console.WriteLine(创建欧式的房门188 189 190  
191      192      现代的房顶
193     194      ModernizationRoof : Roof
195 196          197 198              Console.WriteLine(创建现代的房顶199 200 201  
202     203      现代的地板
204    205      ModernizationFloor : Floor
206 207         208 209              Console.WriteLine(创建现代的地板210 211 212       
213     214      现代的窗户
215    216     ModernizationWindow : Window
217 218           219 220               Console.WriteLine(创建现代的窗户221 222 223  
224     225      现代的房门
226    227     ModernizationDoor : Door
228 229         230 231             Console.WriteLine(创建现代的房门232 233     }

 1 namespace 桥接模式的实现
 2 {
 4      该抽象类就是抽象接口的定义，该类型就相当于是Abstraction类型
 5      6      Database
 7  8         通过组合方式引用平台接口，此处就是桥梁，该类型相当于Implementor类型
protected PlatformImplementor _implementor;
10 
11         通过构造器注入，初始化平台实现
 Database(PlatformImplementor implementor)
13 14             this._implementor = implementor;
16 
17         创建数据库--该操作相当于Abstraction类型的Operation方法
18         19 20 
21     22      该抽象类就是实现接口的定义，该类型就相当于是Implementor类型
23     24      PlatformImplementor
25 26         该方法就相当于Implementor类型的OperationImpl方法
27          Process();
29 
30     31      SqlServer2000版本的数据库，相当于RefinedAbstraction类型
32     33      SqlServer2000 : Database
34 35         构造函数初始化
36         public SqlServer2000(PlatformImplementor implementor) : base(implementor) { }
37 
38         40             this._implementor.Process();
41 42 43 
44     45      SqlServer2005版本的数据库，相当于RefinedAbstraction类型
46     47      SqlServer2005 : Database
48 49         50         public SqlServer2005(PlatformImplementor implementor) : 51 
52         53 54             55 56 57 
58     59      SqlServer2000版本的数据库针对Unix操作系统具体的实现，相当于ConcreteImplementorA类型
60     61      SqlServer2000UnixImplementor : PlatformImplementor
62 63          Process()
64 65             Console.WriteLine(SqlServer2000针对Unix的具体实现66 67 68 
69     70      SqlServer2005版本的数据库针对Unix操作系统的具体实现，相当于ConcreteImplementorB类型
71     72      SqlServer2005UnixImplementor : PlatformImplementor
73 74         75 76             Console.WriteLine(SqlServer2005针对Unix的具体实现77 78 79 
80      Program
81 82          Main()
83 84             PlatformImplementor SqlServer2000UnixImp =  SqlServer2000UnixImplementor();
85             还可以针对不同平台进行扩展，也就是子类化，这个是独立变化的
86 
87             Database SqlServer2000Unix =  SqlServer2000(SqlServer2000UnixImp);
88             数据库版本也可以进行扩展和升级，也进行独立的变化。
89 
90             以上就是两个维度的变化。
91 
92          就可以针对Unix执行操作了
93          SqlServer2000Unix.Create();
94 95 96 }

 装饰模式的实现
 该抽象类就是房子抽象接口的定义，该类型就相当于是Component类型，是饺子馅，需要装饰的，需要包装的
 House
房子的装修方法--该操作相当于Component类型的Operation方法
 Renovation();
10 11 
12     13      该抽象类就是装饰接口的定义，该类型就相当于是Decorator类型，如果需要具体的功能，可以子类化该类型
14     15     class DecorationStrategy:House 关键点之二，体现关系为Is-a，有这这个关系，装饰的类也可以继续装饰了
16 17        通过组合方式引用Decorator类型，该类型实施具体功能的增加
这是关键点之一，包含关系，体现为Has-a
19          House _house;
22          DecorationStrategy(House house)
23 24            this._house=house;
26 
27        该方法就相当于Decorator类型的Operation方法
28         Renovation()
29 30            if(this._house!=31 32                 ._house.Renovation();
36  
37     38      PatrickLiu的房子，我要按我的要求做房子，相当于ConcreteComponent类型，这就是我们具体的饺子馅，我个人比较喜欢韭菜馅
39     40      PatrickLiuHouse:House
42         43 44             Console.WriteLine(装修PatrickLiu的房子45 46 47  
48 
49    50      具有安全功能的设备，可以提供监视和报警功能，相当于ConcreteDecoratorA类型
51     52      HouseSecurityDecorator:DecorationStrategy
54         public  HouseSecurityDecorator(House house):(house){}
55 
56         57 58             .Renovation();
59             Console.WriteLine(增加安全系统60 61 62  
63     64      具有保温接口的材料，提供保温功能，相当于ConcreteDecoratorB类型
65     66      KeepWarmDecorator:DecorationStrategy
68         public  KeepWarmDecorator(House house):69 
70         71 72             73             Console.WriteLine(增加保温的功能74 76 
77    79       80 81          这就是我们的饺子馅，需要装饰的房子
82          House myselfHouse= PatrickLiuHouse();
83 
84          DecorationStrategy securityHouse= HouseSecurityDecorator(myselfHouse);
85          securityHouse.Renovation();
86          房子就有了安全系统了
87 
88          如果我既要安全系统又要保暖呢，继续装饰就行
89          DecorationStrategy securityAndWarmHouse= HouseSecurityDecorator(securityHouse);
90          securityAndWarmHouse.Renovation();
91 92 93 }

 命令模式的实现
 俗话说：“好吃不如饺子，舒服不如倒着”。今天奶奶发话要吃他大孙子和孙媳妇包的饺子。今天还拿吃饺子这件事来说说命令模式的实现吧。
 9 10             奶奶想吃猪肉大葱馅的饺子
11             PatrickLiuAndWife liuAndLai = new PatrickLiuAndWife();命令接受者
12             Command command = new MakeDumplingsCommand(liuAndLai);命令
13             PaPaInvoker papa = new PaPaInvoker(command); 命令请求者
14 
15             奶奶发布命令
            papa.ExecuteCommand();
17 
18 
            Console.Read();
20 21 22 
23     这个类型就是请求者角色--也就是我爸爸的角色，告诉奶奶要吃饺子
 PaPaInvoker
我爸爸从奶奶那里接受到的命令
 Command _command;
28 
29         爸爸开始接受具体的命令
30         public PaPaInvoker(Command command)
32             this._command = command;
34 
爸爸给我们下达命令
 ExecuteCommand()
38             _command.MakeDumplings();
40 41 
42     该类型就是抽象命令角色--Commmand，定义了命令的抽象接口，任务是包饺子
43      Command
44 45         真正任务的接受者
46          PatrickLiuAndWife _worker;
47 
48          Command(PatrickLiuAndWife worker)
49 50             _worker = worker;
51 52 
53         该方法就是抽象命令对象Command的Execute方法
 MakeDumplings();
56 
57     该类型是具体命令角色--ConcreteCommand，这个命令完成制作“猪肉大葱馅”的饺子
58      MakeDumplingsCommand : Command
59 60         public MakeDumplingsCommand(PatrickLiuAndWife worker) : (worker) { }
61 
62         执行命令--包饺子
 MakeDumplings()
65             执行命令---包饺子
66             _worker.Execute(今天包的是农家猪肉和农家大葱馅的饺子68 70     该类型是具体命令接受角色Receiver，具体包饺子的行为是我们夫妻俩来完成的
71      PatrickLiuAndWife
72 73         这个方法相当于Receiver类型的Action方法
void Execute( job)
76             Console.WriteLine(job);
79 }

79 }

  1  中介者模式的实现
  2   3     抽象中介者角色
  4     interface Mediator
  5  Command(Department department);
  8 
  9     总经理--相当于具体中介者角色
 10      President : Mediator
 11  12         总经理有各个部门的管理权限
 13          Financial _financial;
 14          Market _market;
 15          Development _development;
 17          SetFinancial(Financial financial)
 18  19             this._financial = financial;
 21          SetDevelopment(Development development)
 23             this._development = development;
 25          SetMarket(Market market)
 27             this._market = market;
 28  29 
 30          Command(Department department)
 31  32             if (department.GetType() == typeof(Market))
 33  34                 _financial.Process();
 35  36  37  38 
 39     同事类的接口
 40      Department
 41  42         持有中介者(总经理)的引用
 43          Mediator mediator;
 44 
 45          Department(Mediator mediator)
 46  47             this.mediator = mediator;
 48  49 
 50          Mediator GetMediator
 51  52             get {  mediator; }
 53             set {  value; }
 54  55 
 56         做本部门的事情
 58 
 59         向总经理发出申请
 60          Apply();
 62 
 63     开发部门
 64      Development : Department
 66         public Development(Mediator m) : (m) { }
 67 
 68          69  70             Console.WriteLine(我们是开发部门，要进行项目开发，没钱了，需要资金支持！ 71  72 
 73          Apply()
 75             Console.WriteLine(专心科研，开发项目！ 76  78 
 79     财务部门
 80      Financial : Department
 81  82         public Financial(Mediator m) :  83 
 84          86             Console.WriteLine(汇报工作！没钱了，钱太多了！怎么花? 87  88 
 89          90  91             Console.WriteLine(数钱！ 92  93  94 
 95     市场部门
 96      Market : Department
 98         public Market(Mediator mediator) : (mediator) { }
 99 
100         101 102             Console.WriteLine(汇报工作！项目承接的进度，需要资金支持！103             GetMediator.Command(105 
106         107 108             Console.WriteLine(跑去接项目！110 111 
112 
113     114 115          Main(String[] args)
116 117             President mediator =  President();
118             Market market =  Market(mediator);
119             Development development =  Development(mediator);
120             Financial financial =  Financial(mediator);
121 
122             mediator.SetFinancial(financial);
123             mediator.SetDevelopment(development);
124             mediator.SetMarket(market);
125 
            market.Process();
127             market.Apply();
128 
129 130 132 }

 状态模式的实现
  3         环境角色---相当于Context类型
  4          Order
  6              State current;
  7 
 Order()
 10                 工作状态初始化为上午工作状态
 11                 current =  WaitForAcceptance();
 12                 IsCancel = false;
 14             double minute;
 15              Minute
 16  17                  minute; }
 18                 set { minute = 19  20 
 21             bool IsCancel { get; set; }
 22 
bool finish;
 24              TaskFinished
 26                  finish; }
 27                 set { finish = 29              SetState(State s)
 30  31                 current = s;
 33              Action()
 35                 current.Process( 39         抽象状态角色---相当于State类型
 40          State
 42             处理订单
 43              Process(Order order);
 45 
 46         等待受理--相当于具体状态角色
 47          WaitForAcceptance : State
 49              Process(Order order)
 50  51                 System.Console.WriteLine(我们开始受理，准备备货！ 52                 if (order.Minute < 30 && order.IsCancel)
 54                     System.Console.WriteLine(接受半个小时之内，可以取消订单！ 55                     order.SetState( CancelOrder());
 56                     order.TaskFinished = true 57                     order.Action();
 58  59                 order.SetState( AcceptAndDeliver());
 60                 order.TaskFinished =                 order.Action();
 62  63  64 
 65         受理发货---相当于具体状态角色
 AcceptAndDeliver : State
 68              70                 System.Console.WriteLine(我们货物已经准备好，可以发货了，不可以撤销订单！ 71                  72  73                     System.Console.WriteLine( 74                     order.SetState( 75                     order.TaskFinished =  78                 if (order.TaskFinished== 80                     order.SetState( Success());
 82  84  85 
 86         交易成功---相当于具体状态角色
 87          Success : State
 88  89              91                 System.Console.WriteLine(订单结算 92                 order.SetState( ConfirmationReceipt());
 93                 order.TaskFinished =  94  96  97 
确认收货---相当于具体状态角色
 99          ConfirmationReceipt : State
100 101             102 103                 System.Console.WriteLine(检查货物，没问题可以就可以签收！104                 order.SetState(105                 order.TaskFinished = 106 108 109 
110         取消订单---相当于具体状态角色
111          CancelOrder : State
112 113             115                 System.Console.WriteLine(检查货物，有问题，取消订单！116                 order.SetState(117                 order.TaskFinished = 118 119 122 
123         125             127                 订单
128                 Order order =  Order();
129                 order.Minute = 9131                 可以取消订单
132                 order.IsCancel = 133                 order.Minute = 20134 135                 order.Minute = 33136 137                 order.Minute = 43138 139 
140                 Console.Read();
141 143     }

 Vistor
抽象图形定义---相当于“抽象节点角色”Element
 Shape
画图形
  7          Draw();
  8         外界注入具体访问者
  9          Accept(ShapeVisitor visitor);
 10  11 
 12     抽象访问者 Visitor
 13      ShapeVisitor
 Visit(Rectangle shape);
 Visit(Circle shape);
 18 
 19          Visit(Line shape);
这里有一点要说：Visit方法的参数可以写成Shape吗？就是这样 Visit(Shape shape)，当然可以，但是ShapeVisitor子类Visit方法就需要判断当前的Shape是什么类型，是Rectangle类型，是Circle类型，或者是Line类型。
 23 
 24     具体访问者 ConcreteVisitor
 25      CustomVisitor : ShapeVisitor
 27         针对Rectangle对象
 28          Visit(Rectangle shape)
 29  30             Console.WriteLine(针对Rectangle新的操作！ 32         针对Circle对象
 33          Visit(Circle shape)
 35             Console.WriteLine(针对Circle新的操作！ 37         针对Line对象
 38          Visit(Line shape)
 39  40             Console.WriteLine(针对Line新的操作！ 42  43 
 44     矩形----相当于“具体节点角色” ConcreteElement
 45      Rectangle : Shape
 Draw()
 49             Console.WriteLine(矩形我已经画好！ 51 
 52          Accept(ShapeVisitor visitor)
 54             visitor.Visit( 56  57 
 58     圆形---相当于“具体节点角色”ConcreteElement
 59      Circle : Shape
 60  61          63             Console.WriteLine(圆形我已经画好！ 64  65 
 68             visitor.Visit( 70  71 
 72     直线---相当于“具体节点角色” ConcreteElement
 Line : Shape
 75          77             Console.WriteLine(直线我已经画好！ 78  79 
 80          82             visitor.Visit( 86     结构对象角色
 87     internal  AppStructure
 ShapeVisitor _visitor;
 90 
 91          AppStructure(ShapeVisitor visitor)
 93             this._visitor = visitor;
 95 
 96          Process(Shape shape)
            shape.Accept(_visitor);
 99 101 
102     103 104         105 106             如果想执行新增加的操作
107             ShapeVisitor visitor =  CustomVisitor();
108             AppStructure app =  AppStructure(visitor);
110             Shape shape =  Rectangle();
111             shape.Draw();执行自己的操作
112             app.Process(shape);执行新的操作
113 
114 
115             shape =  Circle();
116             shape.Draw();117             app.Process(shape);118 
119 
120             shape =  Line();
121             shape.Draw();122             app.Process(shape);123 
124 
125             Console.ReadLine();
128 }

 MementoPattern
 联系人--需要备份的数据，是状态数据，没有操作
 ContactPerson
姓名
string Name { 电话号码
 10         string MobileNumber {  12 
 发起人--相当于【发起人角色】Originator
 14      MobileBackOriginator
 16          发起人需要保存的内部状态
private List<ContactPerson> _personList;
 19 
 20         public List<ContactPerson> ContactPersonList
 22             get
 24                 ._personList;
 26 
set
 29                 this._personList = value;
初始化需要备份的电话名单
public MobileBackOriginator(List<ContactPerson> personList)
 35             if (personList !=  37                  personList;
 39             else
 40  41                 throw new ArgumentNullException(参数不能为空！ 43  创建备忘录对象实例，将当期要保存的联系人列表保存到备忘录对象中
 ContactPersonMemento CreateMemento()
 48             new ContactPersonMemento(new List<ContactPerson>(._personList));
 50 
 51          将备忘录中的数据备份还原到联系人列表中
 RestoreMemento(ContactPersonMemento memento)
 54             this.ContactPersonList = memento.ContactPersonListBack;
 56 
 Show()
 59             Console.WriteLine(联系人列表中共有{0}个人，他们是:,ContactPersonList.Count);
 60             foreach (ContactPerson p in ContactPersonList)
 62                 Console.WriteLine(姓名: {0} 号码: {1} 66 
 67      备忘录对象，用于保存状态数据，保存的是当时对象具体状态数据--相当于【备忘录角色】Memeto
 68      ContactPersonMemento
 70          保存发起人创建的电话名单数据，就是所谓的状态
 71         public List<ContactPerson> ContactPersonListBack { public ContactPersonMemento(List<ContactPerson> 75             ContactPersonListBack = 管理角色，它可以管理【备忘录】对象，如果是保存多个【备忘录】对象，当然可以对保存的对象进行增、删等管理处理---相当于【管理者角色】Caretaker
 MementoManager
如果想保存多个【备忘录】对象，可以通过字典或者堆栈来保存，堆栈对象可以反映保存对象的先后顺序
 83         比如：public Dictionary<string,ContactPersonMemento> ContactPersonMementoDictionary { get; set; }
public ContactPersonMemento ContactPersonMemento {  86 
 91             List<ContactPerson> persons = new List<ContactPerson>()
 93                 new ContactPerson() { Name=黄飞鸿",MobileNumber = 13533332222}, 94                 方世玉13966554433 95                 洪熙官13198765544}
            };
 98             手机名单发起人
 99             MobileBackOriginator mobileOriginator =  MobileBackOriginator(persons);
            mobileOriginator.Show();
102              创建备忘录并保存备忘录对象
103             MementoManager manager =  MementoManager();
104             manager.ContactPersonMemento = mobileOriginator.CreateMemento();
 更改发起人联系人列表
107             Console.WriteLine(----移除最后一个联系人--------108             mobileOriginator.ContactPersonList.RemoveAt(2110 
111              恢复到原始状态
112             Console.WriteLine(-------恢复联系人列表------113             mobileOriginator.RestoreMemento(manager.ContactPersonMemento);
115 
117 119 }