Book Overview & Buying
Table Of Contents
Feedback & Rating

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

By : Gaurav Aroraa, Chilberto

2.8 (5)

Buy this Book

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

2.8 (5)

By: Gaurav Aroraa, Chilberto

Buy this Book

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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Section 1: Essentials of Design Patterns in C# and .NET Core

Overview of OOP in .NET Core and C#

Technical requirements

OOP and how classes and objects work

Inheritance

Encapsulation

Polymorphism

Summary

Questions

Modern Software Design Patterns and Principles

Technical requirements

Design principles

Software patterns

Software development life cycle patterns

Summary

Questions

Section 2: Deep Dive into Utilities and Patterns in .NET Core

Implementing Design Patterns - Basics Part 1

Technical requirements

Minimum Viable Product

Test-driven development

Abstract Factory design pattern

SOLID principles

Summary

Questions

Implementing Design Patterns - Basics Part 2

Technical requirements

The singleton pattern

The factory pattern

Features in .NET Core

Console application

Summary

Questions

Implementing Design Patterns - .NET Core

Technical requirements

.Net Core service lifetimes

Implementation factory

Summary

Questions

Implementing Design Patterns for Web Applications - Part 1

Technical requirements

Creating a .Net Core web application

Implementing CRUD pages

Summary

Questions

Further reading

Implementing Design Patterns for Web Applications - Part 2

Technical requirements

Extending the .NET Core web application

Authentication and authorization

Summary

Questions

Further reading

Section 3: Functional Programming, Reactive Programming, and Coding for the Cloud

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

Functional Programming Practices

Technical requirements

Understanding functional programming

Enhancing our inventory application

Strategy pattern and functional programming

Summary

Questions

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

Advanced Database Design and Application Techniques

Technical requirements

Use case discussion

Database discussion

Database processing

Implementing the CQRS pattern

Summary

Questions

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

Miscellaneous Best Practices

Technical requirements

Use case discussion

Best practices

Other design patterns

Summary

Questions

Further reading

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

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

2.8 (5)

5 star

40%

4 star

3 star

2 star

20%

1 star

40%

Understanding functional programming

In simple terms, functional programming is an approach to symbolic computation that is done in the same way as solving mathematical problems. Any functional programming is based on mathematical functions and its coding style. Any language that supports functional programming works for solutions for the following two questions:

What does it need to solve?
How does it solve it?

Functional programming is not a new invention. This language has existed in the industry for a long time. The following are some well-known programming languages that support functional programming:

Haskell
Scala
Erlang
Clojure
Lisp
OCaml

In 2005, Microsoft released the first version of F# (pronounced EffSharp—https://fsharp.org/). This is a functional programming language that has a lot of good features that any functional programming should have. In this...