Upload
theo-jungeblut
View
1.663
Download
2
Tags:
Embed Size (px)
DESCRIPTION
Dependency injection is a design patter with the potential to write cleaner code. Over the lifetime of a product, maintaining the product is actual one - if the the most - expensive areas of the overall product costs. Writing clean code can significantly lower these costs. Writing clean code also makes you more efficient during the initial development time and results in a more stable code base. In this talk, we will dive into the basics of Inversion of Control (IoC) and Dependency Injection (DI) to review different ways of achieving decoupling. We will explorer best practices, design, and anti-patterns.
Citation preview
with DIMountain View, Sep. 25th, 2013
South Bay.NET User Group
Cut your Dependencies
Theo Jungeblut• Engineering manager & lead by day
at AppDynamics in San Francisco
• Coder & software craftsman by night, house builder and soon to be dad
• Architects decoupled solutions & crafts maintainable code to last
• Worked in healthcare and factory automation, building mission critical applications, framework & platforms
• Degree in Software Engineeringand Network Communications
• Enjoys cycling, running and [email protected]
www.designitright.net
Rate Session & Win a Shirt
http://www.speakerrate.com/theoj
Where to get the Slides
http://www.slideshare.net/theojungeblut
Overview
• What is the issue?• What is Dependency Injection?• What are Dependencies?• What is the IoC-Container doing for you?• What, how, why?• Q & A
UI
Service
ProcessorProcessor
Service
ResourcesResources
UI
Processor
A cleanly layered Architecture
What is the problem?
What is Clean Code?
Clean Code is maintainable
Source code must be:• readable & well structured• extensible• testable
Code Maintainability *
Principles Patterns Containers
Why? How? What?
Extensibility Clean Code Tool reuse
* from: Mark Seemann’s “Dependency Injection in .NET” presentation Bay.NET 05/2011
What is Dependency Injection?
Without Dependency Injectionpublic class ExampleClass{
private Logger logger;
public ExampleClass(){
this.logger = new Logger();
this.logger.Log(“Constructor call”);}
}
public class ExampleClass{
private Logger logger;
public ExampleClass(){
this.logger = new Logger();
this.logger.Log(“Constructor call”);}
}
Without Dependency Injection
Avoid
Inversion of Control –
Constructor Injectionhttp://www.martinfowler.com/articles/injection.html
public class ExampleClass{
private ILogger logger;
public ExampleClass(ILogger logger){
this.logger = logger;if (logger == null){
throw new ArgumentNullException(“logger”);
}
this.logger.Log(“Constructor call”);}
}
Why is Dependency Injection beneficial?
Benefits of Dependency InjectionBenefit Description
Late binding Services can be swapped withother services.
Extensibility Code can be extended and reusedin ways not explicitly planned for.
Paralleldevelopment
Code can be developed in parallel.
Maintainability Classes with clearly definedresponsibilities are easier to maintain.
TESTABILITY Classes can be unit tested.
* from Mark Seemann’s “Dependency Injection in .NET”, page 16
The Adapter Patternfrom Gang of Four, “Design Patterns”
What are
Dependencies ?
Stable Dependency
“A DEPENDENCY that can be referenced without any detrimental effects.
The opposite of a VOLATILE DEPENDENCY. “
* From Glossary: Mark Seemann’s “Dependency Injection in .NET”
Volatile Dependency“A DEPENDENCY that involves side effects that
may be undesirable at times.
This may include modules that don’t yet exist, or that have adverse requirements on its
runtime environment.
These are the DEPENDENCIES that are addressed by DI.“
* From Glossary: Mark Seemann’s “Dependency Injection in .NET”
Lifetime a Job
for the Container
public class ExampleClass{
private Logger logger;
public ExampleClass(){
this.logger = new Logger();
this.logger.Log(“Constructor call”);}
}
Without Dependency Injection
Avoid
“Register, Resolve, Release”“Three Calls Pattern by Krzysztof Koźmic: http://kozmic.pl/
1. Register 2. Resolve
Build up You code
Execute ReleaseClean
up
What the IoC-Container will do for you
1. Register 2. Resolve
Build up
ReleaseClean up
Separation of Concern (SoC)probably by Edsger W. Dijkstra in 1974
You codeExecu
te
• Focus on purpose of your code• Know only the contracts of the
dependencies• No need to know
implementations• No need to handle lifetime of
the dependencies
The 3 Dimensions of DI
1.Object Composition2.Object Lifetime3.Interception
Register - Composition Root
• XML based Configuration• Code based Configuration• Convention based (Discovery)
Resolve
Resolve a single object request for example by Constructor Injection by resolving the needed object graph for this object.
Release
Release objects from Container when not needed anymore.
Anti Patterns
Control Freak
http://www.freakingnews.com/The-Puppet-Master-will-play-Pics-102728.asp
// UNITY Exampleinternal static class Program{ private static UnityContainer unityContainer; private static SingleContactManagerForm singleContactManagerForm;
private static void InitializeMainForm() { singleContactManagerForm = unityContainer.Resolve<SingleContactManagerForm>(); }}
Inversion of Control –
Service Locatorhttp://www.martinfowler.com/articles/injection.html
// UNITY Exampleinternal static class Program{ private static UnityContainer unityContainer; private static SingleContactManagerForm singleContactManagerForm;
private static void InitializeMainForm() { singleContactManagerForm = unityContainer.Resolve<SingleContactManagerForm>(); }}
Inversion of Control –
Service Locatorhttp://www.martinfowler.com/articles/injection.html
Anti-Pattern
based on Mark Seemann
Inversion of Control –
Setter (Property) Injection
// UNITY Examplepublic class ContactManager : IContactManager{ [Dependency] public IContactPersistence ContactPersistence { get { return this.contactPersistence; }
set { this.contactPersistence = value; } }}
http://www.martinfowler.com/articles/injection.html
Property Injection
+ Easy to understand
- Hard to implement robust
* Take if an good default exists
- Limited in application otherwise
Method Injectionpublic class ContactManager : IContactManager{ …. public bool Save (IContactPersistencecontactDatabaseService, IContact contact) { if (logger == null) {
throw new ArgumentNullException(“logger”); } …. // Additional business logic executed before calling the save
return contactDatabaseService.Save(contact); }}
http://www.martinfowler.com/articles/injection.html
Method Injection
• Needed for handling changing dependencies in method calls
Ambient Contextpublic class ContactManager : IContactManager{ …. public bool Save (….) { …. IUser currentUser = ApplicationContext.CurrentUser; …. }}
* The Ambient Context object needs to have a default value if not assigned yet.
Ambient Context
• Avoids polluting an API with Cross Cutting Concerns
• Only for Cross Cutting Concerns
• Limited in application otherwise
InterceptionPublic class LoggingInterceptor : IContactManager{ public bool Save(IContact contact) { bool success;
this. logger.Log(“Starting saving’);
success = this.contactManager.Save(contact);
this. logger.Log(“Starting saving’);
return success; }}
Public class ContactManager : IContactManager{ public bool Save(IContact contact) { ….
return Result }}
* Note: strong simplification of what logically happens through interception.
Dependency Injection Container & more• Typically support all types of Inversion of Control mechanisms• Constructor Injection• Property (Setter) Injection• Method (Interface) Injection• Service Locator
•.NET based DI-Container• Unity• Castle Windsor • StructureMap• Spring.NET• Autofac• Puzzle.Nfactory• Ninject• PicoContainer.NET• and more
Related Technology:• Managed Extensibility Framework (MEF)
The “Must Read”-Book(s)
http://www.manning.com/seemann/
by Mark Seemann
Dependency Injection is a set of software design principles and patterns that enable us to develop loosely coupled code.
Summary Clean Code - DIMaintainability is achieved through:
• Simplification, Specialization Decoupling (KISS, SoC, IoC, DI)
• Dependency InjectionConstructor Injection as default, Property and Method Injection as needed, Ambient Context for Dependencies with a default,Service Locator never
• Registration Configuration by Convention if possible, exception in Code as neededConfiguration by XML for explicit extensibility and post compile setup
• Quality through Testability (all of them!)
Graphic by Nathan Sawaya
courtesy of brickartist.com
Downloads, Feedback & Comments:
Q & A
Graphic by Nathan Sawaya courtesy of brickartist.com
[email protected] www.speakerrate.com/theoj
References… http://www.manning.com/seemann/http://en.wikipedia.org/wiki/Keep_it_simple_stupidhttp://picocontainer.org/patterns.htmlhttp://en.wikipedia.org/wiki/Dependency_inversion_principlehttp://en.wikipedia.org/wiki/Don't_repeat_yourselfhttp://en.wikipedia.org/wiki/Component-oriented_programminghttp://en.wikipedia.org/wiki/Service-oriented_architecturehttp://www.martinfowler.com/articles/injection.htmlhttp://www.codeproject.com/KB/aspnet/IOCDI.aspxhttp://msdn.microsoft.com/en-us/magazine/cc163739.aspxhttp://msdn.microsoft.com/en-us/library/ff650320.aspxhttp://msdn.microsoft.com/en-us/library/aa973811.aspxhttp://msdn.microsoft.com/en-us/library/ff647976.aspxhttp://msdn.microsoft.com/en-us/library/cc707845.aspxhttp://msdn.microsoft.com/en-us/library/bb833022.aspxhttp://unity.codeplex.com/
Lego (trademarked in capitals as LEGO)
Blog, Rating, Slides
http://www.DesignItRight.net
www.speakerrate.com/theoj
www.slideshare.net/theojungeblut
… thanks for you attention!
And visit and support
Please fill out the feedback, and…
www.speakerrate.com/theoj