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.

The reader is supposed to have worked with at least a project with the .NET platform using C# as the primary programming language. A good understanding of basic object oriented programming will help you navigate the territory faster. From a software perspective, a laptop, desktop or a virtual machine with Visual Studio 2012 (or above) to test and play around with the source code.

The book is useful for any C#/.NET developer to understand how enterprise class applications are designed, developed, and deployed. Rather than studying various patterns in isolation, the book deals with scenarios where patterns are often combined to engineer state of the art applications. Developers who work with Java can also follow the book without much difficulty, as both platforms have lot of things in common.

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "An instance of this class needs to be passed to the Sort routine of the List<T> instance."

A block of code is set as follows:

    class Employee 
    { 
        public String name {get;set;} 
        public int age {get;set;} 
        public double salary { get; set; } 
    }

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

    return function () { 
      try { 
        return fn.apply(null, args.slice(1)); 
      }

Any command-line input or output is written as follows:

npm install rx

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: "You could simply do this in JSbin by using the Add library option shown in the web editor."

Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of. To send us general feedback, simply e-mail [email protected], and mention the book's title in the subject of your message. If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.