C# 3.0 Design Patterns: Use the Power of C# 3.0 to Solve Real-World Problems

Lets face it design patterns are something that we have to have but at the same token are usually difficult to understand where it should be used and how to create it. With design patterns C# 3.0 By Judith Bishop we have a little more help. From structural patterns to Behavorial we can all feel a bit better in designing our tiers for robustness and making things just a slight more easier on ourselves. When i had to create a protected class for an application that i was working on. I had difficulty creating protecting it from instantiation with the guidance in this book i was able to complete the application in less time and focus on other areas of code that needed improvements. I also found use for the decorator pattern, while i will admit some patterns in the book seem like a lot of work to include in an application Bishop makes the case for each one and also describes situations where patterns may be become anti pattern for example using the Singleton pattern to hold static information as a global variable. Overall, the quality of this book is top notch (figures since it is a O'reily book) and offers many sections on how to enhance your coding practices to make best of your limited time and also of your program. The examples in the book are superb and offer a introduction to what i feel is one of the more complex ways of designing a program. It also has a fair bit of UML diagrams and is "decent" practical guide to also adhering to UML based designs. Something though i wish they had in this book were more samples, at times there seems to be decent coverage on some of the easier patterns (singleton) and not so much on the more convoluted patterns like Model View Controller. While she does try to create a balanced ground sometimes, i have to re-read the section because she gets to technical sometimes. I guess with time and over the years her thoughts should become more clear. - Mike

I found this book to be a very good treatment of the GOF patterns. The content is well organized and has a very clean feel to it. I think there would be 2 primary audiences. One would be those that have study the GOF patterns, but want to see them implemented with the latest C# functionality available. The other would be those that have never before studied the GOF patterns and want to learn about them. I think both audiences should know the C# 3.0 language and syntax before reading this book, or at least be willing to learn C# 3.0 while reading this book. Although the author claims this is a the book will guide you through the new C# 3.0 language features, they are only really listed. The side bars are enough to send you off looking for the right thing to learn, but you won't learn it with the content in the sidebar. As long as you are willing to go outside the book to learn the new C# 3.0 features, this book will serve to point them out. Each pattern is broken down into 7 parts- Role, Illustration, Design, Implementation, Example, Use, and Exercises. I think the author does a great job at communicating the intention of the patterns. She makes good use of graphics and UML diagrams. She also makes you put some thought into the patterns by offering mini quizzes. The author also has a nice support site which has the code available and a lot of good information about patterns including the UML diagrams from the book. The code is very well organized and is very usable. All in all I think this is a great C# GOF Patterns book and would recommend it to anyone that wants to learn to implement the GOF patterns with the latest C# language features available.

There is a plethora of Design Patterns available but it is often very difficult to make a sound decision on which is the most applicable for a problem scenario, not taking into account the programming language used. A particular Design Pattern, if not applied appropriately, can add unnecessarily to the complexity that already exists in the problem. In C# 3.0 Design Patterns, the author presents 23 commonly used Design Patterns and categorizes them in a well-structured way that I find is precise and easy to follow. Advice is given to aid in the appropriate use of each Design Pattern, while mentioning its limitations. In addition, the Author also explains which Design Patterns can be used to interact with each other. Each Design Pattern is illustrated with UML and implemented with a real-world example where some of these examples are flavored with Web 2.0 concepts. I find the number of lines in the example code is just right and is not too long. I liked the short quiz and coding exercises that this book offers. They helped me to recap on the Design Patterns learnt. The code used in this book is compatible with C# 3.0 and you need to have some experience in using C# as this book does not teach you the basics. Because the official C# language specification is quite tedious to navigate through, the author saves you time by pointing you to the actual section within the specification for further reading on the new C# 3.0 constructs used in the implementation of the examples. Each Design Patterns is nicely tabulated along with the language features to use. A final chapter on the outlook on the future of Design Patterns is quite interesting. I recommend that this lightweight and yet concise book is a definite to have for students and professional developers.

This is a good rehash of the Gang of Four patterns, reworked in C# 3.0. The book's fairly concise and most patterns are clearly laid out with a simplistic example to demonstrate the basics of the patterns followed by a more detailed example in a semi-real world implementation. The articles are nicely done, there are a good set of exercises about each pattern, and there are some good comparisons between similar patterns. As an example, there's a bit comparing the Builder and Abstract Factory which details that a Builder is concerned with how things are built while an Abstract Factory is concerned with what is built. A couple things bothered me in the book, namely the lack of a clear overall summary of patterns, and an annoying batch of sidebars on fairly basic concepts. While each pattern has a summary of when you would use it, you're forced to dig through the entire book looking at each pattern trying to figure out if it will solve a problem for you. A consolidated list of the uses of each pattern at the start or end of the book would have been a great help. Regarding the sidebars: do I need a patterns book to lay out fundamental concepts like accessibility modifiers or indexers? These detract from the book's main purpose, which isn't to teach C# 3.0, but show how patterns are done in C# 3.0. Sidebars specific to a pattern's C# 3.0 intricacies are OK, but the fundamentals should have been left out. Those annoyances aside, I found the book to be a good read and a useful addition to my bookshelf.

This concise, well-organized and clearly written book helps readers understand design patterns -- a architectural concept that has been adapted in recent years to become an invaluable tool for software developers. The engaging and informative illustrations which begin the chapters that discuss each design pattern help relate everyday concepts to the intricacies of software. For example, novice programmers would often make use of Facade patterns; blogs are examples of Observer patterns; and social networking systems such as Facebook are examples of Proxy patterns. Clarity is a crucial quality of this valuable book, which stands out from others on the topic by embracing the most modern programming language features, explained in sidebars with definitive references back to the new C# 3.0 standard. Deploying numerous illustrations, quizzes, diagrams, exercises and tips, Bishop has succeeded in making that standard palatable, in contrast to the indigestible length and density of Microsoft's document.