Real-World Implementation of C# Design Patterns: Overcome daily programming challenges using elements of reusable object-oriented software

I might be a little biased though.

This is a fantastic book if you want to know more about C# coding. Van Horn really knows his stuff. Wish I had this a year ago when I was just starting out. Not only does he explain design patterns in a practical down to earth way, but he has been able to grasp my attention and keep me awake. Unlike like most textbooks that are dry and tedious to read, Van Horn presents the subject matter using a fun real-world story about a fictional business facing real world challenges. I would recommend this book to anyone who wants to know more about design patterns and have fun doing it.

The author appears to attempt a blend similar to what "The Phoenix Project" or "The Unicorn Project" achieved, but unfortunately falls short. In those books, the narrative style serves as an engaging vehicle for technical content, whereas this book is intended to be a straightforward technical guide. Instead, the inclusion of two-page stories between diagrams and implementations disrupts the focus and detracts from the core material. This approach makes it difficult to maintain concentration and undermines the book's effectiveness as a technical resource.Too many metaphors which make it complex to get the idea straight forward.

This has to be one of the most instructive works on design patterns I have seen in a while. If your code lacks structure, you struggle with implementation, and your throwaway code keeps increasing, “Real-World Implementation of C# Design Patterns” (Packt) by Bruce M. Van Horn II should move to the top of your list. The book works through a fictional story about sisters running a bike factory to pair software patterns to real-world manufacturing instances, making both the code and the implementation clear in every case. The first section covers common mistakes and an approach to C#, while the next section builds through implementing those patterns. Finally, the last two appendices, one on Unified Modelling Language (UML) and one on C# basics, are well worth the admission cost. Van Horn starts with anti-patterns using the terms stovepipe, ball of mud, and golden hammer. All developers have run across these instances, but they are extensively detailed. Stovepipes detail a single approach to reach coding goals, a ball of mud is randomly adding code until works correctly, and a golden hammer shows when a single approach appears for all solutions. Each can impede code and prevent success. These are then paired with spaghetti, lasagna, and ravioli terms for code in the next chapter. Spaghetti code is the typical approach to throwing everything in the bowl and being done. Lasagna shows the extensive use of layers to prevent different items from interacting in a non-desired fashion. Finally, ravioli moves to almost a container fashion, where each coding element is held separate but can be orchestrated through a common sauce. The next section shows creational, structural and behavioral patterns in some detail. These patterns are some of those originated by the original Gang of Four documentation but each is presented within the bicycle factory fictional construct. Along the way, each gets referenced by how well they meet the traditional SOLID basis for software architecture. If you haven’t looked at SOLID, it stands for single responsibility, open-closed, Liskov substitution, Interface segregation, and dependency inversion. Even if you regularly meet those goals in your own programming, this can provide some useful insight into making those achievements even more effective. Finally, in the words of Monty Python, the third part offers something completely different. This section becomes an entirely requirements-focused discussion using UML to show how one can model code and potential patterns before ever touching a keyboard. More coders using this approach would likely be beneficial to the industry as a whole. However, it doesn’t stop with just the modeling as the following chapter describes a step-by-step how to in putting all those code elements into your program. The conversion to one to the other is an outstanding critical thinking exercise in structuring an approach and then making it work. In the last chapter, the author shows the patterns he skipped, explains when each might be used, and offers a lesson in building one’s own patterns. Normally, I would skip the appendices but not in this case. Most programming books open with a syntax and language discussion. While useful for new programmers, for those with some experience, this can often derail the entire book. Putting this section at the end allows easy reference if you need it but allows the reader to focus on the meat of implementing various patterns. The second appendix then walks through using UML to assist your coding. If you haven’t used UML, you probably have seen it in project diagrams and it is always worth going back to those basics. After all, the clearer the model, the more efficient your programming will be. All in all, “Real World Implementation of C# Design Patterns” by Bruce Van Horn II is a must-have for your desk reference. This is the best book on design patterns I have seen in a while. While the title says C#, and the author focuses on that code, with some minor syntax changes, it could just as easily be used for a variety of languages such as Java, Python, Go, Ruby, or a variety of others. If you do any type of extensive programming, I would move this book to the top of your reading list.

The software development world tips its collective hat to the Gang of Four (GoF) for the introduction of design patterns in 1994. Those patterns are still the basis for modern programming. The book twice uses the GoF phrase to indicate it is the focus of the book. However, the categorization and naming conventions are lost. I understand the approach to add personal vignettes and real-world analogies (e.g., a wrench), but it results in excessive content for those wanting to get their hands on C# code and learn to implement the GoF design patterns.For those that appreciate the author’s approach, the book does a great job of contextualizing design patterns and providing sample code. If you are not seasoned software developer, this book offers a nice way to understand OOP design patterns and how to implement them.