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.
2. 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 Engineering
and Network Communications
• Enjoys cycling, running and eating
theo@designitright.net
www.designitright.net
3. Rate Session & Win a Shirt
http://www.speakerrate.com/theoj
4. Where to get the Slides
http://www.slideshare.net/theojungeblut
5. 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
13. Without Dependency Injection
public class ExampleClass
{
private Logger logger;
public ExampleClass()
{
this.logger = new Logger();
this.logger.Log(“Constructor call”);
}
}
14. public class ExampleClass
{
private Logger logger;
public ExampleClass()
{
this.logger = new Logger();
this.logger.Log(“Constructor call”);
}
}
Without Dependency Injection
15. 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”);
}
}
17. Benefits of Dependency Injection
Benefit Description
Late binding Services can be swapped with
other services.
Extensibility Code can be extended and reused
in ways not explicitly planned for.
Parallel
development
Code can be developed in parallel.
Maintainability Classes with clearly defined
responsibilities are easier to
maintain.
TESTABILITY Classes can be unit tested.
* from Mark Seemann’s “Dependency Injection in .NET”, page 16
20. 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”
21. 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”
23. public class ExampleClass
{
private Logger logger;
public ExampleClass()
{
this.logger = new Logger();
this.logger.Log(“Constructor call”);
}
}
Without Dependency Injection
24. “Register, Resolve, Release”
“Three Calls Pattern by Krzysztof Koźmic: http://kozmic.pl/
1. Register
2. Resolve
Build
up
You code
Execu
te
Release
Clean
up
26. Separation of Concern (SoC)
probably by Edsger W. Dijkstra in 1974
You code
Execu
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
27. The 3 Dimensions of DI
1.Object Composition
2.Object Lifetime
3.Interception
28. Register - Composition Root
• XML based Configuration
• Code based Configuration
• Convention based (Discovery)
29. Resolve
Resolve a single object request for
example by Constructor Injection
by resolving the needed object
graph for this object.
33. // UNITY Example
internal static class Program
{
private static UnityContainer unityContainer;
private static SingleContactManagerForm singleContactManagerForm;
private static void InitializeMainForm()
{
singleContactManagerForm =
unityContainer.Resolve<SingleContactManagerForm>();
}
}
Inversion of Control –
Service Locator
http://www.martinfowler.com/articles/injection.html
34. // UNITY Example
internal static class Program
{
private static UnityContainer unityContainer;
private static SingleContactManagerForm singleContactManagerForm;
private static void InitializeMainForm()
{
singleContactManagerForm =
unityContainer.Resolve<SingleContactManagerForm>();
}
}
Inversion of Control –
Service Locator
http://www.martinfowler.com/articles/injection.html
35. Inversion of Control –
Setter (Property) Injection
// UNITY Example
public class ContactManager : IContactManager
{
[Dependency]
public IContactPersistence ContactPersistence
{
get { return this.contactPersistence; }
set { this.contactPersistence = value; }
}
}
http://www.martinfowler.com/articles/injection.html
36. Property Injection
+ Easy to understand
- Hard to implement robust
* Take if an good default exists
- Limited in application otherwise
37. Method Injection
public 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
39. Ambient Context
public class ContactManager : IContactManager
{
….
public bool Save (….)
{
….
IUser currentUser = ApplicationContext.CurrentUser;
….
}
}
* The Ambient Context object needs to have a default value if not assigned yet.
40. Ambient Context
• Avoids polluting an API with Cross
Cutting Concerns
• Only for Cross Cutting Concerns
• Limited in application otherwise
41. Interception
Public 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.
42. 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)
44. Summary Clean Code - DI
Maintainability is achieved through:
• Simplification, Specialization Decoupling
(KISS, SoC, IoC, DI)
• Dependency Injection
Constructor 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 needed
Configuration by XML for explicit extensibility and post compile setup
• Quality through Testability
(all of them!)
Graphic by Nathan Sawaya
courtesy of brickartist.com
45. Downloads,
Feedback & Comments:
Q & A
Graphic by Nathan Sawaya courtesy of brickartist.com
theo@designitright.net
www.designitright.net
www.speakerrate.com/theoj