C # implementation prototype

1. Using system;
2. Using system. Collections. Generic;
3. Using system. LINQ;
4. Using system. text;
6. Namespace Design Mode
7. {
8. Class Program
9. {
10. Static void main (string [] ARGs)
11. {
12. // First, the prototype mode is a creation mode used to handle the dependency caused by new.
13. // There are two essentials for the prototype mode: 1. Solve the dependency, that is to say, the Customer Code must depend on abstraction rather than implementation.
14. // 2 clone the instance that implements the class through the prototype of the connected image.
15. // The following is an example: for example, we can simulate and process different enemies in a Soldado game.
16. // Enemies fall into the sky, go to the ground, and swim in the water .. When the sky flies, a bomb can be thrown, and a gun can be taken on the ground. when traveling in the water, a knife can be used to hurt people.
17. // Below we start to define three enemy abstract classes. Note: Because the clone method is implemented, it cannot be an interface.
18. // Next, we will create specific implementation classes for these three types of people, such as the enemies of Water games and the enemies of armor.
19. // This encapsulates the change point. That is to say, the enemy of Water games will always have a knife, but some will have armor and some will not.
20. // That is to say, the knife remains unchanged, and the armor can be changed. For example, the armor is used to describe changes in the other two types. In fact, if it is a real project, more images should be drawn from the change points.
21. // Then we compile the game runtime. Here, we do not rely on implementation classes, but can create a batch of enemies.
22. // Let's start running the game ....
24. Wateractor W = new armorwateractor ();
25. Flyactor F = new normalflyactpolictor ();
26. Roadactor r = new armorroadactor ();
27. // We can see that we instantiate people in the water and people on land as soldiers with armor
29. Gamesystem GM = new gamesystem (W, r, f );
30. GM. rungame ();
32. // Assume that we want to replace people in water and land with people without armor. We only need to give them different instances in some places and do not need to change the dependency GM.
33. Wateractor W1 = new normalwateractor ();
34. Flyactor F1 = new armorflyactpolictor ();
35. Roadactor R1 = new normalroadactor ();
36. // We can see that we instantiate people in the water and people on land as soldiers with armor
38. Gamesystem GM1 = new gamesystem (W1, R1, F1 );
39. Gm1.rungame ();
41. Console. Readline ();
42. }
43. }
45. // Enemies of Water games
46. Abstract class wateractor
47. {
48. // Return your instance. Use the system-provided shortest copy. Note: if there is a reference type, we recommend that you use serialization and deserialization for deep copy.
49. Public wateractor clone ()
50. {
51. Return (wateractor) This. memberwiseclone ();
52. }
54. // Knife attack method
55. Public abstract void knifeattack ();
56. }
58. // Enemies flying in the sky
59. Abstract class flyactor
60. {
61. Public flyactor clone ()
62. {
63. Return (flyactor) This. memberwiseclone ();
64. }
66. // Bomb throwing
67. Public abstract void bombattack ();
68. }
71. // Enemies walking on the ground
72. Abstract class roadactor
73. {
74. Public roadactor clone ()
75. {
76. Return (roadactor) This. memberwiseclone ();
77. }
79. // Machine gun Scanning
80. Public abstract void gunattack ();
81. }
83. Class armorwateractor: wateractor
84. {
85. Public override void knifeattack ()
86. {
87. Console. writeline ("% attacked with a knife in armor water ");
88. }
89. }
91. Class normalwateractor: wateractor
92. {
93. Public override void knifeattack ()
94. {
95. Console. writeline ("% no enemy in armor water attacked with a knife ");
96. }
97. }
99. Class armorflyactoractor: flyactor
100. {
101. Public override void bombattack ()
102. {
103. Console. writeline ("### air enemies with armor ");
104. }
105. }
107. Class normalflyactoractor: flyactor
108. {
109. Public override void bombattack ()
110. {
111. Console. writeline ("############## no armor, air enemies, throwing bombs ");
112. }
113. }
115. Class armorroadactor: roadactor
116. {
117. Public override void gunattack ()
118. {
119. Console. writeline ("@ target land enemies with armor scan with machine guns ");
120. }
121. }
123. Class normalroadactor: roadactor
124. {
125. Public override void gunattack ()
126. {
127. Console. writeline ("@ no armor on land enemies use machine guns to scan ");
128. }
129. }
131. Class gamesystem
132. {
133. Private wateractor wactor;
134. Private roadactor ractor;
135. Private flyactor factor;
137. Public gamesystem (wateractor wactor, roadactor ractor, flyactor factor)
138. {
139. This. wactor = wactor;
140. This. ractor = ractor;
141. This. Factor = factor;
142. }
144. Public void rungame ()
145. {
146. Wateractor W1 = This. wactor. Clone ();
147. Wateractor W2 = This. wactor. Clone ();
148. Wateractor W3 = This. wactor. Clone ();
149. Wateractor W4 = This. wactor. Clone ();
150. Wateractor W5 = This. wactor. Clone ();
152. // Here, we don't care at all. The subclass has armor or armor .. Whether you have armor or not, attack ..
153. W1.knifeattack ();
154. W2.knifeattack ();
155. W3.knifeattack ();
156. W4.knifeattack ();
157. W5.knifeattack ();
159. Flyactor F1 = This. factor. Clone ();
160. Flyactor F2 = This. factor. Clone ();
161. Flyactor F3 = This. factor. Clone ();
162. Flyactor F4 = This. factor. Clone ();
164. F1.bombattack ();
165. F2.bombattack ();
166. F3.bombattack ();
167. F4.bombattack ();
169. Roadactor R1 = This. ractor. Clone ();
170. Roadactor r2 = This. ractor. Clone ();
171. Roadactor R3 = This. ractor. Clone ();
172. Roadactor r4 = This. ractor. Clone ();
173. Roadactor R5 = This. ractor. Clone ();
175. R1.gunattack ();
176. R2.gunattack ();
177. R3.gunattack ();
178. R4.gunattack ();
179. R5.gunattack ();
180. }
181. }
182. }