Call Us: +32 2 466 00 16
Follow Us:

Domain-Driven Design with Entity Framework Core

3 days
3 days

Upcoming Sessions





Book now





Book now

Interested in a private company training? Request it here.

Domain Driven Design

Introduction to Domain Driven Design

Getting the software right is a hard thing to do. This is because business and developers do not always talk the same language. Domain Driven Design is all about getting the language right between them.

  • What is Domain Driven Design?
  • Advantages of using Domain Driven Design
  • When is Domain Driven Design a bad option?
  • Anti-Pattern: Big Ball of Mud
  • Anti-Pattern: Death by a Thousand Dots

Tactical Design

When constructing the domain model, there are several approaches. Tactical Design provides a set of technical resources that are used in the construction of the domain model. The goal is to enrich your domain model by applying these standards correctly. When done so, it will reflect your business model with more clarity.

  • Differentiating between Entities and Value Objects
  • Implementing Value Objects Equality efficiently
  • Clustering Entities and Value Objects with Aggregates
  • Providing domain specific operations with Services
  • Data storage by using Repositories
  • Abstracting the creation of Entities, Value Objects and Aggregates with Factories
  • Publishing significant domain changes with Domain Events
  • Segregating concepts using Modules
  • Applying Tactical Design to a real world business case
  • Writing Unit Tests for all.

Strategic Design

One of the core pillars of DDD is Strategic Modeling. Strategic modelling helps you at defining the Bounded Contexts, the Ubiquitous Language and Context Maps.

  • The linguistic delimitation that are Bounded Contexts
  • Identifying the terms and concepts with the Ubiquitous Language
  • Relating Bounded Contexts with Context Maps

Clean Architecture

Architecting Modern Web Applications

So what is a modern web application? One that uses Angular and TypeScript? With the speed that modern web application developement evolves, there is the chance that your web site uses 'old' technology by the time it is done. But sound architecture never goes stale. As a wise man once said: 'If you think good architecture is expensive, try bad architecure'.

  • "Clean" Architecture: put the business and application model at the center
  • Understanding the Core, Infrastructure and Presentation layer
  • Testing everything with Clean Architecture

Entity Framework Core

Introduction to Entity Framework Core

When a database is designed, the idea is to normalize data, i.e. avoid duplicate data. When designing the object model for an application you try to come up with a design which is best suited for solving your business problems. This means that mapping tables to classes one-on-one is often a bad idea. Entity Framework allows us to map the relational world to the world of objects, allowing more complex mapping.

  • What is Entity Framework Core?
  • The need for Object Relational Mapping, especially with inheritance
  • Decoupling conceptual data structure from logical data structure
  • Querying data: APIs and LINQ

Entity Framework Core

With .NET 5 also comes a while new Entity Framework Core. A new implementation of EF, which can run cross-platform, on Windows, Mac and Linux.

  • Differences with .NET 4.x Entity Framework
  • Scaffolding your project from an existing database
  • Understanding the generated code
  • Interacting with the database with LINQ

Modeling your database with EF Core

Mapping in EF Core uses conventions, attributes, or Fluent API. You will see how to use these to model your database in EF Core and apply the changes with Code-first Migrations.

  • Methods of configuration
  • Creating and applying migrations
  • Table and column mapping
  • Modeling properties
  • Mapping Value generated properties
  • Handling Concurrent updates
  • Modeling relationships
  • Mapping inheritance

Advanced EF: Mapping DDD to EF Core.

Domain Driven Design is a great way to start designing your applications. Entity Framework Core is a great framework to access and manipulate your data, stored in databases. Now, how can we fit Domain Driven Design concepts into Entity Framework Core? Yes we can!

  • DDD and Persistance Ignorance
  • Implementing Value Objects with Owned Properties
  • Using Shadow Properties to Avoid 'Leaky Abstractions'
  • Building Repository and Specification classes
  • Testing your Specifications
  • Entity Validation


Unit Testing ASP.NET 5 Web Applications

When creating modern web applications with ASP.NET 5 MVC, it's not that straightforward to unit test the Controllers and Views. How does one validate wether the ActionResult returned by the Controller action is the one you wanted, as well as whether the View is correct. How do we replace dependencies during testing with MVC? How do we perform end-to-end testing?

  • Challenges when unit testing MVC applications
  • Writing unit test for your MVC controllers
  • Unit testing your views
  • Unit testing ApiControllers
  • Using the ASP.NET 5 testing framework
  • End-to-end testing

When architecting and developing applications, there are several approaches that could be considered. Domain-Driven Design (DDD) is one of them. The idea of domain-driven design is to let the software originate from the so-called domain. By doing so, one tries to create software that perfectly mimics the domain it was created for. When creating business applications, there is often a need for a data access layer to some database. This is where Entity Framework Core (EF) jumps in. In fact, domain-driven design and EF Core can go perfectly hand in hand. This course will discuss the concepts of domain-driven design and how EF Core can help you at implementing these concepts. Building a large website can turn into a very complex project if you are not careful, so we will split our solution into layers. Best practices today is using an architecture approach called "Clean Architecture", which separates your solution into different layers with maintenance and testing in mind. DDD works very well for long-lasting software projects that will undergo many changes triggered by changing and new requirements. How do you ensure that existing functionality doesn't get broken? This is where testing comes into play. Participants learn about modern architecture and will get a hands-on approach to building a web site using C#, DDD, EF Core and Unit testing.

Attendees are required to have prior knowledge of C#/VB.NET and ASP.NET.

© 2020 U2U All rights reserved.