Grigori Melnik: Thoughts on Agile Software Engineering and Beyond : dependency injection

Dependency Injection pattern in APIs

gmelnik — Fri, 13 Nov 2009 00:44:20 GMT

My colleague and friend Chris Tavares, who is the Dev Lead on Enterprise Library and Unity, published an insightful article in MSDN magazine on the usage of DI in APIs, which I highly recommend. It is based on our recent experience of doing architectural refactoring of the Enterprise Library. It outlines our design objectives and the approach taken to meet them. It concludes with lessons learnt and key considerations when designing your own API or framework.

Read Chris’s article here.

Unity 2.0 container update

gmelnik — Thu, 16 Jul 2009 21:18:56 GMT

Our latest work on Unity 2.0 is available on Codeplex (see change set 28516). This is the first work we’ve done on Unity as part of the EntLib5.0 effort.

Major changes in this drop include:

ObjectBuilder2 DLL is now gone. The code is now completely contained in the Unity assembly, and you won't need to reference OB2 anymore in your projects using Unity. Over time the ObjectBuilder stuff is going to lose a lot of it's generality and be just the underpinnings for the container.
We're taking a first cut at fixing our exception messages. All the extra BuildFailedException’s that ended up in the inner exception tree are now GONE. Instead, you get a top level ResolutionFailedException, and the InnerException is the actual exception that caused resolution to fail. And the exception message has been reformatted significantly to hopefully get a better description of what the container was doing, and how it ended up where it did, when the error occurred. This is in response to user feedback to provide better error messaging in Unity. We consider this to be a significant improvement, but still need your feedback. In particular, we look forward to specific suggestions about how we could change the messages to be even more descriptive and intuitive. Please reply to this post or via Codeplex discussion thread.
Silverlight projects are now updated to Silverlight 3.

Just Released: Unity Application Block 1.2 for Silverlight

gmelnik — Sun, 14 Dec 2008 11:01:41 GMT

If you are building rich application experiences in Silverlight, you can now use the power of dependency injection. It was possible to use Unity on Silverlight before, but you had to make some tweaks since Silverlight has some differences from the desktop common language runtime (CLR). We are happy to announce the official release of Unity for Silverlight.

The following capabilities and packaging of the Unity container have been adjusted in this release:

The single Microsoft.Practices.Unity.dll file in the Silverlight version contains all the classes from the three separate desktop DLLs: Microsoft.Practices.Unity.dll, Microsoft.Practices.ObjectBuilder2.dll, and Microsoft.Practices.Unity.StaticFactoryExtension.dll. You only need to reference and deploy the one assembly in your Silverlight projects.
Because of differences in the Silverlight security model, only public types can be created and injected by the container. The desktop version allows you to also inject internal types.
XML configuration is not supported.
The Unity interception mechanism is not supported.

An updated quickstart is also included.

See Chris’s post for more details on how this release was produced.

As always, submit your feedback and/or questions via Unity community forum.

Merry Christmas! and … Joyous Coding!

What is Enterprise Library team currently up to?

gmelnik — Fri, 12 Dec 2008 01:10:00 GMT

After shipping Enterprise Library v4.1, the team is focusing on the ease-of-use and learnability aspects of both EntLib and Unity. Our top stories of the current backlog include the following:

Unity for Silverlight [Done - 12/14/2008]
Comprehensive Enterprise Library FAQs [Done - 2/10/2009]
Validation Block Hands-on Lab [Done - 1/3/2009]
Interception Hands-on Lab [Done - 3/18/2009]
Unity Extensibility documentation [In Dev]
New video on Unity (level 200)
New video on Unity Extensibility (level 400)
Customer satisfaction survey analysis [Done]

These are all things we plan on doing prior to starting Enterprise Library v5 research and planning work early next year.

EntLib4.1 kickoff

gmelnik — Mon, 04 Aug 2008 06:13:00 GMT

On July 31 we have kicked off the EntLib4.1 and Unity 1.2 project. This is a minor service release. In it, we address several bugs and enhancements, and provide the following features:

- Collections support in the Unity Application Block (Unity dependency injection container)

- Improved support for generics in Unity

- Interception mechanism in Unity (including integration with the Policy Injection Application Block)

- Improved type picker of the config tool (this one needed a face lift for a long time)

- Debugging visualizer (to allow for easy navigation of mappings, corresponding lifetime policies as well as container extensions).

We also plan on doing rigorous testing on 64-bit machines. I’ll post a complete backlog on Codeplex soon.

We intend to release regular community previews at the end of each iteration (biweekly).

I am excited to continue working with several people from the previous release (Chris, Fernando, Vijaya) and also welcome new team members: Erik and Dennis. Alex, Hanz, and Carlos take on the roles of consultants. This is an amazing team! At the end of the first day we already had two user stories done-done.

Codeplex discussions remain the primary venue for posting your feedback. Keep it coming.

Webcasts demos

gmelnik — Fri, 11 Jul 2008 15:35:00 GMT

The demo from the Enterprise Library 4.0 webcast we did yesterday is posted on Codeplex.

Now can also find the demos from the webcasts on Unity here.

Webcasts on EntLib4 and Unity

gmelnik — Thu, 19 Jun 2008 00:35:00 GMT

We are planning three webcasts on EntLib4 and Unity. Pencil in the tentative dates:

§ Taking advantage of Microsoft Enterprise Library 4.0 for Visual Studio 2008 (Level 200 – Intro)

July 10, 13:00-14:30pm Pacific

§ Introduction to dependency injection with Unity (Level 200 – Intro)

July 11, 12:00-13:00 Pacific

§ Extending the Unity dependency injection container (Level 400 – Advanced)

July 24, 13:00-14:30 Pacific

We’ll be doing lots of demos of the goodness in EntLib and Unity. I’ll post the links to the registration site as soon as they become available on MS Events.

Cheers,

Grigori

Unity refresh (v1.1)

gmelnik — Sat, 17 May 2008 08:40:00 GMT

In addition to the release of the Enterprise Library 4.0, the patterns & practices team is happy to announce the release of the Unity dependency injection container v1.1.

Quick Links:

– MSDN site: http://msdn.microsoft.com/unity

– Community Forum: http://codeplex.com/unity

– Community Extensions: http://codeplex.com/unitycontributions

What’s New in Unity 1.1?

– Remove all obsolete ObjectBuilder code;

– Fix the bug: lifetime managers with open generic types;

– Fix the bug: RegisterType was overriding RegisterInstance;

– Performance improvement when resolving singletons;

– Made some internal classes public to make it easier to write certain type of extensions (the ones that need to customize how the dependencies are resolved;

– Improved error messages when value resolution fails.

What’s NOT in Unity yet?

– Interception mechanism is not implemented yet; it is on top of our Unity backlog though;

– Policy Injection Application Block can still be used if AOP functionality is needed;

– No tool support for DI configuration.

As always, your feedback is invited. Please post your stories, questions, screams on Codeplex. We are listening!

Cheers,
Grigori

Unity DI container 1.0 shipped!

gmelnik — Sat, 05 Apr 2008 02:09:00 GMT

Microsoft patterns & practices is excited to announce the release of Unity 1.0.

As many of you already know, Unity is a lightweight, extensible dependency injection (DI) container. It facilitates building loosely coupled applications and provides .NET developers with the following advantages:

Simplified object creation, especially for hierarchical object structures and dependencies;
Abstraction of requirements; this allows developers to specify dependencies at run time or in configuration and simplify management of crosscutting concerns;
Increased flexibility by deferring component configuration to the container;
Service location capability; this allows clients to store or cache the container.

You can download Unity (binaries, source code, unit tests, documentation, and quickstarts) from:

http://msdn.microsoft.com/unity

The Unity team thanks our Industry Advisory Board and all members of the community who provided meaningful feedback in the past 3 months. We encourage you to continue doing so and engage on http://codeplex.com/unity

Unity container: resolving non-public objects

gmelnik — Wed, 02 Apr 2008 04:10:00 GMT

If you care, please read the following thread posted on Codeplex: http://www.codeplex.com/unity/Thread/View.aspx?ThreadId=25123 and comment on the path we are taking to address the issue with injecting and resolving non-public types in partial trust scenarios.

Thanks!

Unity project heartbeat

gmelnik — Wed, 05 Mar 2008 06:43:00 GMT

Those who follow the work of our team on Unity have probably noticed a certain rhythm we follow – of weekly Unity CTP drops on Tuesdays. Today, we did another one. It has some changes to the API (described at http://www.codeplex.com/unity/Release/ProjectReleases.aspx?ReleaseId=11319). Please check it out and provide us with your feedback. The community involvement (through codeplex) has been quite meaningful. Keep sending your comments and voting on existing work items on codeplex.

Unity February 2008 Community Technology Preview

gmelnik — Wed, 13 Feb 2008 03:12:00 GMT

Friends! Today we have released the February 2008 Community Technology Preview of Unity, our lightweight extensible dependency injection container (it's truly lightweight - to use it, you only need to include 2 assemblies totalling about 100K). Get it from Codeplex: http://www.codeplex.com/unity. It comes with all source, test cases, a couple of examples/quickstarts and an initial set of docs. We look forward to your feedback. Don’t wait for too long. Our final release is on March 15.

Also, as a reminder, registration for the Unity Extensibility Workshop closes on February 15. Your participation is invited. If you want to jam with the Unity authors and other developers who are interested in building extensions for Unity, this is a great opportunity.

DIAB is now Unity

gmelnik — Tue, 15 Jan 2008 03:19:00 GMT

First of all, we finally came up with a name for the DI container we are building. A drum roll, please… We’ve decided to call it “Unity” as a container that epitomizes a quality of one (system) being, comprising, or consisting of a number (of parts/components). It may not be as descriptive as other blocks but it fits with our vision. We also wanted to distinguish it from other application blocks.

A short description of Unity is a lightweight, extensible dependency injection container.

Unity will provide mechanisms for building instances of objects, which may contain other dependent object instances.

Unity will expose Register methods that support configuring the container with mappings and objects (including singleton instances), and Get methods to return instances of built objects that contain any dependent objects. Note we have purposefully designed the API to support the “fluent interface” pattern. Here’s a preview of the fundamental features of the Unity API, these are very tentative as we are still working on the semantics:

public class UnityContainer : IDisposable {

// getting objects

public T Get<T>(string key){}

public IEnumerable<T> GetAll<T>(){}

// type mapping

public UnityContainer Register<TFrom, TTo>(string key) where TTo : TFrom {}

// singleton support

public UnityContainer SetSingleton<T>(string key) {}

// support for registering existing objects

public UnityContainer RegisterInstance<T>(T existing, string key, bool overload) {}

// running existing objects through the container

public T BuildUp<T>(T existing, string key){}

}

There are also overloads for non-generics.

So, a typical usage scenario will be:

UnityContainer container = new UnityContainer()

.Register<ILogger, TraceLogger>()

.Register<ISomething, Something>()
.Register<ISomethingElse, SomethingElse>();

container.Get<ISomething>();

As mentioned in our previous postings, Unity will be released in two forms - standalone container and as a part of Enterprise Library 4, with the existing blocks refactored to take advantage of Unity.

Unity will support extensibility via the ContainerExtension mechanism to allow third parties to add support for other on-demand features at runtime, such as event broker.

Enterprise Library product backlog

gmelnik — Wed, 09 Jan 2008 03:00:00 GMT

I've posted the current EntLib4 product backlog with prioritized stories on Codeplex: http://www.codeplex.com/entlib/Wiki/View.aspx?title=EntLib4%20Backlog

There are two main areas we are working on: introducing the dependency injection block (which I blogged about in my previous post ) and making enhancements to the existing blocks. As always, community feedback is welcomed.

-- Grigori

Making Dependency Injection Simpler in EntLib 4

gmelnik — Tue, 04 Dec 2007 05:51:00 GMT

The benefits of modular design with cohesive components that have little or no coupling to the rest of the software system are commonly recognized today. Dependency injection is a mechanism that facilitates such aggressive decoupling and independence of components. Lightweight dependency injection containers (such as StructureMap, Spring.NET, or Castle Windsor) help assemble components (potentially from different projects) into a cohesive application at runtime and promote code reuse. An introduction to dependency injection can be found in this article by Martin Fowler.

The values of modular design implemented with support of dependency injection have been long recognized and embraced by Microsoft patterns & practices. Originally, implemented for the Composite UI Application Block (CAB) and later for the Enterprise Library v2 (back in early 2006), the ObjectBuilder pipeline allows to customize how objects are created at runtime. The current Enterprise Library configuration system is based on a DI container created using ObjectBuilder (Brian Button has written an excellent post on how Enterprise Library used ObjectBuilder).

With the upcoming version of EntLib (v4), we are planning to provide containers (flat and hierarchical) that will support dependency injection out of the box. These containers will be packaged individually and also with EntLib v4. Furthermore, to demonstrate the effective use of dependency injection on a real world project, we plan to refactor individual EntLib blocks and abstract away configuration code (configurators). We will build an EntLib façade that will have individual configurators injected in it as needed. A client app can go through this façade to request services while all wiring of objects necessary for those services to run will be handled by the DI container. This will not only make the design cleaner but will also make it easier to use and configure only those application blocks that you desire.

Once refactored, the EntLib blocks can be used as a la carte with other DI containers – some updating of the façade would be necessary and we invite the EntLib enthusiasts to port the EntLib façade to individual containers. Swapping DI containers means organizations can leverage their existing infrastructure.

For those who wish to continue to use the EntLib the way they always had, the current public API of EntLib will NOT be broken.

We believe that these changes will not only add well-desired functionality to the list of p&p assets, but further promote the principles of good architectural design.

Of course, we’d like to hear from you: comments, ideas, screams….