In this 5+ hour series Bob applies the lessons learned from the Application Architecture Fundamentals series to a real project. You’ll learn how to apply an agile, object oriented analysis and design process to the requirements then utilize Test Driven Development, Domain Driven Development, dependency injection and other patterns, principles, tools and practices to build an architectural spike to help design a solution for a fictional company’s business problem.

Applied Architecture – Architecting the Domain Layer eBook (PDF)

This series also features a 160+ page eBook (PDF) that covers the same material as the videos, but does so in a textual way to help you as you watch the videos to get the most out of this course.
Applied Architecture – Architecting the Domain Layer Final Code Files

At the end of the series, this is the ACME.Maintenance solution and project files. Throughout the series, individual snippets (Gists on Github) of the code in the various files are located in both the eBook and on the pages where the videos are streaming.
AA-AD_01 – Series Introduction

This first lesson introduces the goals and the approach of this unique series. We’ll focus on building an entire application for a fictitious client, focusing on the ideas, practices and patterns presented in the Application Architecture Fundamentals series.
AA-AD_02 – Discovering the Problem Domain

In this lesson, Bob explains the business problem facing our fictional client who needs to replace a legacy system with a new system. Bob discusses the background of the client, and the goals of the new system and asks how these goals might impact our architectural decisions.
AA-AD_03 – Analyzing the Problem Domain

Picking up where the previous video left off, Bob discusses the goals of the new system and how they might impact our architectural decisions.
AA-AD_04 – Reviewing the User Stories

In this lesson, we begin to drill down into greater detail in a single use case as outlined in a User Story. We discuss user stories, how they’re used in project planning and estimating, how they are used in requirements gathering and can be used to direct an architectural spike. The assignment in this lesson asks you to identify candidate layers and the tiers they would most likely be distributed to, as well as candidate classes for use in the domain layer.
AA-AD_05 – Designing a Solution Architecture

Now that we have some solid requirements, we’re able to discuss the architecture from several perspectives. Based on the previous lesson’s assignment, Bob discusses the required layers, their distribution on to physical tiers, and talks about identifying candidate classes and properties, associations, etc. for the domain layer.
AA-AD_06 – Preparing the the Architectural Spike

In this short less, we begin the process of setting up our Visual Studio Solution and projects, paying particular attention to the names of things.
AA-AD_07 – Creating the First Unit Test

In this lesson we take our first steps into designing the domain model with unit tests. We outline a scenario and write the unit test to focus our domain classes to satisfying those unit tests.
AA-AD_08 – Refactoring the First Unit Test

Our first pass at the unit test has helped us gain some clarity on how best to design our domain classes. In this lesson, we apply those insights in the form of refactorings to better express our intent in the unit test and ultimately in the design of our domain classes.
AA-AD_09 – Creating a Stubbed Persistence Class and Data Transfer Object Class

We have an implied dependency between our domain layer and a data access technology. We intend to use a persistence layer to address that concern of the application, and with the intent of focusing our design and work on the domain classes, we create a persistence class and hardcode values it should return. We also introduce data transfer object classes for transferring data between the layers of our application.
AA-AD_10 – Using Dependency Injection to Break Layer Dependencies

While our concrete stubbed persistence layer was a good start, it presented us with a dilemma … to solve the dilemma, we decide not to create a concrete hard wired connection between the domain layer and persistence layer, but rather, to have the persistence class dependency injected into the domain class at runtime via an interface.
AA-AD_11 – Introducing Fakes and FakeItEasy to Better Isolate Our Domain

While the stubbed persistence layer class has served its purpose, it is also limiting. To provide more flexibility in working with dependent classes without having to create stubs for every possible scenario, we choose to introduce an isolation framework, Fake It Easy, so that we can create fake object based on interfaces, and instruct Fake It Easy to issue “happy noises” to our domain classes when it needs something from our impostor.
AA-AD_12 – Introducing AutoMapper to Automatically Map our Domain and DTO Objects

In this lesson we introduce AutoMapper to help reduce the amount of boilerplate code required to map properties from one class (a domain class) to another class (a data transfer object).
AA-AD_13 – Arrange, Act, Assert

In this lesson, we talk about the pattern most people follow for creating unit tests, namely Arrange, Act, Assert.
AA-AD_14 – Handling Exceptional Cases

Having completed a couple of unit tests and refactored both the tests and the production code, we consider how to test those cases where we expect an exception to be raised.
AA-AD_15 – Adding a New Unit Test for Creating an Order

Now that most of the new concepts have been covered, we continue to apply those ideas to creating new Unit Tests to continue focusing on completing the user story.
AA-AD_16 – Creating the Exceptional Case for Creating an Order using an Expired Contract

In this lesson, we continue focusing on the user story, this time paying attention to what should happen when the system has to deal with an expired contract.
AA-AD_17 – Adding Order Items to the Order – Part 1

Now that we’ve finished getting contracts, we want to focus on working with Orders. We begin with a new Unit Test but quickly come to realize we’re in over our heads and need to give more careful thought to how this process should work.
AA-AD_18 – Getting Parts

Taking a short aside from creating a new Order and adding OrderItems to it, we decide to briefly focus on getting parts so that we can base new OrderItems on them.
AA-AD_19 – Adding Order Items to the Order – Part 2

Now that we can work with Parts, we can revisit our unit test, refactor it, and focus it on the act of creating OrderItems.
AA-AD_20 – Adding Order Items to the Order – Part 3

Now that we can create OrderItems, time to add them to an Order. We talk about the challenges of working with a List and determine how to solve it using the new IReadOnlyList.
AA-AD_21 – Getting a List of Order Items

Finally, we focus on testing the process of iterating through an Order’s Items making sure that we are testing the edge cases (i.e., empty values, no Order Items, etc.) I add some closing comments at the end. However, in many ways, this is just the beginning to the other Applied Architecture series on LearnVisualStudio.NET.

Home:

http://www.learnvisualstudio.net/series/applied-architecture-architecting-the-domain-layer/

Only for V.I.P