This here coffee machine is konked!

Recoil 1.1.0 released!

Posted on October 9, 2009. Filed under: .NET, Programming, Recoil | Tags: .NET 3.5, Fluent Interface, IoC, Recoil, Spring.NET |

NEWSFLASH! Recoil 1.1.2 is the latest version clikety click.

That’s right, after some two weeks of testing, meditation and refactoring, Recoil can be considered stable for wide adoption. Most of the changes since 1.0.0 are bug fixes when wiring nested object definitions, but that is definitely not all. All public API is now fully documented and mainly the property wiring mechanism has been unified to be less confusing.

You can grab the latest version right here. A getting started guide and some examples can be found here.

Now that Recoil is stable and the basic functionality is there, the idea is to start adding all the goodies. Right now we have the following on the list:

• Fluent proxy/advice configuration
• Non-generic interfaces for programmatic configuration
• Fluent interface for exporting web services
• Convention instead of configuration features

“But wait Tom, what the hell is this whole Recoil malarkey? I’m so confused that questionmarks are pouring out of my ears!”

Ah well…

What is Recoil?

Recoil is a fluent interface extension for Spring.NET. It provides an easy to use framework to define your object wirings in code, so they can be checked at compile time and you can continue to leverage the power of refactoring tools such as Resharper (which are reduced quite significantly when you have to manually rewire/rename objects in XML).

Recoil allows you to turn this:

 <object id="MyAssembly.MyNamespace.IBar"
      type="MyAssembly.MyNamespace.BarFactory,  MyAssembly"
      factory-method="Create">
    <property name="TestProperty" value="TestValue"/>
    <property name="ListProperty">
           <list element-type="MyAssembly.MyNamespace.Foo">
                   <object type="MyAssembly.MyNamespace.Foo>
                          <constructor-arg name="Name" value="A Foo" />
                   </object>
                   <ref object="SpecialFoo"/>
           </list>
    <property/>
</object>

Into this:

Define(() => BarFactory.Create())
            .As<IBar>()
            .Set(b => b.TestProperty).To(() => "TestValue")
            .Set(b => b.ListProperty).To(() => new List {
                                                            new Foo("A Foo),
                                                            Wire<IFoo>("SpecialFoo")
                                                        });

The in-code object definition can be compile time checked, allows the developer to make full use of intellisense and refactoring tools and is easier to navigate as well (less text). I’ve actually hidden a typo in the XML object definition, see how easily you can spot it. If you manage under 15 seconds, congratulations, you must have been staring at XML way too much in your life. The ability to mentally validate xml will surely make you stand apart from the rest of the crowd though.

“But why extend Spring.NET, there are many IoC containers with fluent interfaces, and they are all free, cool and in.”

Because Spring.NET has a vast array of tools to make enterprise software development smoother and easier. While there are many frameworks which provide a subset of Spring.NET’s functionality, to this day it remains one of the most comprehensive frameworks for .NET.  The only fad that was still missing is a fluent interface, and since I was tooling around with Expressions anyway (which are a core part of Recoil), I decided to take the dive and create Recoil. The final objective is to integrate Recoil into the Spring.NET framework itself, so that everyone can use the fluent interface straight out of the box!

Happy wiring!

Make a Comment

16 Responses to “Recoil 1.1.0 released!”

Comments RSS Feed

Where's The Comment Form?