An Atypical ASP.NET Core 5 Design Patterns Guide

A SOLID adventure into architectural principles, design patterns, .NET 5, and C#

Carl-Hugo Marcotte 지음

Packt(GCO Science) 2020년 12월 31일 출간

작품소개

책소개

A .NET developer's guide to crafting robust, maintainable, and flexible web apps by leveraging C# 9 and .NET 5 features and component-scale and application-scale design patterns

▶What You Will Learn
？Apply the SOLID principles for building flexible and maintainable software
？Get to grips with .NET 5 dependency injection
？Work with GoF design patterns such as strategy, decorator, and composite
？Explore the MVC patterns for designing web APIs and web applications using Razor
？Discover layering techniques and tenets of clean architecture
？Become familiar with CQRS and vertical slice architecture as an alternative to layering
？Understand microservices, what they are, and what they are not
？Build ASP.NET UI from server-side to client-side Blazor

▶Key Features
？Apply software design patterns effectively, starting small and progressing to cloud-scale
？Discover modern application architectures such as vertical slice, clean architecture, and event-driven microservices
？Explore ASP.NET design patterns, from options to full-stack web development using Blazor

▶Who This Book Is For
This design patterns book is for intermediate-level software and web developers with some knowledge of .NET who want to write flexible, maintainable, and robust code for building scalable web applications. Knowledge of C# programming and an understanding of web concepts like HTTP is necessary.

목차

▶TABLE of CONTENTS
▷ Section 1: Principles and Methodologies
？Chapter 1: Introduction to .NET
？Chapter 2: Testing Your ASP.NET Core Application
？Chapter 3: Architectural Principles

▷ Section 2: Designing for ASP.NET Core
？Chapter 4: The MVC Pattern using Razor
？Chapter 5: The MVC Pattern for Web APIs
？Chapter 6: Understanding the Strategy, Abstract Factory, and Singleton Design Patterns
？Chapter 7: Deep Dive into Dependency Injection
？Chapter 8: Options and Logging Patterns

▷ Section 3: Designing at Component Scale
？Chapter 9: Structural Patterns
？Chapter 10: Behavioral Patterns
？Chapter 11: Understanding the Operation Result Design Pattern

▷ Section 4: Designing at Application Scale
？Chapter 12: Understanding Layering
？Chapter 13: Getting Started with Object Mappers
？Chapter 14: Mediator and CQRS Design Patterns
？Chapter 15: Getting Started with Vertical Slice Architecture
？Chapter 16: Introduction to Microservices Architecture

▷ Section 5: Designing the Client Side
？Chapter 17: ASP.NET Core User Interfaces
？Chapter 18: A Brief Look into Blazor
Assessment Answers

책 속으로

▶What this book covers
▷ Section 1, Principles and Methodologies
This section contains the book's foundations: an overview of unit testing and xUnit, the SOLID principles, and some theory and examples on how to design software.

？ Chapter 1, Introduction to .NET, contains the prerequisites and an explanation of how the book works as well as a few important topics that will be useful to a software developer.

？ Chapter 2, Testing Your ASP.NET Core Application, introduces you to the basics of unit testing and the xUnit testing framework as well as to some good practices and methodologies to help write unit tests.

？ Chapter 3, Architectural Principles, lays the architectural ground with crucial principles used throughout the book and extremely important to any engineer trying to write "SOLID code."

▷ Section 2, Designing for ASP.NET Core
This section introduces ASP.NET Core-specific subjects, including Model-View-Controller (MVC), View Models, DTOs, and a few classic design patterns. We also deep dive into dependency injection and explore the evolved usage of certain patterns in ASP.NET Core as pillars of modern software engineering.

？ Chapter 4, The MVC Pattern using Razor, introduces you to the Model-View-Controller and the View Model design patterns to render views using Razor and ASP.NET Core MVC.

？ Chapter 5, The MVC Pattern for Web APIs, takes you further on the ASP.NET Core MVC journey, focusing on web APIs. We explore the Data Transfer Object (DTO) pattern and API contracts.

？ Chapter 6, Understanding the Strategy, Abstract Factory, and Singleton Design Patterns, introduces you to the traditional implementation of three basic Gang of Four (GoF) design patterns: Strategy, Abstract Factory, and Singleton.

？ Chapter 7, Deep Dive into Dependency Injection, takes the ASP.NET Core dependency injection container for a ride, introducing you to one of the most important aspects of modern software development. This chapter connects ASP.NET Core and the SOLID principles. Once the basics of dependency injection are laid out, we review the previous three GoF design patterns and revisit them using dependency injection, opening the way to build testable, flexible, and reliable software.

？ Chapter 8, Options and Logging Patterns, takes ASP.NET Core-related subjects and digs into them. We cover different options patterns and the abstraction provided to us. We also explore how to leverage logging in .NET 5.

▷ Section 3, Designing at Component Scale
This section focuses on component design, where we study how an individual piece of software can be crafted to achieve a particular goal. We explore a few more GoF patterns that should help us design SOLID data structures and components as well as simplifying the complexity of our code by encapsulating our logic in smaller units.

？ Chapter 9, Structural Patterns, introduces you to four new GoF structural design patterns and a few variants, such as transparent fa？ades and opaque fa？ades. It also introduces you to Scrutor, an open source project that adds support for the dependency injection of decorators.

？ Chapter 10, Behavioral Patterns, introduces two GoF behavioral design patterns and concludes by mixing them together as a final improvement on the code sample's design.

？ Chapter 11, Understanding the Operation Result Design Pattern, covers multiple variants of the Operation Result design pattern, structuring a result object to carry more than a simple result.

▷ Section 4, Designing at Application Scale
This section takes a step forward, leading toward application design and introducing layering, vertical slices, and microservices. We overview each technique making sure you know how to get started. We also cover different component-level patterns that help put those architectural styles together.
...

출판사 서평

▶ Preface
Design patterns are a set of solutions to many of the common problems occurring in software development. Knowledge of these design patterns helps developers and professionals to craft software solutions of any scale.

ASP.NET Core 5 Design Patterns starts by exploring basic design patterns, architectural principles, dependency injection, and other ASP.NET Core mechanisms. You'll explore the component scale as you discover patterns oriented toward small chunks of the software, and then move to application-scale patterns and techniques to understand higher-level patterns and how to structure the application as a whole. The book covers a range of significant GoF (Gangs of Four) design patterns such as strategy, singleton, decorator, facade, and composite. The chapters are organized based on scale and topics, allowing you to start small and build on a strong base, the same way that you would develop a program. With the help of use cases, the book will show you how to combine design patterns to display alternate usage and help you feel comfortable working with a variety of design patterns. Finally, you'll advance to the client side to connect the dots and make ASP.NET Core a viable full-stack alternative.

By the end of the book, you'll be able to mix and match design patterns and have learned how to think about architecture and how it works.

작가정보

저자(글) Carl-Hugo Marcotte

Carl-Hugo Marcotte is a senior .NET developer working as an independent consultant out of Ottawa, Canada. Having written his first line of code at about eight years old, he has grown to be an expert on Software Architecture, C#, Asp.Net, Asp.Net Core, Agile Methodologies, Azure and Cloud. Since the beginning of his career, he developed projects of different sizes; mostly for enterprises. Knowledge is what drives him which led him to teach part-time computer programming to adults going back to school; leading to fruitful second chances for some! He is also an active blogger which he sees as another effective way of sharing his skills and code with the world.