Polaris presentation ioc - code conference

An introduction to DI and IOC using a simple console application.

• Senior Consultant for Polaris Solutions, a technology based
consulting firm based out of Chicago, Denver, and St. Louis.
• Been in software development for almost thirty years,
programming in various languages and operating systems.
• Worked for startups, fortune 500 companies, and consulting
firms.
• A firm believer in the idea that Confucius expressed, “Choose a
job you love, and you will never have to work a day in your life.”
Steven.Contos@PolarisSolutions.com
Blog:TheOldManAndTheCSharp

• We will work through several examples transforming a very simple
program to a very complex program, exploring along the way the
concepts of dependency injection, inversion of control and AOP.
• Present these concepts through examples written in c#,
progressively introducing concepts in a compare and contrast
fashion.
• Learning Objectives:
• What is Inversion of Control and Dependency Injection?
• Are they always paired together?
• See Dependency Injection and Inversion of Control work in a simple scenario.

• https://github.com/polarissolutions/DIIOC_Presentation
• In addition to a master branch, contains branches which align
with the presentation

• Because the dateHelper class creates it’s own instance of the
date object, the class becomes really difficult to test.
• To test you would either need to change the class for a
particular case or set a break point and change during runtime.
• Extremely difficult to unit test, cannot mock up a date object
(yes you can place under a shim context but more difficult)

• A dependency is an object that can be used (a service).
• An injection is the passing of a dependency to a dependent
object (a client) that would use it.
• The service is made part of the client's state.
• Passing the service to the client, rather than allowing a
client to build or find the service, is the fundamental
requirement of the pattern.
• Source - https://en.wikipedia.org/wiki/Dependency_injection
• Can be used independently of IOC Container

• It is more generally accepted to pass an object which
implements an interface, although in our dateHelper class we
are passing a concrete implementation to start.
• Coding against the contract (Interface) allows you to pass any
concrete class which implements the contract.
• Example:
• Public class SQLDBConnection : IDBConnection
• Public class ODBCConnection : IDBConnection
• All classes share the same IDBConnection contract definition.
• Programming against the interface allows you not to worry
about implementation
• Factories can be used to create the concrete class
• IDBConnection = DBFactory(“configfile”)

• Add the following:
• Logger project
• Façade project
• Interfaces project
• Hello project
• Date Print project.

• You can consider an interface a contract which you agree to
implement in a class.
• You can program against the interface / contract instead of a
concrete class.
• Interfaces can exist in as part of the same project (default).
• Interfaces can exist in a separate project from the project that
implements them as long as the project references the interface
project.
• You might use this to publish a list of interfaces publicly that someone
could use to extend the software.

• Inject the dependency through a constructor or method
• The dependency object can be a concrete class created using a
new (new object)
• The dependency object can be a concrete class created as an
interface created using a factory.
• The dependency can be created using a container which will
create the concrete object based of the interface.

• Traditionally the flow of the business logic is determined by
objects that are statically bound (referenced) to one another.
• With inversion of control, the flow depends on the object graph
that is built up during program execution. Such a dynamic flow
is made possible by object interactions being defined through
abstractions.
• In dependency injection, a dependent object or module is
coupled to the object it needs at run time.
• Source - https://en.wikipedia.org/wiki/Inversion_of_control

• Consider using Inversion of Control if you need:
• Significant extensibility
• A generic configuration tool
• Want to support multiple deployment configurations
• Use a Test-Driven Development philosophy or want to largely automate
testing
• Want to isolate a troublesome subsystem or provide smooth migration
paths away from legacy interfaces
• Need a great deal of configurable properties or plugin hot spots
• Break hard dependencies in projects

• Typically objects created can be configured for different life
times:
• Typically:
• Per Request - The default operation. A new instance will be created for each
request.
• Singleton - A single instance will be shared across all requests
• Depending on circumstances:
• Thread Local - A single instance will be created for each requesting thread.
Caches the instances with Thread Local Storage.
• HttpContext - A single instance will be created for each HttpContext. Caches the
instances in the HttpContext.Items collection.
• HttpSession - A single instance will be created for each HttpSession. Caches the
instances in the HttpContext.Session collection. Use with caution.

• Builder object to initialize objects and provide the required
dependencies to the object through a constructor (typically).
• Service Locator pattern introduces a locator object to resolve
dependencies.
• You will see examples of both the Service Locator pattern as
well as Dependency Constructor injection
• https://msdn.microsoft.com/en-us/library/ff921087.aspx

• StructureMap *
• Ninject
• Autofac **
• Microsoft Unity
• Castle Windsor
• Spring.Net
• * Examples in structure map
• ** We may also explore Autofac (time permitting)

• Use NuGet to get proper package for container.
• We will add a new project called Injector.
• Injector will provide ContainerBootStrapper which will be responsible
for wiring up the concrete classes to inject into the classes
constructors.
• The projects which change include:
• DIIOC - using container to return concrete object for logger and
facade.
• DisplayDateClass - Now logs as well and has the logger injected
as part of the constructor.
• The InterfaceClass now has the contracts defined for all
projects.

• We break the dependency of including each object in the
container to resolve.
• Add an example of AOP (Aspect Oriented Programming) where
the real concrete class is wrapped with a similar class as a
proxy and added functionality for centralized functionality.

• To break dependency from the bootstrapper setting the log
parameters, the loggerclass was changed to responsible for
itself.

• Notice class has two constructors.
• Pass in a date object.
• Pass in a date object and a logger object.
• Remember when using IOC the container will typically be
greedy and fill the constructor with the most parameters.
• Internally we have a date factory to return todays date which is
instantiated through the internal IDateFactory interface.
Scanner will automatically map

• So that we did not need to set the current date as part of the
scanner, added a private DateFactory to pass in the current
date.

• You can think of the container as a dictionary of concrete
classes which have a key of the interface
• The Service Locator will return a concrete type using the
interface as the key. Basically a factory pattern. Especially in
the case of the logger which has no dependencies.
• The builder will create not only the concrete class requested but
also the object graph for any dependent objects.

• In computing, aspect-oriented programming (AOP) is a
programming paradigm that aims to increase modularity by
allowing the separation of cross-cutting concerns.
• This allows behaviors that are not central to the business logic
to be added to a program without cluttering the code core to the
functionality.
• Examples include:
• Logging
• Error Handling
• Source - https://en.wikipedia.org/wiki/Aspect-
oriented_programming

• In our StructureMap solution, AOP is
implemented as a Decorator pattern
• In our Autofac solution, AOP is
implemented as a Interceptor pattern

• Since the projects are no longer referenced by the core program (only interface and injector are)
they do not automatically move to the application bin directory. This needs to be done for each
project built.

• You need to set the build order for IOC so that all projects are built first.

• Show example of Injector using:
• AutoFac
• Show in further detail the AOP implementation for Autofac.
• Discuss Unity and XML configuration

• Steven.Contos@PolarisSolutions.com
• www.TheOldManAndTheCSharp.com
• https://www.slideshare.net/StevenContos
• Wikipedia links:
• https://en.wikipedia.org/wiki/Dependency_injection
• https://en.wikipedia.org/wiki/Inversion_of_control
• https://en.wikipedia.org/wiki/Aspect-oriented_programming
• .Net Core – built in dependency injection.
• https://andrewlock.net/using-dependency-injection-in-a-net-core-
console-application

Polaris presentation ioc - code conference

More Related Content

What's hot

Similar to Polaris presentation ioc - code conference

Recently uploaded

Polaris presentation ioc - code conference

Editor's Notes