ITCamp 2011 - Gabriel Enea - Elements of DDD with ASPNet MVC and Entity Framework

Elements of DDD with
ASP .NET MVC &
Entity Framework Code First
Gabriel ENEA, Technical Director
Maxcode
Co-founder Joobs.ro – primul portal de joburi IT
gabriel.enea@maxcode.ro / gabrielenea.blogspot.com / @dotnet18

Premium conference on Microsoft’s Dev and ITPro technologies @itcampro / #itcampro

IT Camp 2011
• Thanks for coming!
• ITCamp is made possible by our sponsors:


Session agenda
# Unit Testing
# Enterprise Application Architecture
# Domain-Driven-Design
# Dependency Injection
# ASP.NET MVC 3 DI
# Entity Framework 4.1 Code First
# Design Patterns

• Q&A
• Feedback & prizes


How do you start building an
application architecture?
Focus on?
• building an architecture from scratch
• thinking about how to achieve unit testing
• start with modeling the database schema and data
relations
• using drag & drop programming
• modeling the domain entities, relations, business rules

• but, in the end, do you achieve 99,99% of unit testing?


Is unit testing realizable? 100%?
Yes or No? Who knows?

Maybe not! Possible answers:
• The customer doesn't understand this need
• Neither the management staff
• Instead, everyone expects you to write the perfect code

• As developers, every time we say: we need time to do it
right!

• But, do we need time or we don't know how to achieve it?


Let's start thinking to architecture
design
What? Right, now!?

Hey, we have only 1 hour to finish this
presentation! 

Indeed, but let's try to do something!


Some directions
• Modeling approaches
– Database First Design
– Model First Design
• Layers
– How do we design them?
• Business rules
– Where and how do we implement?
• Persistence
– Should we use an ORM?


Modeling approach - Pros/Cons
• Database First Design
– doesn't focus on business rules, only on the way the
data is represented

• Model First Design
– Conceptual Design
• defines a conceptual model of the entities and relations
(UML vs. Domain-Specific Languages)
– Code First Design
• starts writing code: classes, properties, associations,
businesss rules


Layers

Presentation

Business

Data Access


Layers – any problems?
Presentation

Business

Layers Coupling! Data Access

A strong coupling conducts to a hard way to do:
– unit testing
– refactoring
– agile development
– or be opened for changes


Business rules
Where should these be located?
– Database
– Business layer
– User Interface (aka code behind!)

How do we test them?
– Running the application
– Automatically, maybe using unit tests
– Or we should let the customer test them!? 


And...what's inappropriate here?
// somewhere in the business layer
public class Patient {
public DateTime Birthdate { get; set; }

public int Age { // computed value
get {
return DateTime.Now.Year - this.Birthdate.Year;
}
Strong coupling!
}

public bool IsAdult { // business rule
get {
return this.Age >= 18;
}
}
...


Let's start with a new approach...
Domain-Driven-Design
• What is Domain?

A new default architecture where:
• the database is not the first focus
• the layers are loosely coupled
• the business rules are within the application Domain
• it is easier to achieve unit testing

• Why? Today we have the tools!


A new default architecture


Persistence
Requirements
• Persistence Ignorance (PI) / POCO
• Help Domain Model stay out of
infrastructure stuff
• Decide where to store data
• Use code generation or an Object Relation
(O/R) Mapper
– Metadata mapping
• Support for the Unit of Work pattern


Building blocks of DDD


Today's tools
(from a web developer perspective)
ASP.NET MVC 3
– a mature web development platform based on MVC
pattern
Entity Framework 4.1 Code First / NHibernate
– helps you focus on your domain
DI frameworks
– Manage dependencies
– Castle Windsor, StructureMap, Spring.NET, Unity, ...


Stop, What is DI?
• = DI.Equals(IoC); // true or false?

• IoC = Inversion of Control
• DI = Dependency Injection

• Helps you to decouple the application dependencies
– Logging mechanisms (log4net, Enterprise Library Logging
Application Block, ...)
– Persistence mechanism (direct access to database, ORM)
– User Interface dependencies on Domain services


Dependency Injection

Log4netLogger

PatientService

PatientRepositoy


Dependency Injection
1) creates
Builder PatientService

Log4netLogger
2) inject dependencies 3) uses

ILogger


Persistance with EF 4.1 CodeFirst
Benefits
• Mapping based on predefined conventions
• Support for Query Object pattern (LINQ - IQuerable
interface)
• Fluent API for manual mapping entities to tables, no
more .edmx files
• Entity Validation


ASP.NET MVC 3 and DI support
• Based on MVC pattern
• Provides better support for IoC
– Views/Controllers

• Check IDependencyResolver interface
– simplify service location and dependency resolution

TService GetService<TService>() { … }

IEnumerable<TService> GetServices<TService>() { … }


DDD architecture and solution

DEMO


Conclusions
Focus on
– Analyze application dependencies
– Business rules
– Do refactoring!
– Design your Domain
– Don’t forget to do Unit testing


Elements of DDD with ASP.NET MVC & Entity Framework Code First

Q&A


Resources
Books
• Domain-Driven Design, Tackling Complexity in the
Heart of Software, by Eric Evans
• Applying Domain-Driven Design and Patterns, With
Examples in C# and .NET, by Jimmy Nilsson

Online resources
• http://domaindrivendesign.org/
• http://www.infoq.com/minibooks/domai
n-driven-design-quickly


Don’t forget!
Get your free Azure pass! We want your feedback!

• 30+15 days, no CC req’d • Win a WP7 smartphone
– http://bit.ly/ITCAMP11 – Fill in your feedback forms
– Promo code: ITCAMP11 – Raffle: end of the day


ITCamp 2011 - Gabriel Enea - Elements of DDD with ASPNet MVC and Entity Framework

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (15)

Mehr von ITCamp

Mehr von ITCamp (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

ITCamp 2011 - Gabriel Enea - Elements of DDD with ASPNet MVC and Entity Framework