David Hayden

InjectionFactory in Unity - Register Delegate to Create Object

I think everyone who has used Unity for inversion of control and dependency injection will be very happy to see the new InjectionFactory in Unity 2. Before when you wanted to register a factory ( function / delegate ) with Unity to create an object you had to use the StaticFactoryExtension. Using static factories was way behind the times in terms of what other containers, like Autofac, Windsor, Ninject, etc., could do using simple inline lambda expressions.

InjectionFactory in Unity 2

Microsoft Patterns & Practices has been working diligently on Unity 2 and Enterprise Library 5 and we are seeing all kinds of usability being added to these products. With InjectionFactory one can now use a simple lambda expression when specifying a factory for creating an object. Here is some code using Unity 2 and InjectionFactory to create an instance of IPaymentProcessor using a simple lambda expression:

class Program
{
 static void Main(string[] args)
 {
  var container = new UnityContainer();

  container.RegisterType<IPaymentProcessor>(
   new InjectionFactory ((c) => new PaymentProcessor())
  );

  var processor = container.Resolve<IPaymentProcessor>();
 }
}

public interface IPaymentProcessor { }

public class PaymentProcessor : IPaymentProcessor { }

I think we can all agree that this is much, much better than the previous StaticFactoryExtension. Of course, you can still specify a static method on a class as a factory to create the object:

class Program
{
 static void Main(string[] args)
 {
  var container = new UnityContainer();

  container.RegisterType<IPaymentProcessor>(
   new InjectionFactory ((c) => PaymentProcessorFactory.Create())
  );

  var processor = container.Resolve<IPaymentProcessor>();
 }
}

public static class PaymentProcessorFactory
{
 public static IPaymentProcessor Create()
 {
  // Pretend Some Algortithm Here...
  return new PaymentProcessor();
 }
}

public interface IPaymentProcessor { }

public class PaymentProcessor : IPaymentProcessor { }

Note that you can also pass in the instance of the IUnityContainer into the factory method as well. In fact, you probably will want to use the UnityContainer to create PaymentProcessor as opposed to using the new keyword. Let’s change the code above to use Unity to resolve PaymentProcessor:

class Program
{
 static void Main(string[] args)
 {
  var container = new UnityContainer();

  container.RegisterType<IPaymentProcessor>(
   new InjectionFactory ((c) => PaymentProcessorFactory.Create(c))
  );

  var processor = container.Resolve<IPaymentProcessor>();
 }
}

public static class PaymentProcessorFactory
{
 public static IPaymentProcessor Create(IUnityContainer container)
 {
  // Pretend Some Algortithm Here...
  return container.Resolve<PaymentProcessor>();
 }
}

public interface IPaymentProcessor { }

public class PaymentProcessor : IPaymentProcessor { }

Conclusion

Lots of interesting changes coming to Unity 2 and Enterprise 5. Hopefully they will be released around mid-to-late April along with Visual Studio 2010. Check my presentations for upcoming Enterprise Library and Unity Presentations in Florida. As soon as the  code stabilizes I will create screencasts on Patterns & Practices Guidance.

Hope this helps.

David Hayden

Automatic Factories in Unity 2 - Unity 2 Tutorials and Samples

In Unity 2 there is the concept of Automatic Factories to allow classes or services to defer instantiation of their dependencies to the last possible moment. This is particularly useful when the dependency is expensive to create and is not always used by the service. Think of it as lazy loading of dependencies just like we have lazy loading in O/R Mappers.

I mentioned similar functionality in Autofac in the following tutorial: Auto-Generated Factories in Autofac for Lazy Instantiation - LazyDependencyModule. I recommend you read that tutorial as it talks more about the concepts, etc., whereas here I will only mention a few comments and show you an example. Autofac also goes a bit further than Unity 2 by supporting Lazy<T> and Lazy<T,TMetadata> when using Autofac with the .NET Framework 4.

Automatic Factories in Unity 2

The example below shows Unity resolving a NewsController with a dependency on Func<Publisher> in its constructor. The idea here is that we are pretending that Publisher is expensive to create and we only want to resolve it on demand at time of use when the News is being published.

We do not have to register Func<Publisher> in the UnityContainer. Unity will automatically create a delegate matching that signature for us at runtime. The delegate will essentially do a container.Resolve<Publisher> on our behalf, allowing us to lazy load the Publisher without having a dependency on the container itself.

Here is some Unity 2 sample code:

class Program
{
 static void Main(string[] args)
 {
 var container = new UnityContainer();
 var controller = container.Resolve<NewsController>();

 controller.Publish(new News());

 Console.ReadLine();
 }
}


public class NewsController
{
 private readonly Func<Publisher> _getPublisher;

 public NewsController(Func<Publisher> getPublisher)
 {
 _getPublisher = getPublisher;
 }

 public void Publish(News news)
 {
 _getPublisher().Publish(news);
 }
}

public class Publisher
{
 public void Publish(News news)
 {
 Console.WriteLine("Published...");
 }
}

public class News { }

That's all there is to it. With a few small changes the Publisher is now being resolved on demand just when you need it.

Conclusion

I'll be giving a number of presentations on Enterprise Library 5 and Unity 2 this year at various Florida Code Camps and Florida .NET Developer Groups. First up is the South Florida Code Camp and then later I have presentations scheduled for IASA Tampa, Sarasota .NET Developer Group, and more to come.

Hope this helps.

David Hayden