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.
"synopsis" may belong to another edition of this title.
Long ago (1995), four object-orientation specialists came out with a book called Design Patterns. In it, the four--whose book became so famous that they became known as the Gang of Four--forwarded a convincing argument that most programming jobs fell into a couple of dozen general categories, and that generic solutions to these programming problems--design patterns--could carry the day a lot of the time. The book remains part of the Holy Writ of object orientation, and indeed if you study it carefully you can save yourself from having to reinvent the wheel every time you set about writing software.
Not long ago (2003), Microsoft came out with a new programming language called C#. It's object oriented, and does lots of nifty stuff with networks. Design Patterns in C# shows you how to implement the 23 "Gang of Four" design patterns in this new language. Steven Metsker's approach is mostly architectural, with lots of object relationship diagrams and relatively little code. He says right up front: "This book is for developers who know C# and want to improve their skills as designers." Among the most valuable parts of his coverage are his comparisons of similar patterns. These clarify, for example, when to use a Builder pattern, as opposed to a Factory or Abstract Factory. The approach helps you become a good C# architect. --David Wall
Topics covered: How to implement the 23 classic Gamma-Helm-Johnson-Vlissides design patterns in C#. Questions scattered throughout the text help you improve your C# skills while you read about pattern architecture.From the Back Cover:
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:
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.
"About this title" may belong to another edition of this title.
Book Description Book Condition: New. Brand new copy. Ships fast secure, expedited available!. Bookseller Inventory # 3UBDHI000006
Book Description Addison-Wesley Professional, 2004. Book Condition: New. Brand New, Unread Copy in Perfect Condition. A+ Customer Service! Summary: Preface. 1. Introduction.Why Patterns? Why Design Patterns? Why C#? UML. Challenges. The Organization of this Book. Welcome to Oozinoz! Summary.I. INTERFACE PATTERNS. 2. Introducing Interfaces.Interfaces and Abstract Classes. Interfaces and Delegates. Interfaces and Properties. Interface Details. Summary. Beyond Ordinary Interfaces.3. Adapter.Adapting to an Interface. Class and Object Adapters. Adapting Data in .NET. Summary.4. Facade.An Ordinary Facade. Refactoring to Facade. Facades, Utilities, and Demos. Summary.5. Composite.An Ordinary Composite. Recursive Behavior in Composites. Composites, Trees, and Cycles. Composites with Cycles. Consequences of Cycles. Summary.6. Bridge.An Ordinary Abstraction. From Abstraction to Bridge. Drivers as Bridges. Database Drivers. Summary.II. RESPONSIBILITY PATTERNS. 7. Introducing Responsibility.Ordinary Responsibility. Controlling Responsibility with Accessibility. Summary. Beyond Ordinary Responsibility.8. Singleton.Singleton Mechanics. Singletons and Threads. Recognizing Singleton. Summary.9. Observer.C# Support for Observer. Delegate Mechanics. A Classic Example-Observer in GUIs. Model/View/Controller. Layering. Summary.10. Mediator.A Classic Example-GUI Mediators. Relational Integrity Mediators. Summary.11. Proxy.A Simple Proxy. A Data Proxy. Remote Proxies. Summary.12. Chain of Responsibility.An Ordinary Chain of Responsibility. Refactoring to Chain of Responsibility. Anchoring a Chain. Chain of Responsibility without Composite. Summary.13. Flyweight.Immutability. Extracting the Immutable Part of a Flyweight. Sharing Flyweights. Summary.III. CONSTRUCTION PATTERNS. 14. Introducing Construction.A Few Construction Challenges. Summary. Beyond Ordinary Construction.15. Builder.An Ordinary Builder. Building under Constraints. A Forgiving Builder. Summary.16. Factory Method.A Classic Example-Enumerators. Recognizing Factory Method. Taking Control of Which Class to Instantiate. Factory Method in Parallel Hierarchies. Summary.17. Abstract Factory.A Classic Example-GUI Kits. Abstract Factories and Factory Method. Namespaces and Abstract Factories. Summary.18. Prototype.Prototypes as Factories. Prototyping with Clones. Summary.19. Memento.A Classic Example-Using Memento for Undo. Memento Durability. Persisting Mementos across Sessions. Summary.IV. OPERATION PATTERNS. 20. Introducing Operations.Operations and Methods. Signatures. Delegates. Exceptions. Algorithms and Polymorphism. Summary. Beyond Ordinary Operations.21. Template Method.A Classic Example-Sorting. Completing an Algorithm. Template Method Hooks. Refactoring to Template Method. Summary.22. State.Modeling States. Refactoring to State. Making States Constant. Summary.23. Strategy.Modeling Strategies. Refactoring to Strategy. Comparing Strategy and State. Comparing Strategy and Template Method. Summary.24. Command.A Classic Example-Menu Commands. Using Command to Supply a Service. Command Hooks. Command in Relation to Other Patterns. Summary.25. Interpreter.An Interpreter Example. Interpreters, Languages, and Parsers. Summary.V. EXTENSION PATTERNS. 26. Introducing Extensions.Principles of OO Design. The Liskov Substitution Principle. The Law of Demeter. Remov. Bookseller Inventory # ABE_book_new_0321126971
Book Description Addison-Wesley Professional, 2004. Hardcover. Book Condition: New. book. Bookseller Inventory # 0321126971
Book Description Book Condition: Brand New. Book Condition: Brand New. Bookseller Inventory # 97803211269791.0
Book Description Lebanon, Indiana, U.S.A., 2004. Hardcover. Book Condition: New. Hardcover, covers as new with sharp corners, pages clean and unmarked, tight binding as unread (clean page edge). ¿ Shipped in a padded envelope and packaged in bubble wrap. Bookseller Inventory # 010612
Book Description Addison-Wesley Professional, 2004. Hardcover. Book Condition: New. Bookseller Inventory # P110321126971
Book Description Addison-Wesley Professional. Hardcover. Book Condition: New. 0321126971 New Condition. Bookseller Inventory # NEW4.0147983