Course info
Jul 17, 2012
2h 1m

In part 1 of this series, you'll learn why separating software application logic into layers is a common practice, as well as some pros and cons of doing so. You'll see how monolithic applications can evolve into N-Tier applications, including two approaches: Data Centric and Domain Centric (or DDD) designs.

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
Pair Programming
2h 29m
Apr 7, 2016
Domain-Driven Design Fundamentals
4h 16m
Jun 25, 2014
More courses by Steve Smith
Section Introduction Transcripts
Section Introduction Transcripts

Application Evolution
Hi, and welcome to this Pluralsight course on Creating N-Tier Applications in C# Part 1, Application Evolution. My name is Steve Smith and you can learn more about me on my blog at Ardalis. com or you can follow me on Twitter where I'm @ardalis. Creating N-Tier Applications in C# is a big topic, so this course is just part 1 in a series. In this course, you'll learn how N-tier applications evolve which is a subject of this module. In the next module, you'll learn about traditional data-centric N-tier design and architecture. And then in the third module, you'll learn about domain-centric N-tier design and architecture and how this differs from the data-centric style. In discussing the evolution of N-tier applications, we also need to talk through some of the basics of N-tier design and architecture. In this module, you'll learn what we mean when we refer to an application that's consisting of N-tiers or layers. You'll learn the difference between logical and physical separation. You'll learn about the typical tiers that make up an N-tier application design. You'll learn some of the pros and cons of applying an N-tier design to your application. And finally, you'll see a demo showing an application comprised of just one tier. Later on, we'll expand on this demo to show how we can evolve it into an N-tier application.

Data-Centric N-Tier Design
Hi and welcome back. This is the Pluralsight course on Creating N-Tier Applications in C sharp, Part 1. This is the second module in the course where we're going to take a look at creating a Data-Centric N-Tier design by starting with a monolithic design and then refactoring it into separate tiers with their own responsibilities. My name is Steve Smith, I will be your instructor here and you can find more about me at my blog on Ardalis. com or on Twitter where I'm @ardalis. I hope you've had a chance to watch the first module in this course on how N-Tier applications evolved. In this module, we're going to focus on the traditional Data-Centric N-Tier architecture and how we can refactor an existing monolithic application to make use of this design. You'll get to experience firsthand some of the pinpoints that this design is meant to address as well as some of the effort that's required to perform this refactoring. In the next module, we'll perform a similar exercise but with the end goal being a Domain-Centric N-Tier Architecture rather than a Data Centric one.

Domain-Centric N-Tier Design
Hi, this is Steve Smith. And in this module we're going to continue Part 1 of my Creating N-Tier Application in C# course. In this module we'll be considering a Domain-Centric approach to N-Tier system design. Let's get started. If you've been following along, you've seen how N-Tier application evolved, and how traditional data centric N-Tier systems are designed. One of the problems with this approach is that it tends to lead to a significant amount of coupling between the applications at every tier in the database. In this module, we'll se how you can invert this dependence on external system like databases, so that the application can remain more loosely coupled, maintainable, and testable.