الگوهای طراحی در C♯

Explains how to use C# as an object-oriented language, using design patterns to create clean code while taking advantage of the extensive Microsoft[registered] .NET Framework Class Libraries. This book offers detailed code examples utilizing C# and the .NET Framework - as well as programming exercises crafted to help you build expertise. Cover......Page 1 Contents......Page 10 Preface......Page 18 Why Patterns?......Page 19 Why Design Patterns?......Page 20 UML......Page 21 The Organization of this Book......Page 22 Summary......Page 24 Part 1: Interface Patterns......Page 26 Interfaces and Abstract Classes......Page 27 Interfaces and Delegates......Page 28 Interfaces and Properties......Page 32 Interface Details......Page 33 Summary......Page 34 Beyond Ordinary Interfaces......Page 35 Adapting to an Interface......Page 37 Class and Object Adapters......Page 42 Adapting Data in .NET......Page 46 Summary......Page 51 An Ordinary Facade......Page 53 Refactoring to Facade......Page 56 Facades, Utilities, and Demos......Page 64 Summary......Page 66 An Ordinary Composite......Page 67 Recursive Behavior in Composites......Page 68 Composites, Trees, and Cycles......Page 71 Composites with Cycles......Page 76 Consequences of Cycles......Page 80 Summary......Page 81 An Ordinary Abstraction......Page 83 From Abstraction to Bridge......Page 86 Drivers as Bridges......Page 88 Summary......Page 89 Part 2: Responsibility Patterns......Page 92 Ordinary Responsibility......Page 93 Controlling Responsibility with Accessibility......Page 95 Summary......Page 98 Beyond Ordinary Responsibility......Page 99 Singleton Mechanics......Page 101 Singletons and Threads......Page 102 Recognizing Singleton......Page 104 Summary......Page 105 C# Support for Observer......Page 107 Delegate Mechanics......Page 108 A Classic Example—Observer in GUIs......Page 112 Model/View/Controller......Page 119 Layering......Page 121 Summary......Page 126 A Classic Example—GUI Mediators......Page 127 Relational Integrity Mediators......Page 132 Summary......Page 139 A Simple Proxy......Page 141 A Data Proxy......Page 145 Remote Proxies......Page 150 Summary......Page 155 An Ordinary Chain of Responsibility......Page 157 Refactoring to Chain of Responsibility......Page 159 Anchoring a Chain......Page 162 Summary......Page 164 Immutability......Page 165 Extracting the Immutable Part of a Flyweight......Page 166 Sharing Flyweights......Page 168 Summary......Page 171 Part 3: Construction Patterns......Page 173 A Few Construction Challenges......Page 175 Beyond Ordinary Construction......Page 178 An Ordinary Builder......Page 181 Building under Constraints......Page 184 A Forgiving Builder......Page 186 Summary......Page 187 A Classic Example—Enumerators......Page 189 Recognizing Factory Method......Page 191 Taking Control of Which Class to Instantiate......Page 192 Factory Method in Parallel Hierarchies......Page 194 Summary......Page 196 A Classic Example—GUI Kits......Page 197 Abstract Factories and Factory Method......Page 203 Namespaces and Abstract Factories......Page 207 Summary......Page 208 Prototypes as Factories......Page 209 Prototyping with Clones......Page 211 Summary......Page 214 A Classic Example—Using Memento for Undo......Page 215 Persisting Mementos across Sessions......Page 224 Summary......Page 227 Part 4: Operation Patterns......Page 229 Operations and Methods......Page 231 Signatures......Page 233 Delegates......Page 234 Exceptions......Page 235 Algorithms and Polymorphism......Page 236 Summary......Page 238 Beyond Ordinary Operations......Page 239 A Classic Example—Sorting......Page 241 Completing an Algorithm......Page 244 Template Method Hooks......Page 247 Refactoring to Template Method......Page 248 Summary......Page 250 Modeling States......Page 253 Refactoring to State......Page 257 Making States Constant......Page 262 Summary......Page 264 Modeling Strategies......Page 265 Refactoring to Strategy......Page 268 Comparing Strategy and State......Page 273 Summary......Page 274 A Classic Example—Menu Commands......Page 275 Using Command to Supply a Service......Page 277 Command Hooks......Page 279 Command in Relation to Other Patterns......Page 281 Summary......Page 282 An Interpreter Example......Page 285 Interpreters, Languages, and Parsers......Page 297 Summary......Page 298 Part 5: Extension Patterns......Page 300 Principles of OO Design......Page 301 The Liskov Substitution Principle......Page 302 The Law of Demeter......Page 303 Removing Code Smells......Page 304 Beyond Ordinary Extensions......Page 305 Summary......Page 307 A Classic Example—Streams......Page 309 Function Wrappers......Page 318 Decorator in GUIs......Page 326 Summary......Page 327 Thread-Safe Iteration......Page 329 Iterating over a Composite......Page 334 Summary......Page 345 Visitor Mechanics......Page 347 An Ordinary Visitor......Page 349 Visitor Cycles......Page 355 Visitor Controversy......Page 359 Summary......Page 360 Get the Most Out of This Book......Page 361 Weave Patterns into Your Code......Page 362 Keep Learning......Page 363 Appendix B: Solutions......Page 365 Building the Oozinoz Code......Page 435 Helping the Oozinoz Code Find Files......Page 436 Finding Files Yourself......Page 437 Summary......Page 438 Appendix D: UML at a Glance......Page 439 Classes......Page 440 Class Relationships......Page 442 Interfaces......Page 443 Delegates and Events......Page 445 Objects......Page 446 States......Page 447 C......Page 449 E......Page 450 I......Page 451 M......Page 452 P......Page 453 S......Page 454 W......Page 455 Bibliography......Page 457 A......Page 459 C......Page 460 D......Page 462 E......Page 463 G......Page 464 I......Page 465 M......Page 466 N......Page 467 O......Page 468 P......Page 469 R......Page 470 S......Page 471 T......Page 472 U......Page 473 X......Page 474 Steven John Metsker explains how to use C# as an object-oriented language, using design patterns to create clean code while taking advantage of the extensive Microsoft(R) .NET Framework Class Libraries. For all 23 classic "Gang of Four" design patterns, Metsker offers detailed code examples utilizing C# and the .NET Framework--as well as programming exercises crafted to help you rapidly build expertise. His exercises and explanations make extensive use of the Unified Modeling Language, helping you build your skills in this standard notation. Design patterns covered include: Interfaces: Adapter, Facade, Composite, and Bridge Responsibility: Singleton, Observer, Mediator, Proxy, Chain of Responsibility, and Flyweight Construction: Builder, Factory Method, Abstract Factory, Prototype, and Memento Extensions: Decorator, Iterator, and Visitor If you've already used design patterns in other languages, Design Patterns in C# will deepen your understanding, build your confidence, and help you apply them to any C# project. If you're a Microsoft programmer who's new to design patterns, this book will be an ideal practical introduction. www.awprofessional.com/patterns/ ADDISON-WESLEY PROFESSIONAL Pearson Education ISBN: 0-321-12697-1 Ch. 1. Introduction -- Pt. 1. Interface Patterns -- Ch. 2. Introducing Interfaces -- Ch. 3. Adapter -- Ch. 4. Facade -- Ch. 5. Composite -- Ch. 6. Bridge -- Pt. 2. Responsibility Patterns -- Ch. 7. Introducing Responsibility -- Ch. 8. Singleton -- Ch. 9. Observer -- Ch. 10. Mediator -- Ch. 11. Proxy -- Ch. 12. Chain Of Responsibility -- Ch. 13. Flyweight -- Pt. 3. Construction Patterns -- Ch. 14. Introducing Construction -- Ch. 15. Builder -- Ch. 16. Factory Method -- Ch. 17. Abstract Factory -- Ch. 18. Prototype -- Ch. 19. Memento -- Pt. 4. Operation Patterns -- Ch. 20. Introducing Operations -- Ch. 21. Template Method -- Ch. 22. State -- Ch. 23. Strategy -- Ch. 24. Command -- Ch. 25. Interpreter -- Pt. 5. Extension Patterns -- Ch. 26. Introducing Extensions -- Ch. 27. Decorator -- Ch. 28. Iterator -- Ch. 29. Visitor -- App. C. Oozinoz Source -- App. D. Uml At A Glance. Steven John Metsker. Includes Bibliographical References (p. 439-440) And Index. This book is an application book, rather than a theoretical one. It is written for software practitioners who want to gain a better understanding of the patterns described in the seminal design patterns book by Gamma et al. The book's intent is to give developers the confidence and know-how to apply the original 23 patterns identified in the Gamma book, with all code examples provided in C#. There are a large number of programmers and designers who have "grown up" in the Microsoft environment. Traditionally, this environment has not placed an emphasis on structured approaches to software engineering (such as patterns), but there is a growing sentiment toward applying proven approaches to application development (such as design patterns) in this environment. For this reason, the timing for this new book from patterns expert Steve Metsker is superb. Metsker explains how to use C# as an object-oriented language, using design patterns to create clean code while taking advantage of the extensive Microsoft( .NET Framework Class Libraries. For all 23 classic "Gang of Four" design patterns, Metsker offers detailed code examples utilizing C# and the .NET Framework--as well as programming exercises crafted to help programmers rapidly build expertise Designed patterns help developers leverage the wisdom of the entire software community to build more robust, higher-quality software. [In this volume, the author] explains how to use C# as an object-oriented language, using design patterns to create clean code while taking advantage of the extensive Microsoft.NET Framework class Libraries.-Back cover