Description
Course info
Rating
(454)
Level
Intermediate
Updated
Dec 31, 2012
Duration
1h 40m
Description

In part 2 of this series, you'll continue to learn about building N-Tier applications using domain driven design techniques. You'll learn how to structure tests within your solution, how to design your application's persistence strategy, and how to reuse your core domain objects between multiple front-end applications.

About the author
About the author

Steve Smith (@ardalis) is an entrepreneur and software developer with a passion for building quality software as effectively as possible.

More from the author
SOLID Principles for C# Developers
Beginner
2h 8m
Apr 2, 2019
Pair Programming
Beginner
2h 29m
Apr 7, 2016
More courses by Steve Smith
Section Introduction Transcripts
Section Introduction Transcripts

Testing a Domain-Centric N-Tier Application
Hi, this is Steve Smith and in this module, we're going to continue the course series on Creating N-Tier Applications in C#. In Part 2, we're going to build on the application built in Part 1. In this first module of Part 2, we're going to look at Testing a Domain-CentricN-Tier Application. Let's get started. In Part 2 of this course, we're first going to look at how to test a Domain-CentricN-Tier Application. We'll consider a couple of different kinds of tests and some best practices for organizing our tests. Then, we'll look at a common source of confusion in this kind of application, persistence. Finally, we'll look at how we can take advantage of the separation of concerns this architectural approach uses to reuse business logic from our core domain objects in multiple front-end user interfaces. If you haven't already, you may want to watch Part 1 of this course found at the URL shown here. In this module, we'll start at the solution level with some thoughts on how to organize test projects. A lot of this is personal preference or maybe subject to your team's practices, but if you're starting from scratch, I have some advice you may find useful. Along the same lines, I have some tips for naming and organizing the tests themselves that I'll also share. Next, we look at how to deal with infrastructure since we will want some tests that exercise our application using its actual infrastructure such as the database. Finally, we'll briefly take a look at how we can automate the process of running our tests. Before we get started, let's review where we are so far.

Persistence Best Practices
Steve Smith: Hi. This is Steve Smith. And in this module, we're going to continue the course series on creating N-Tier applications in CSharp. In this module, we're going to take a look at persistence best practices in a domain-driven design. If you've been following along, you've just seen that we covered how to organize our tests in a domain-centric N-Tier application. In this module, we're going to look at persistence best practices, and then we'll wrap up this part of the course by looking at how to reuse some of our CoreLogic with multiple frontend applications. If you haven't already, you may want to watch part one of this course at the URL shown here. We'll be starting this module by considering object life cycles and where persistence fits into these life cycles. There are several patterns one can use here, each of which deals with responsibility of persistence differently. We'll discuss the responsibility of persistence and where it should live in our application and our solution, which classes should worry about persistence, and what does it mean for an object to be persistence ignorant? Next we'll take a look at object relational mappers and repositories in a bit more in depth than we have thus far. Finally, we'll consider some useful tips and tricks that relate to persistence in domain-driven design style applications. We'll see you again soon.

Core Logic Reuse
Hi! This is Steve Smith, and in this module, we're going to continue the course series on Creating N-Tier Applications in C# Part 2. This module focuses on Core Logic Reuse in a domain driven design. If you've been following along so far in this course, we've talked about Testing a Domain Centric N-Tier Application. We just looked at some Persistence Best Practices using things like repositories and object-relational mappers like Entity Framework and Hibernate. And now, in this module, we're going to talk about reusing the Core Logic in our domain driven design in Multiple Front-End Applications. If you haven't already, you may want to watch Part 1 of this course which you can find at the URL shown below or by doing a search on Pluralsight for N-Tier.