Clean Architecture with .NET (Developer Reference)

Dino Esposito, "Clean Architecture with .NET (Developer Reference)"Understand what to do at any point in developing a clean .NET architectureMaster advanced .NET techniques with a focus on actual value delivered by working within a modular, clean architecture. Microsoft Data Platform MVP Dino Esposito explains key clean architecture concepts with a mix of pragmatism and design discipline and helps you solidify your knowledge through a real-world project. Starting with an explanation of the quest for modular software architecture continuing through the methodology of domain-driven design (DDD), Esposito emphasizes the role that modularization plays in managing complexity in software development. Breaking down the layers of an architecture that is modular and maintainable, he presents a sample project that is not simply another to-do list, but an actual tool for the reader. Ultimately, an exploration of common dilemmas for both developers and operations brings together historical developments with real solutions for today.Microsoft Data Platform MVP Dino Esposito helps youUnderstand the relevance of modular software architecture in the history of softwareReview domain-driven design concepts both, strategic and practicalApply modular analysis techniques to your developmentMake the most of layered architectureMake the most of layered architecture that is modular and maintainableExplore in detail the individual layerspresentation, application, domain and infrastructureMake sense of domain services to separate raw persistence from persistence-related business tasksMake your way through a series of C# best-practices for modeling classes from real-world entitiesUnderstand the benefits of microservices versus modular monolithsUnderstand the analysis of technical shortcuts and benefits of long-term technical investmentUnderstand client-side, server-side and other common deployment dilemmasSet up your architecture, test your conclusions, and find even more help Cover Title Page Copyright Page Contents at a Glance Contents Acknowledgments Introduction PART I THE HOLY GRAIL OF MODULARITY Chapter 1 The quest for modular software architecture In the beginning, it was three-tier Core facts of a three-tier system Layers, tiers, and modularization The DDD canonical architecture The proposed supporting architecture Adding more to the recipe Different flavors of layers Hexagonal architecture Clean architecture Feature-driven architecture Summary Chapter 2 The ultimate gist of DDD Design driven by the domain Strategic analysis Tactical design DDD misconceptions Tools for strategic design Ubiquitous language A domain-specific language vocabulary Building the glossary Keeping business and code in sync The bounded context Making sense of ambiguity Devising bounded contexts The context map Upstream and downstream An example context map An example deployment map Summary Chapter 3 Laying the ground for modularity Aspects and principles of modularization Separation of concerns Loose coupling Reusability Dependency management Documentation Testability Applying modularization The presentation layer: interacting with the outside world The application layer: processing received commands The domain layer: representing domain entities The data/infrastructure layer: persisting data Achieving modularity More modularity in monoliths Introducing microservices The simplest solution ever Maintainability Designing for testability Summary PART II ARCHITECTURE CLEANUP Chapter 4 The presentation layer Project Renoir: the final destination Introducing the application The abstract context map Designing the physical context map Business requirements engineering Breakdown of software projects Event-based storyboards Fundamental tasks of Project Renoir Boundaries and deployment of the presentation layer Knocking at the web server’s door ASP.NET application endpoints Presentation layer development Connecting to business workflows Front-end and related technologies API-only presentation Summary Chapter 5 The application layer An architectural view of Project Renoir The access control subsystem The document-management subsystem Project Renoir in Visual Studio Task orchestration What is a task, anyway? An example distributed task An example task in Project Renoir Data transfer From the presentation layer to the application layer From the application layer to the persistence layer Implementation facts Outline of an application layer Propagating application settings Logging Handling and throwing exceptions Caching and caching patterns Injecting SignalR connection hubs Boundaries and deployment of the application layer The dependency list Deployment options Summary Chapter 6 The domain layer Decomposition of the domain layer The business domain model Helper domain services Devising a domain model Shifting focus from data to behavior Life forms in a domain model The domain model in Project Renoir The hitchhiker’s guide to the domain Treating software anemia Common traits of an entity class Rules of etiquette Style conventions Writing truly readable code Summary Chapter 7 Domain services What is a domain service, anyway? The stateless nature of domain services Marking domain service classes Domain services and ubiquitous language Data access in domain services Data injection in domain services Common scenarios for domain services Determining the loyalty status of a customer Blinking at domain events Sending business emails Service to hash passwords Implementation facts Building a sample domain service Useful and related patterns The REPR pattern adapted Open points Are domain services really necessary? Additional scenarios for domain services Summary Chapter 8 The infrastructure layer Responsibilities of the infrastructure layer Data persistence and storage Communication with external services Communication with internal services Implementing the persistence layer Repository classes Using Entity Framework Core Using Dapper Hosting business logic in the database Data storage architecture Introducing command/query separation An executive summary of event sourcing Summary PART III COMMON DILEMMAS Chapter 9 Microservices versus modular monoliths Moving away from legacy monoliths Not all monoliths are equal Potential downsides of monoliths Facts about microservices Early adopters Tenets of a microservices architecture and SOA How big or small is “micro”? The benefits of microservices The gray areas Can microservices fit all applications? The big misconception of big companies SOA and microservices Are microservices a good fit for your scenario? Planning and deployment Modular monoliths The delicate case of greenfield projects Outlining a modular monolith strategy for new projects From modules to microservices Summary Chapter 10 Client-side versus server-side A brief history of web applications The prehistoric era The server-scripting era The client-scripting era Client-side rendering The HTML layer The API layer Toward a modern prehistoric era Server-side rendering Front-end–back-end separation ASP.NET front-end options ASP.NET Core versus Node.js The blocking/non-blocking saga Summary Chapter 11 Technical debt and credit The hidden cost of technical debt Dealing with technical debt Ways to address debt Debt amplifiers The hidden profit of technical credit The theory of broken windows The power of refactoring Do things right, right away Summary Index A B C D E F G H I J K L M N O P Q R S T U V W X Y Z Understand what to do at any point in developing a clean .NET architecture Master advanced .NET techniques with a focus on actual value delivered by working within a modular, clean architecture. Microsoft Data Platform MVP Dino Esposito explains key clean architecture concepts with a mix of pragmatism and design discipline and helps you solidify your knowledge through a real-world project. Starting with an explanation of the quest for modular software architecture continuing through the methodology of domain-driven design (DDD), Esposito emphasizes the role that modularization plays in managing complexity in software development. Breaking down the layers of an architecture that is modular and maintainable, he presents a sample project that is not simply another to-do list, but an actual tool for the reader. Ultimately, an exploration of common dilemmas for both developers and operations brings together historical developments with real solutions for today. Microsoft Data Platform MVP Dino Esposito helps you: · Understand the relevance of modular software architecture in the history of software · Review domain-driven design concepts both, strategic and practical · Apply modular analysis techniques to your development · Make the most of layered architecture · Make the most of layered architecture that is modular and maintainable · Explore in detail the individual layers―presentation, application, domain and infrastructure · Make sense of domain services to separate raw persistence from persistence-related business tasks · Make your way through a series of C# best-practices for modeling classes from real-world entities · Understand the benefits of microservices versus modular monoliths · Understand the analysis of technical shortcuts and benefits of long-term technical investment · Understand client-side, server-side and other common deployment dilemmas · Set up your architecture, test your conclusions, and find even more help