Book Image

Hands-On Design Patterns with C# and .NET Core

By : Gaurav Aroraa, Jeffrey Chilberto
Book Image

Hands-On Design Patterns with C# and .NET Core

By: Gaurav Aroraa, Jeffrey Chilberto

Overview of this book

Design patterns are essentially reusable solutions to common programming problems. When used correctly, they meet crucial software requirements with ease and reduce costs. This book will uncover effective ways to use design patterns and demonstrate their implementation with executable code specific to both C# and .NET Core. Hands-On Design Patterns with C# and .NET Core begins with an overview of object-oriented programming (OOP) and SOLID principles. It provides an in-depth explanation of the Gang of Four (GoF) design patterns, including creational, structural, and behavioral. The book then takes you through functional, reactive, and concurrent patterns, helping you write better code with streams, threads, and coroutines. Toward the end of the book, you’ll learn about the latest trends in architecture, exploring design patterns for microservices, serverless, and cloud native applications. You’ll even understand the considerations that need to be taken into account when choosing between different architectures such as microservices and MVC. By the end of the book, you will be able to write efficient and clear code and be comfortable working on scalable and maintainable projects of any size.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Design Patterns with C# and .NET Core
Gaurav Aroraa | Jeffrey Chilberto
Jul, 2019 | 410 pages
Small book image
Hands-On Microservices with C# 8 and .NET Core 3
Ed Price | Gaurav Aroraa
Mar, 2020 | 474 pages
Small book image
Building Microservices with .NET Core 2.0
Gaurav Aroraa
Dec, 2017 | 300 pages
Small book image
Learn C# in 7 days
Gaurav Aroraa
Oct, 2017 | 306 pages
Table of Contents (19 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Section 1: Essentials of Design Patterns in C# and .NET Core
Section 1: Essentials of Design Patterns in C# and .NET Core
2
Overview of OOP in .NET Core and C#
Overview of OOP in .NET Core and C#
Technical requirements
OOP and how classes and objects work
Inheritance
Encapsulation
Polymorphism
Summary
Questions
3
Modern Software Design Patterns and Principles
Modern Software Design Patterns and Principles
Technical requirements
Design principles
Software patterns
Software development life cycle patterns
Summary
Questions
4
Section 2: Deep Dive into Utilities and Patterns in .NET Core
Section 2: Deep Dive into Utilities and Patterns in .NET Core
5
Implementing Design Patterns - Basics Part 1
Implementing Design Patterns - Basics Part 1
Technical requirements
Minimum Viable Product
Test-driven development
Abstract Factory design pattern
SOLID principles
Summary
Questions
6
Implementing Design Patterns - Basics Part 2
Implementing Design Patterns - Basics Part 2
Technical requirements
The singleton pattern
The factory pattern
Features in .NET Core
Console application
Summary
Questions
7
Implementing Design Patterns - .NET Core
Implementing Design Patterns - .NET Core
Technical requirements
.Net Core service lifetimes
Implementation factory
Summary
Questions
8
Implementing Design Patterns for Web Applications - Part 1
Implementing Design Patterns for Web Applications - Part 1
Technical requirements
Creating a .Net Core web application
Implementing CRUD pages
Summary
Questions
Further reading
9
Implementing Design Patterns for Web Applications - Part 2
Implementing Design Patterns for Web Applications - Part 2
Technical requirements
Extending the .NET Core web application
Authentication and authorization
Summary
Questions
Further reading
10
Section 3: Functional Programming, Reactive Programming, and Coding for the Cloud
Section 3: Functional Programming, Reactive Programming, and Coding for the Cloud
11
Concurrent Programming in .NET Core
Concurrent Programming in .NET Core
Technical requirements
Concurrency in the real world
Multithreading and asynchronous programming
Async/Await – why is blocking bad?
Concurrent collections
Patterns and practices – TDD and Parallel LINQ
Summary
Questions
Further reading
12
Functional Programming Practices
Functional Programming Practices
Technical requirements
Understanding functional programming
Enhancing our inventory application
Strategy pattern and functional programming
Summary
Questions
13
Reactive Programming Patterns and Techniques
Reactive Programming Patterns and Techniques
Technical requirements
The principles of reactive programming
Reactive and IObservable
Reactive extensions – .NET Rx extensions
Inventory application use case
Patterns and Practices – MVVM
Summary
Questions
Further reading
14
Advanced Database Design and Application Techniques
Advanced Database Design and Application Techniques
Technical requirements
Use case discussion
Database discussion
Database processing
Implementing the CQRS pattern
Summary
Questions
15
Coding for the Cloud
Coding for the Cloud
Technical requirements
Key considerations when building solutions in the cloud
Scalability
Resiliency/availability
Security
Application design
DevOps
Summary
Questions
Further reading
16
Miscellaneous Best Practices
Miscellaneous Best Practices
Technical requirements
Use case discussion
Best practices
Other design patterns
Summary
Questions
Further reading
17
Assessments
Assessments
Chapter 1 – Overview of OOP in .NET Core and C#
Chapter 2 – Modern Software Design Patterns and Principles
Chapter 3 – Implementing Design Patterns – Basics Part 1
Chapter 4 – Implementing Design Patterns – Basics Part 2
Chapter 5 – Implementing Design Patterns – .NET Core
Chapter 6 – Implementing Design Patterns for Web Applications – Part 1
Chapter 7 – Implementing Design Patterns for Web Applications – Part 2
Chapter 8 – Concurrent Programming in .NET Core
Chapter 9 – Functional Programming Practices – an Approach
Chapter 10 – Reactive Programming Patterns and Techniques
Chapter 11 – Advanced Database Design and Application Techniques
Chapter 12 – Coding for the Cloud
Appendix A – Miscellaneous Best Practices
18
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Reactive extensions – .NET Rx extensions

The discussion in the previous session was aimed at reactive programming and the implementation of reactive programming using the IObservable<T> and IObserver<T> interfaces as an observer pattern. In this section, we will extend our learning with the help of Rx Extensions. If you would like to find out more about the development of Rx Extensions, you should follow the official repository at https://github.com/dotnet/reactive.

Please note that Rx Extensions are now merged with the System namespace, and you can find everything in the System.Reactive namespace. If you have experience with Rx Extensions, you should know that the namespace of these extensions has been changed, as follows:

  • Rx.Main has been changed to System.Reactive.
  • Rx.Core has been changed to System.Reactive.Core.
  • Rx.Interfaces has been changed to System...
Previous Section
End of Section 5
Next Section