Domain-Driven Design

Paths

Domain-Driven Design

Authors: Matthew Renze, Dino Esposito, Julie Lerman, Steve Smith, Vladimir Khorikov

Learn the philosophy and major design patterns that underlie the Domain Driven Design approach to software architecture. Understand the importance of focusing on the core domain... Read more

• How to split the problem domain into Core, Generic, and Supporting subdomains and design bounded contexts for them with appropriate level of effort (e.g. rich domain model, transaction script, etc.) • How to identify entities and Value Objects in the domain model • How to choose aggregate boundaries in the bounded context and identify the root entity in the aggregate • How to work with domain events • The Specification pattern • How to identify an anemic domain model and refactor away from it towards a rich one • How to work productively with a legacy project via implementation of an anti-corruption layer • How to map complex domain models using modern ORMs, such as EF Core and NHibernate • How to apply the CQRS pattern in practice • Working with Event Sourcing

Pre-requisites

C# programming language

Beginner

Like a building, the strength of your software construction starts with a solid foundation. Here we learn both the basics of clean software architecture design and the fundamental pillars of the Domain Driven Design approach you’ll need in any solution you create.

Clean Architecture: Patterns, Practices, and Principles

by Matthew Renze

Jan 11, 2017 / 2h 21m

2h 21m

Start Course
Description

Hello, and welcome to Pluralsight! My name is Matthew Renze, and I want to give you a quick overview of my course, Clean Architecture: Patterns, Practices, and Principles. It’s designed to help you learn how software experts keep their architecture clean using a modern approach to software architecture called Clean Architecture, and covers things like domain-centric architecture, application layers, CQRS (Command-Query Responsibility Separation), event sourcing, functional cohesion, bounded contexts, and more. In addition, you'll use these practices to replace the outdated three-layer database-centric architecture that has been used for decades. Most important though, you'll see how these practices, when combined, create an architecture that is simple, understandable, flexible, testable, and maintainable. When you’re done, you’ll have the skills necessary to understand and implement these clean architecture practices on your own software projects. As an introductory course, there are no prerequisites for this course. However, having basic experience with at least one C like programming language, and basic knowledge of software architecture will be beneficial. I look forward to working with you on Clean Architecture: Patterns, Practices, and Principles, here at Pluralsight.

Table of contents
  1. Course Overview
  2. Introduction
  3. Domain-centric Architecture
  4. Application Layer
  5. Commands and Queries
  6. Functional Organization
  7. Microservices
  8. Testable Architecture
  9. Evolving the Architecture

Modern Software Architecture: Domain Models, CQRS, and Event Sourcing

by Dino Esposito

Jul 23, 2015 / 4h 26m

4h 26m

Start Course
Description

This course covers DDD analysis patterns helpful in discovering the top-level architecture of a business domain. Architects and developers will find details of implementation patterns such as Domain Model, CQRS, and Event Sourcing.

Table of contents
  1. DDD at a Glance
  2. Discovering the Domain Architecture through DDD
  3. The DDD Layered Architecture
  4. The "Domain Model" Supporting Architecture
  5. The CQRS Supporting Architecture
  6. Event Sourcing
  7. Designing Software Driven by the Domain

Domain-Driven Design Fundamentals

by Julie Lerman

Jun 25, 2014 / 4h 17m

4h 17m

Start Course
Description

Hello, and welcome to Domain-Driven Design Fundamentals, part of the ASP.NET MVC 5 Learning Path here at Pluralsight. Your authors, Steve Smith and Julie Lerman, are looking forward to helping you learn the fundamentals of Domain-Driven Design (DDD) through a demonstration of customer interactions and a complex demo application. Along the way, you’ll learn about elements of a domain model, aggregates in Domain-Driven Design, and repositories. You’ll also get hands on modeling problems, and learn about technical components of DDD, and how to manage complexity. So if you’re ready to get started, Domain-Driven Design Fundamentals is waiting for you. Thanks again for visiting us here at Pluralsight!

Table of contents
  1. Introducing DDD
  2. DDD: Modeling Problems in Software
  3. Elements of a Domain Model
  4. Aggregates in Domain-Driven Design
  5. Repositories
  6. Domain Events and Anti-corruption Layers
  7. Reaping the Benefits of Domain-Driven Design

Intermediate

Once you understand the basic principles, it’s time to learn how to handle the havoc imposed by the real world. Start by learning not just to use DDD in your ground-up designs but how to refactor existing designs to leverage the power of DDD. We’ll also explore how the Specification Pattern can solve a class of problems and how to leverage the power of Modern Object Relational Mapping tools.

COMING SOON: Mapping Complex Domain Models with Modern ORMs

Domain-Driven Design in Practice

by Vladimir Khorikov

Jan 21, 2016 / 4h 20m

4h 20m

Start Course
Description

While Domain-Driven Design offers invaluable insights regarding developing enterprise-level software projects, it is often unclear how to apply them in practice. In this course, we'll go through the whole process of building an application from the very beginning using the DDD principles.

Table of contents
  1. Introduction
  2. Starting with the First Bounded Context
  3. Introducing UI and Persistence Layers
  4. Extending the Bounded Context with Aggregates
  5. Introducing Repositories
  6. Introducing the Second Bounded Context
  7. Working with Domain Events
  8. Looking Forward to Further Enhancements

Refactoring from Anemic Domain Model Towards a Rich One

by Vladimir Khorikov

Nov 13, 2017 / 3h 36m

3h 36m

Start Course
Description

Having a rich, highly encapsulated domain model is essential if you want to succeed in building building bullet-proof business line applications. In this course, Refactoring from Anemic Domain Model Towards a Rich One, is going to show you how to properly implement it. First, you'll cover why Anemic domain is an anti-pattern and its relationship to functional programming. Next, you'll learn about encapsulation and how to achieve it in your domain model. Finally, you'll touch on some important refactoring techniques. By the end of this course, you'll understand practical techniques that will help you recognize this anti-pattern in your code base and refactor it into a bullet-proof one.

Table of contents
  1. Introduction
  2. Introducing an Anemic Domain Model
  3. Decoupling the Domain Model from Data Contracts
  4. Using Value Objects as Domain Model Building Blocks
  5. Pushing Logic Down from Services to Domain Classes
  6. Organizing the Application Services Layer
  7. Domain Modeling Best Practices
  8. Course Overview

Specification Pattern in C#

by Vladimir Khorikov

Jun 27, 2017 / 1h 28m

1h 28m

Start Course
Description

Domain-driven design includes many established patterns and practices, and the specification pattern is one of them. In this course, Specification Pattern in C#, you'll learn how to properly implement the specification pattern in practice. First, you'll learn about the use cases for this pattern. Next, you'll explore common anti-patterns and pitfalls in this area. Finally, you'll wrap up the course by learning about how to maintain encapsulation, as well as how to combine different specifications together. By the end of this course, you'll have the necessary knowledge needed to apply this pattern in real-world projects.

Table of contents
  1. Course Overview
  2. Introduction
  3. Implementing the Specification Pattern the Naive Way
  4. Refactoring Towards Better Encapsulation

Domain-Driven Design: Working with Legacy Projects

by Vladimir Khorikov

Mar 27, 2018 / 3h 52m

3h 52m

Start Course
Description

As a programmer, you'd love to only work on green-field projects. However, you are most likely working on a legacy project right now, or will be at some point in the future. In this course, Domain-Driven Design: Working with Legacy Projects, you'll develop skills that will help you manage these legacy projects to deliver new functionality and keep the stakeholders happy. First, you'll learn how to make your way through the legacy code base by refactoring it one step at a time. Next, you'll explore how to handle rewrites, when to do that, and when it is better to keep the existing legacy code base instead. Finally, you'll discover techniques such as building an Anticorruption Layer, the Strangler pattern, and Branch by Abstraction pattern to deal with these code bases. By the end of this course, you'll have a solid understanding of the theory and practice of improving the functionality and scalability of legacy projects.

Table of contents
  1. Introduction
  2. Introducing a Legacy Project
  3. Creating a Bubble Context with a New Domain Model
  4. Making the Bubble Autonomous by Introducing a Separate Data Storage
  5. Exploring Further Ways of Dealing with the Legacy Project
  6. Creating an Anticorruption Layer
  7. Promoting the Anticorruption Layer to Synchronizing Anticorruption Layer
  8. Course Overview

Advanced

To complete your journey to becoming a DDD architect, we’ll help you take full advantage of the Command Query Responsibility Segregation pattern. You’ll finish with an exploration of using Event Sourcing not only to understand the current state of your application but a trackable history of how it got there.

COMING SOON: Event Sourcing in Practice

CQRS in Practice

by Vladimir Khorikov

Oct 11, 2018 / 4h 22m

4h 22m

Start Course
Description

There are a lot of misconceptions around the CQRS pattern, especially when it comes to applying it in real-world software projects. In this course, CQRS in Practice, you will learn all about CQRS with event sourcing, database configuration for reads and writes, and more. First, you will learn exactly what CQRS is, the principles behind it, and the benefits it can provide for your project. Next, you will explore the common misconceptions and anti-patterns around CQRS. Finally, you will see a detailed, step-by-step implementation of this pattern in practice. The sample project you'll be working on is close to what you will find in the real world, and you will see each step on the way to CQRS in great detail. By the end of this course, you will have a foundational understanding of the CQRS pattern and how to implement it in your software projects.

Table of contents
  1. Introduction
  2. Introducing a Sample Project
  3. Segregating Commands and Queries
  4. Refactoring Towards a Task-based Interface
  5. Simplifying the Read Model
  6. Introducing a Separate Database for Queries
  7. Synchronizing the Commands and Queries Databases
  8. CQRS Best Practices and Misconceptions
  9. Implementing Decorators upon Command and Query Handlers
  10. Course Overview
Offer Code *
Email * First name * Last name *
Company
Title
Phone
Country *

* Required field

Opt in for the latest promotions and events. You may unsubscribe at any time. Privacy Policy

By providing my phone number to Pluralsight and toggling this feature on, I agree and acknowledge that Pluralsight may use that number to contact me for marketing purposes, including using autodialed or pre-recorded calls and text messages. I understand that consent is not required as a condition of purchase from Pluralsight.

By activating this benefit, you agree to abide by Pluralsight's terms of use and privacy policy.

I agree, activate benefit