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

One of the best books on design patterns.

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.

I was dreading reading a book about Design Patterns but as a long time c# developer, I wanted to up my game, to make sure I was doing things the right way and be able to answer interview questions with a full understanding of patterns and to no longer bluff it.This book is a massively relatable journey and explanation to give you a feel for patterns rather than it being the academic chore that I was expecting. It has real passion for what might have otherwise been a very boring topic and goes above and beyond. I may have been practising some of the aspects such as SOLID principles without knowing it but this cements my full understanding of the terms.

I might be a little biased though.

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.