The Petite library contains a couple of things I often need when I set up a new project. Two main parts at the moment, the Petite Container and the Petite Repository base classes.
The Petite Container is a very light-weight container that only covers the very basic needs. It is inspired mainly by Funq and Munq, but has even less bells and whistles.
var container = new Container(); // Simple case container.Register<IMyDependency>(c => new MyDependencyImplementation()); // Will get you an instance of MyDependencyImplementation var myDependency = container.Resolve<IMyDependency>(); // Using nested dependencies container.Register<IMyService>( c => new MyServiceImplementation( c.Resolve<IMyDependency>() )); // Will get you an instance of MyServiceImplementation (in it's turn // created with a new instance of MyDependencyImplementation) var myService = container.Resolve<IMyService>(); // We also support Singletons out-of-the-box container.RegisterSingleton<IMySingleton>(c => new MySingletonImplementation()); // Both of these will be the same instance var mySingleton = container.Resolve<IMySingleton>(); var sameSingleton = container.Resolve<IMySingleton>(); // You can also register an existing instance as a singleton if you're into that var myInstance = new MyOtherSingletonImplementation(); container.RegisterInstance<IMyOtherSingleton>(myInstance); // This will be the same as myInstance var otherSingleton = container.Resolve<IMyOtherSingleton>();
Note that all registration methods seen here are actually extension methods found in the
you therefore need to make sure you are
using Petite; since they won't be picked up otherwise.
If you need another kind of lifetime manager (or ServiceHandler as they are called in Petite), feel free
to write your own deriving from
ServiceHandlerBase<TService>. You should then probably create your own extension
methods to handle the registration in the same way as the rest of the overloads are handled.
Also note that it would be quite possible to create a ServiceHandler that doesn't use factory methods. If you feel adventurous, please try to do something different - perhaps it could be released as Petite.Container.AutoRegistration or something like that.
Petite Repository is divided into two separate files, Domain and Data. The Domain file contains just the IRepository and the IObjectContext interfaces. The Data file has base class implementations of those interfaces as well as an ObjectContext adapter that can be used within a WCF service.
The Petite Repository is probably best explained with a sample project or two. I'll try to get around to that..
And that is pretty much it for now. Feel free to fork and send me a pull request or two!
- Test everything in a real-world scenario. (ongoing)
- Make SingletonServiceHandler thread-safe
- Compatibility with Silverlight
- Take over the world