Recoil 1.1.3 – Need your initializer method & configuration inheritence fix?

Posted on November 2, 2009. Filed under: Uncategorized |

Knock yourself out with inheriting configurations and setting initializer methods right here.

Special thanks go out to Graham Nash and Maxim Klyuchnikov who contributed these features, very much appreciated guys. May thousands upon thousands of dollars shower down on you for a hundred years to come (and may the notional of this blessing rise at a value of inflation + 2%)!


Read Full Post | Make a Comment ( 1 so far )

Woah, another release? Recoil 1.1.2

Posted on October 21, 2009. Filed under: .NET, Programming, Recoil |

In a stunning streak of programming that involved adding a single property that returns a constant value, Recoil now supports config placeholders (e.g. ${FancyPlaceholder}) in the fluent interface!

Thanks, cheers and a bottle of beer fly out to maxnk who suggested a quick patch.

As always, you can greedily grab the generous package here.


Read Full Post | Make a Comment ( 3 so far )

Recoil 1.1.1 – fixes deeply nested objects behavior

Posted on October 16, 2009. Filed under: .NET, Programming, Recoil |

I noticed a bizarre bug with Recoil 1.1.0 when nesting an object with multiple constructor arguments in a dictionary that is nested in another object that gets wired into yet another object. How bizarre. Anyhoo, it has been fixed in 1.1.1 and I introduced yet another test example to weed out problems of similar kind. Click here to make your wildest dreams come true (hint: download).


Read Full Post | Make a Comment ( None so far )

Recoil 1.1.0 – now with strong named assemblies

Posted on October 14, 2009. Filed under: .NET, Programming, Recoil |

Good news everyone!

You can now download the strongly named Recoil assemblies – clickety click here. There are no other changes so you don’t need to do anything unless you need them signed.

(I also made you read this out in the Prof’s voice!)


Read Full Post | Make a Comment ( None so far )

Recoil 1.1.0 released!

Posted on October 9, 2009. Filed under: .NET, Programming, Recoil | Tags: , , , , |

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!


Read Full Post | Make a Comment ( 16 so far )

Liked it here?
Why not try sites on the blogroll...