StructureMap is a Dependency Injection tool written in C# for .NET development. StructureMap is also a generic “Plugin” mechanism for flexible and extensible .NET applications.

The new functionality in StructureMap 2.5:

• Completely revamped Assembly scanning options
• Cleaner, more predictable way to initialize a Container.  StructureMapConfiguration is now deprecated, please use ObjectFactory.Initialize().
• Optional setter injection
• All new abilities to query the configuration of a Container
• The ability to use StructureMap with ZERO Xml or attributes by default
• The ability to add services at runtime. You can now programmatically add an entire Assembly at runtime for modular applications that might not want all services to be loaded at startup.
• An auto mocking container based on Rhino Mocks 3.5. I was a doubter on the validity of AMC, but I'm sold now that I've used it
• Contextual object construction
• More sophisticated auto wiring rules
• Supporting NameValueCollection and IDictionary types
• Far more extensibility
• Interception and post processing hooks for you AOP enthusiasts. StructureMap will NOT include its own AOP engine, but will allow you to use the runtime AOP technique of your choice.
• More configuration options in both Xml and the Fluent Interface. Completely revamped the Registry DSL.
• More options for modular configuration (mix and match Xml configuration or Registry's at will) – which basically had to trigger:
• Completely revamped diagnostics, including the Environment Testing support
• Transparent creation of concrete types that are not explicitly registered
• Create objects with explicit arguments passed to the container
• Use the underlying Container independently of ObjectFactory
• Pluggable auto registration with your own custom Type scanning policies
• StructureMap is now strong named (thanks to Steve Harman)
• Pull configuration from the App.config (thanks to Josh Flanagan)
• Generics fixes (thanks to Derrick Rapp)

Download it here: http://sourceforge.net/projects/structuremap

I’m using the SVN version for this.

Lets give an example of how to do this.

First we create a few interfaces.

as we can see ITest has a property Person of type IPerson. Ideally we would like to inject the IPerson.

Then we have the concrete classes.

Now I want to inject the Person that I have already made with structureMap.

The first line makes a new registry.
The second line adds a Iperson to the registry with as concretetype Person that is also the default for IPerson with a name of default.
The third line adds an ITest to the registry with as concretetype Test that is also the default for ITest with a name of default and a setterdepency on IPerson that wants the default implementation of IPerson which we declared in line 2.
Line 4 creates the container.

Having done all this we can now see the result via console.writeline (our favorite testrunner ;-))

This should give the following as a result.

test
Person
Person

Simple enough. Very usefull for when you want to inject your observable into a usercontrol. Usercontrols should have a default constructor for the designer, actually it is also the only constructor because the designer can have a difficult time otherwise. This is actually the only reason why I use Setterinjection instead of constructorinjection.

There used to be time when you would configure StructureMap this way

and then this to get your implementation

Fine that all worked nice and dandy but it had a drawback. Structuremapconfiguration was static/shared. This meant that this.

would lead to an error because you could not add classes to structuremap once objectfactory.getinstance was called. But Jeremy and his compadres (sorry musketeers) to the rescue. In the new svn version (not version 2.4.9 apparently) you can do this.

Or something equally brilliant. You can now add things to the container even after calling resolve.

You can find more of this Using the StructureMap Container independently of ObjectFactory by Jeremy and Comparing .NET DI (IoC) Frameworks, Part 2 by Andrey Shchekin