Dependency injection with unity 2.0 Dmytro Mindra Lohika

1. Dependency Injection with Unity 2.0 DmytroMindra RnD Tech Lead Lohika Вторая встреча Microsoft .Net User Group Одесса, 2010

2. Goal Get DI understanding Get Unity 2.0 understanding Learn how to add Unity 2.0 to your projects

3. Plan Inversion of Control principle (IoC) Dependency Injection pattern (DI) Unity 2.0 Live Demo

4. Problem

5. Problem We live in an age where writing software to a given set of requirements is no longer enough. We have to maintain and change existing code.

6. How? Our solutions should be: Modular Testable Adaptive to change

7. Terms Service —An object that performs a well-defined function when called upon Client—Any consumer of a service; an object that calls upon a service to perform a well-understood function

8. Terms Dependency —A specific service that is required by another object to fulfill its function. Dependent—A client object that needs a dependency (or dependencies) in order to perform its function.

9. PRE DI APPROACHES

10. Ex1:Composition

11. Ex1:Composition public class SpellCheckerService{} public class TextEditor { private SpellCheckerService _spellCheckerService; public TextEditor() { _spellCheckerService = new SpellCheckerService(); } } class Program { static void Main(string[] args) { TextEditor textEditor = new TextEditor(); } }

12. What’s good It’s simple

13. What’s bad It’s not testable It’s hard to maintain/change

14. Ex2: Factory

15. Ex2: Factory public interface ISpellCheckerService { string CheckSpelling(); }

16. Ex2: Factory public class SpellCheckerService: ISpellCheckerService { public string CheckSpelling() { return “Real”; } }

17. Ex2: Factory public class SpellCheckerFactory { private static ISpellCheckerService _spellCheckerService = new SpellCheckerService(); public static ISpellCheckerServiceSpellCheckerService { get{ return _spellCheckerService; } set{ _spellCheckerService = value; } } }

18. Ex2: Factory public class TextEditor { private ISpellCheckerService _spellCheckerService; public TextEditor() { _spellCheckerService = SpellCheckerFactory.SpellCheckerService; } public string CheckSpelling() { return _spellCheckerService.CheckSpelling(); } }

19. Ex2:Factory Unit Testing public class SpellCheckerServiceMock: ISpellCheckerService { public string CheckSpelling() { return “Mock”; } }

20. Ex2:Factory Unit Testing [TestFixture] class EmailerFactoryUnitTests { [Test] public void EmailerFactoryTest() { ISpellCheckerServicemockSpellCheckerService = new SpellCheckerServiceMock(); SpellCheckerFactory.SpellCheckerService = mockSpellCheckerService; TextEditortextEditor = new TextEditor(); Assert.AreEqual(“Mock”, textEditor.CheckSpelling()); } }

21. Ex2: Factory

22. What changed TextEditor is still looking for its dependencies by itself. But now we can plug in different services without letting him know.

23. What’s good It’s testable It’s easier to maintain/change

24. What’s bad You have to maintain factory or service locator Dependent is still looking for Dependencies by himself. Dependencies are encapsulated and are not obvious.

25. Service Locator Unfortunately, being a kind of Factory, Service Locators suffer from the same problems of testability and shared state.

26. Inversion of Control Common Flow TextEditor creates its dependency by himself. IoC Flow TextEditor requests factory to create dependency for him.

27. Inversion of Control Hollywood Principle: Don’t call me, I’ll call you

28. Inversion of Control IoC – is a common characteristic of frameworks. Inversion of Control serves as a design guideline. According to Martin Fowler the etymology of the phrase dates back to 1988.

29. Two principles of IOC Main classes aggregating other classes should not depend on the direct implementation of the aggregated classes. Both the classes should depend on abstraction. Abstraction should not depend on details, details should depend on abstraction.

30. Inversion of Controlas a Design Guideline Without IoC With IoC Loose coupling

31. Time TO INJECT !

32. Ex3:Dependency Injection public class TextEditor { private readonlyISpellCheckerService _spellCheckerService; public TextEditor(ISpellCheckerServicespellCheckerService) { _spellCheckerService = spellCheckerService; } public string CheckSpelling() { return _spellCheckerService.CheckSpelling(); } }

33. Ex3: Unit Testing DI Almost same as for Ex2 // Mock ISpellCheckerService mock = new SpellCheckerServiceMock(); // Instantiate TextEditortextEditor = new TextEditor(mock); // Check Assert.AreEqual(“Mock”, textEditor.CheckSpelling());

34. What changed TextEditor lost its “Sovereignty” and is not able to resolve dependencies by himself.

35. What’s good Dependencies are obvious. Dependency resolution is not encapsulated. Unit Testing got little bit easier Architecture is much better

36. What’s bad We are resolving dependencies manually while creating instances of TextEditor.

37. Dependency Injection

38. Dependency Injection DI is IoC Inversion of Control is too generic a term DI pattern – describes the approach used to lookup a dependency. Dependency resolution is moved to Framework.

39. Ex4: Unity

40. Ex4: Unity using Microsoft.Practices.Unity; UnityContainer container = new UnityContainer(); container.RegisterType<ISpellCheckerService, SpellCheckingService>(); TextEditortextEditor = container.Resolve<TextEditor>();

41. What changed Unity container now resolves dependencies

42. What’s good Automated dependency resolution

43. Unity methods RegisterType RegisterInstance Resolve BuildUp

44. Ex5: Unity Configuration <configSections> <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/> </configSections> <unity xmlns="http://schemas.microsoft.com/practices/2010/unity"> <alias alias="ISpellCheckerService" type="Unity.Config.ISpellCheckerService, Unity.Config" /> <alias alias="SpellCheckingService" type="Unity.Config.SpellCheckingService, Unity.Config" /> <namespace name="Unity.Config" /> <assembly name="Unity.Config" /> <container> <register type="ISpellCheckerService" mapTo="SpellCheckingService" /> </container> </unity>

45. Ex5: Unity Configuration using Microsoft.Practices.Unity;using Microsoft.Practices.Unity.Configuration;UnityContainer container = new UnityContainer();container.LoadConfiguration();TextEditor textEditor = container.Resolve<TextEditor>();

46. Dependency tree

47. Ex6: Dependency tree public interface IAdditionalDependency{} public class AdditionalDependency : IAdditionalDependency{} public class SpellCheckingService: ISpellCheckerService { public SpellCheckingService( IAdditionalDependency dependency){} }

48. Ex6: Dependency Tree UnityContainer container = new UnityContainer();container.RegisterType<ISpellCheckerService, SpellCheckingService>();container.RegisterType<IAdditionalDependency, AdditionalDependency>();TextEditor textEditor = container.Resolve<TextEditor>();

49. Ex6: Dependency tree

50. Injection Types Constructor Injection Setter injection Method call injection

51. Ex7: Defining Injection Constructor public class TextEditor { private readonly ISpellCheckerService _spellCheckerService; [InjectionConstructor] public TextEditor(ISpellCheckerService spellCheckerService) { _spellCheckerService = spellCheckerService; } public TextEditor(ISpellCheckerService spellCheckerService,string name) { _spellCheckerService = spellCheckerService; } }

52. Ex8: Property Injection public class TextEditor { public ISpellCheckerService SpellCheckerService {get; set;} [Dependency] public ISpellCheckerService YetAnotherSpellcheckerService{get;set;} } UnityContainer container = new UnityContainer(); container.RegisterType<TextEditor>(new InjectionProperty("SpellCheckerService")); container.RegisterType<ISpellCheckerService, SpellCheckingService>(); TextEditor textEditor = container.Resolve<TextEditor>();

53. Ex9: Method call injection public class TextEditor { public ISpellCheckerService SpellcheckerService {get; set;} [InjectionMethod] public void Initialize (ISpellCheckerService spellcheckerService) { _spellCheckerService = spellcheckerService; } } UnityContainer container = new UnityContainer();//container.RegisterType<TextEditor>( new InjectionMethod("SpellcheckerService"));container.RegisterType<ISpellCheckerService, SpellCheckingService>();TextEditor textEditor = container.Resolve<TextEditor>();

54. Lifetime Managers TransientLifetimeManagerReturns a new instance of the requested type for each call. (default behavior) ContainerControlledLifetimeManagerImplements a singleton behavior for objects. The object is disposed of when you dispose of the container.

55. Lifetime Managers ExternallyControlledLifetimeManagerImplements a singleton behavior but the container doesn't hold a reference to object which will be disposed of when out of scope. HierarchicalifetimeManagerImplements a singleton behavior for objects. However, child containers don't share instances with parents.

56. Lifetime Managers PerResolveLifetimeManagerImplements a behavior similar to the transient lifetime manager except that instances are reused across build-ups of the object graph. PerThreadLifetimeManagerImplements a singleton behavior for objects but limited to the current thread.

57. Ex10: Unity Singleton UnityContainer container = new UnityContainer();container.RegisterType<ISpellCheckerService, SpellCheckingService>(new ContainerControlledLifetimeManager());TextEditor textEditor = container.Resolve<TextEditor>();

58. Container Hierarchy

61. Performance

62. Performance

63. Performance

64. .NET DI Frameworks Unity 2.0 AutoFac 2.3.2 StructureMap 2.6.1 Castle Windsor 2.1 Ninject 2.0

65. Additional reading

66. Additional reading

67. Live Demo

68. Questions ?

69. Thank YOU !