Writing modern Enterprise software requires large teams that need close co-ordination to deliver quality products and services. The teams require a common language for communication when dealing with technical solutions and artifacts, in order to work as a cohesive unit for meeting the set objective. The GOF design pattern catalog was a major step in this direction. This was followed by other similar catalogs to empower software engineering teams with a common pool of shared idioms and practices. For all practical purpose, GOF patterns became sine qua non for patterns. But there are other equally important catalogs that you would want to leverage.
There have been attempts to map the pattern catalogs to platforms such as JEE and .NET. The J2EE --design patterns and Microsoft--patterns and practices catalogs were attempts in this direction. The emergence and adoption of functional programming and reactive programming models mandates a fresh look at the patterns, applied to modern .NET software development. That is where this book comes into the picture. This book provides detailed examples written using C#/.NET, which will help developers map different constructs from various pattern catalogs to executable code.
The book you have got in your hand outlines author's perspectives about how design, architecture, and domain patterns can be applied in practice by leveraging the .NET platform. The topics covered deals with various patterns and pattern catalogs, including GOF patterns, concurrent programming, object/functional programming, and functional reactive programming. The final chapter talks about materials which we could not cover in this book, but, which a modern programmer should master to become an effective developer.
Learning, as we all know, is a continuous process. We have made to the best of our ability to impart our learnings on the job so that it benefits any one who is interested. We have leveraged code extensively for illustrating this with very detailed examples. Design illustration in the form of UML and context diagrams accompany the concepts and code. The views and perspectives we have outlined mostly align with the industry references and standards.
Chapter 1, An Introduction to Patterns and Pattern Catalogs, deals with the summary of key pattern catalogs and also deals with the evolution of the C# programming language. The chapter deals with the gist of GOF, POSA, DDD, EIP, J2EE, POEAA, and the Arlow and Neustadt pattern catalog.
Chapter 2, Why We Need Design Patterns?, provides the rationale for applying patterns in the context of software engineering. The chapter deals with some foundational principles such as SOLID, KISS, YAGNI, DRY/WET and so on, that lay the foundation for pattern oriented software development. A tax computation engine that uses the factory method pattern, the template method pattern, and design by contract is given as a running example.
Chapter 3, A Logging Library, implements a logging library which can be used in a multithreaded environment. The implementation leverages the template method pattern, the strategy pattern, and the factory method pattern. A custom Dependency Injection framework loads the classes on the fly.
Chapter 4, Targeting Multiple Databases, shows how one can use different persistent technologies (Oracle, SQL Server, SQLite, and so on) without changing a single line of application code. The library leverages ADO.net and uses the abstract factory pattern, the factory pattern, and the adapter pattern.
Chapter 5, Producing Tabular Reports, shows how one can create a canonical object model based on the composite pattern and traverse the object model through visitor pattern to generate HTML and PDF documents.
Chapter 6, Plotting Mathematical Expressions, deals with a library that uses composite, interpreter, observer, builder, and facade patterns to plot arbitrary mathematical expression on the fly using Windows Presentation Foundation.
Chapter 7, Patterns in the .NET Base Class Library, demonstrates how the designers of .NET base class library has leveraged various GOF patterns to give developers a good programing model.
Chapter 8, Concurrent and Parallel Programming under .NET, steps into the very important topic of concurrent and parallel programming by leveraging constructs provided by the .NET platform. Topics such as concurrency versus parallelism, fork/join parallelism, producer-consumer model, and so on are dealt at depth.
Chapter 9, Functional Programming Techniques for Better State Management, deals with the very important topic of managing state by leveraging closures, lambda, immutability, LINQ and other functional programming techniques.
Chapter 10, Pattern Implementation Using Object/Functional Programming, illustrates Map/Reduce, the template method pattern, the iterator pattern, and the strategy pattern by a judicious mix of functional and object-oriented programming constructs.
Chapter 11, What is Reactive Programming?, gives you the gist of Functional Reactive programming model and its realization on the .NET platform.
Chapter 12, Reactive Programming Using .NET Rx Extensions, carries forward from the previous chapter and shows some concrete examples where Functional Reactive Programming techniques can be put for real world use.
Chapter 13, Reactive Programming Using RxJS, gives a very good introduction to the techniques and internals of RxJS for writing web-based responsive UI.
Chapter 14, A Road Ahead, sheds light on a learning progression path highlighting the importance of polyglot programming, domain-specific languages, ontology, and antipatterns.