I have been wanting to have a play
with Object Databases for a while now, and today
I have done just
that. One of the obvious choices
I had to make was which one to use. My criteria for choosing one today was simple,
I wanted one which
I could literally wack in and start using, which means
I wanted one which either had a .NET API or was designed/ported to .NET. My decision was between two being: db4o MongoDb
I went for db4o for the single reason
that it looked like
I could get it running and integrated the quickest.
I am making a Blogging application and front end as a project
with which
I can test and learn
with these object databases. Another requirement which
I thought
I would mention is
that I also want to be able to use the said database in a shared hosting environment where
I cannot install, run and maintain a server instance of said object database.
I can do exactly this
with db4o.
I have not tried to do this
with MongoDb at time of writing. There are quite a few in the industry now and you read an interesting post about different ones and how they are used
with some of the heavy weights in the industry here : http://blog.marcua.net/post/442594842/notes-from-nosql-live-boston-2010 In the example which
I am building
I am using StructureMap as my IOC. To inject the object for db4o
I went
with a Singleton instance scope as
I am using a single file and
I need this to be available to any thread on in the process as opposed to using the server implementation where
I could open and close client connections
with the server handling each one respectively. Again
I want to point out
that I have chosen to stick
with the non server implementation of db4o as
I wanted to use this in a shared hosting environment where
I cannot have such servers installed and run. public static class Bootstrapper { public static void ConfigureStructureMap() { ObjectFactory.Initialize(x => x.AddRegistry(new MyApplicationRegistry())); } } public class MyApplicationRegistry : Registry { public const string DB4O_FILENAME = "blog123"; public string DbPath { get { return Path.Combine(Path.GetDirectoryName(Assembly.GetAssembly(typeof(IBlogRepository)).Location), DB4O_FILENAME); } } public MyApplicationRegistry() { For<IObjectContainer>().Singleton().Use( () => Db4oEmbedded.OpenFile(Db4oEmbedded.NewConfiguration(), DbPath)); Scan(assemblyScanner => { assemblyScanner.TheCallingAssembly(); assemblyScanner.WithDefaultConventions(); }); } } So my code above is the structure map plumbing which
I use for the application.
I am doing this simply as a quick scratch pad to play around
with different things so
I am simply segregating logical layers
with folder structure as opposed to different assemblies. It will be easy if
I want to do this
with any segment but for the purposes of example
I have literally just wacked everything in the one assembly. You can see an example file structure
I have on the right.
I am planning on testing out a few implementations of the object databases out there so
I can program to an interface of IBlogRepository One of the things which
I was unsure about was how it performed under a multi threaded environment which it will undoubtedly be used 9 times out of 10, and for the reason
that I am using the db context as a singleton,
I assumed
that the library was of course thread safe but
I did not know as
I have not read any where in the documentation, again this is probably me not reading things correctly. In short though
I threw together a simple test where
I simply iterate to a limit each time kicking a common task off
with a thread from a thread pool. This task simply created and added an random Post and added it to the storage. The execution of the threads
I put inside the Setup of the Test and then simply ensure the number of posts committed to the database is equal to the number of iterations
I made; here is the code
I used to do the multi thread jobs: [TestInitialize]
public void Setup()
{
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
var resetEvent = new ManualResetEvent(false);
ThreadPool.SetMaxThreads(20, 20);
for (var
i = 0;
i < MAX_ITERATIONS; i++)
{
ThreadPool.QueueUserWorkItem(delegate(object state)
{
var eventToReset = (ManualResetEvent)state;
var post = new Post
{
Author = MockUser,
Content = "Mock Content",
Title = "Title"
};
Repository.Put(post);
var counter = Interlocked.Decrement(ref _threadCounter);
if (counter == 0)
eventToReset.Set();
}, resetEvent);
}
WaitHandle.WaitAll(new[] { resetEvent });
sw.Stop();
Console.WriteLine("{0:00}.{1:00} seconds", sw.Elapsed.Seconds, sw.Elapsed.Milliseconds);
}
I was not doing this to test out the speed performance of db4o but while
I was doing this
I could not help but put in a StopWatch and see out of sheer interest how fast it would take to insert a number of Posts.
I tested it out in this case
with 10000 inserts of a small, simple POCO and it resulted in an average of:
899.36 object inserts / second.
Again this is just simple crude test which came out of my curiosity at how it performed under many threads when using the non server implementation of db4o. The spec summary of the computer
I used is as follows:
With regards to the actual Repository implementation itself, it really is quite straight forward and
I have to say
I am very surprised at how easy it was to integrate and get up and running. One thing
I have noticed in the exposure
I have had so far is
that the Query returns IList<T> as opposed to IQueryable<T> but again
I have not looked into this in depth and this could be there already and if not they have provided everything one needs to make there own repository. An example of a couple of methods from by db4o implementation of the BlogRepository is below: public class BlogRepository : IBlogRepository
{
private readonly IObjectContainer _db;
public BlogRepository(IObjectContainer db)
{
_db = db;
}
public void Put(DomainObject obj)
{
_db.Store(obj);
}
public void Delete(DomainObject obj)
{
_db.Delete(obj);
}
public Post GetByKey(object key)
{
return _db.Query<Post>(post => post.Key == key).FirstOrDefault();
}
…
Anyways
I hope to get a few more implementations going of the object databases and literally just get familiarized
with them and the concept of no sql databases.
Cheers for now,
Andrew
