One thing is for sure - Microsoft gets a bad rep these days.  Maybe its because of Windows Vista.  Maybe its because of classic ASP, or even ASP.NET’s WebForms.  Maybe it is because they are a large company who’s focus has too long been on the enterprise, and not enough on the consumer.  Most likely, though, it is because its simply cool to make fun of Microsoft.

I had plenty of options when I decided to start building a new web application.  My favorite language is C#.  I’m not talking about web app frameworks, or frameworks in general – no, just the language.  I love that C# does not do very much magic, like Ruby does.  I love that C# has a cleaner and more expressive syntax than Java does.  I won’t even compare the language syntax and API to that of PHP. Of course, there were other options too, such as Python and Scala.

Java

I’ve been working for the past 3 years with Java and Spring 2.x.  Older versions of Spring are god-awful, what with their dependence on a metric ton of XML configuration files.  Spring 2.5 began to add support for annotations (attributes in C#) and Spring 3 continued to improve even further in this area.  Java has a fairly good amount of cool technologies, frameworks, and specifications too.  For me, though, the ecosystem feels very broken.  Having many options is good.  Having too many options is bad.

Ruby and RoR

I began toying around with Ruby and, consequently, Ruby on Rails too.  It is a nice and powerful language and framework but at the end of the day it didn’t feel right.  I like type safety and compile-time checks.  I like knowing what my code does – in fact, I like telling my code what to do!  Ruby loves to do magic for you.  Rails builds on top of this magic to provide even more magic.  Honestly, it is pretty impressive but for me, it just didn’t feel right.  I’ve spoken to fellow developers who feel the same way: It is very cool, but doesn’t feel natural.

With that said, I have already written a couple of supporting services in Ruby for my new app.. because Ruby was the better choice for those services.  They are exposed as web services running on Sinatra.

PHP

I’ve used several PHP frameworks, including CakePHP, CodeIgniter, Kohana, Lithium and Yii.  My favorites are the last two, Lithium and Yii.  They both do a great job of making it easy to build web applications and both are extensible.  However, I despise PHP as a language.  It is arguably one of the ugliest languages ever “designed.”  (It really never was designed, it just grew organically which is why function names, parameter order, etc is so different from function to function)  If I choose PHP, I know I would not be able to sleep at night.

As for the others, I just didn’t have enough experience with them to make a fair (to me) comparison.  Nor did I have several months to learn them to a point that would make a fair comparison.

Home, sweet, home

This all brings me back to my personal favorite language, C#.  It has a very clean and expressive API (look at LINQ).  The ecosystem is smaller than that of Java, but it is tighter because one company runs the show – Microsoft.  With Microsoft’s latest MVC framework release, ASP.NET MVC3, writing a web application has become so simple its scary.

The ill-named ASP.NET MVC framework learned quite a bit from Rails and the open source community in general. Microsoft studied what people want to do with their frameworks and what they don’t – and it shows.  ASP.NET MVC is a fantastic framework and they’ve built in extensibility at every level.  Don’t like something? Write your own and plug it in.  It really is that easy. Seriously.

With version 3 comes the Razor view engine which I think is absolutely beautiful.  I’ve used several view engines in different languages but Razor stands out to me as a new approach (which is sometimes scary to some people) where you don’t need weird braces, brackets, or custom HTML tags to render content or run code in your views.  I think its just very streamlined and easy to look at and read.

It scales – they all do!

Scalability isn't a feature of any language or framework.  Nowhere is there a bullet that lists scalability as an important feature.  Instead, scalability is something the application designers must think about while they built there app, no matter which language its built in.

ASP.NET scales very well.  So do Java, Ruby, PHP and all the others – when done right.  Scalability is about engineers, not language.

The Community

People often complain that Microsoft is a large corporation who doesn’t care about the community. Those same people often ignore the fact that Microsoft has open sourced much of the .NET framework, including ASP.NET MVC. They ignore that most (though, not all) .NET programs will run happily on any operating system, including Linux, OSX, and iOS. This is made possible through the open source Mono project, sponsored by Microsoft and Novell.

Microsoft and the community also collaborated on a cool new package manager called Nuget.  It is similar in nature to Ruby’s Gems and Java’s Maven, though it is not a copy of either of them.  What is amazing is that immediately upon its release, cool open source (and some commercial) libraries began showing up in the Nuget listing.  So many libraries that I, and presumably many other people, had never heard of were suddenly at our fingertips, ready to be installed as easily as a Ruby  gem.

Since releasing Nuget, the amount of packages has been steadily growing and the amount of package downloads has been growing even faster.

In addition to this,  there is a healthy community of people willing to help you solve any issues you have.  You can head over the the ASP.NET Forums or StackOverflow if you need help with anything and your question will be answered usually in minutes.

The Microsoft stack, minus Microsoft

For my newest web application, I’ve made the decision to go with MongoDB for my database.  It is a super fast, document-oriented database as opposed to standard relational databases such as MySql, Postgres, and Microsoft’s own SQLServer.  I made this decision because it best fits the type of data I will be storing and I’ve been working with MongoDB since its alpha stage so I know what it is capable of.

MongoDB runs on Windows but runs better on Linux, and that is where I plan to run it.

If C# code and ASP.NET MVC applications can also run on Linux, then you have no need to run on Windows.  You have removed Microsoft from the Microsoft stack.  Where is your vendor lock in now?

I will most likely run my application on Windows Server 2008 but the point is that I don’t have to if I don’t want to.  Even with the Microsoft stack, I still have my options.

Bonus: WebSite Spark and BizSpark

WebSite Spark and BizSpark are two initiatives by Microsoft to bring down the initial cost of getting up and running with the Microsoft platform so that you can get all the tools and resources you need to do it right.

Conclusion

With Microsoft's new commitment to building better tools for the web and working with the community, I feel that my decision to go with the Microsoft stack is the right one, for me.  You may not agree – and that is fine – but don’t knock it before you try it.  Version 3 of ASP.NET MVC brings some really great stuff to the table. Nuget makes finding packages just as easy as it has been for Ruby developers for years. Portability of the code means not needing to worry about vendor lock-in.

So far, I am more than happy with my decision.

I mist say, the latest release of mongodb-csharp is rather awesome.  Typed collections and LINQ support mean I can worry more about my application than about the data layer.

Here is an example of using typed collections:

public class Customer
{
	public Oid Id { get; set; }
	public string Name { get; set; }
	public CustomerBillingInfo Billing { get; set; }
	public List Depts { get; set; }
}

public void AddCustomer(Customer customer) {
	...(code removed for simplicity)...
	IMongoCollection collection = database.GetCollection();
	collection.Save(customer);
}

Gotcha: Beware of the ID property!

One thing that threw me off when I began using the typed collections was that I had defined my ID property as “_id” because That is what MongoDB uses internally.  While this made sense to me, the mongod process kept throwing errors whenever I tried the following:

...(code removed for simplicity)...
IMongoCollection<customer> collection = database.GetCollection<customer>();
Customer customer = collection.Linq().First(c => c.Name == "test customer");
customer.Name = "A new name!";
collection.Save(customer);

The error looked something like this:

Fri Jun 25 10:43:14 Exception 11000:E11000 duplicate key error index: test06.Customer.$_id_  dup key: { : ObjId(4c24c07a189cf31bd4000002) }
Fri Jun 25 10:43:14    Caught Assertion in insert , continuing
Fri Jun 25 10:43:14 insert test06.Customer exception userassert:E11000 duplicate key error index: test06.Customer.$_id_  dup key: { : ObjId(4c24c07a189cf31bd4000002) } 21ms

It was driving me crazy for days before I realized that the driver was doing some magic – the POCO object needed its ID to be named “Id” instead of “_id” an as soon as I changed that – it started working properly.

There are a number of C# based MongoDB projects being actively developed right now but one thing that I needed was a way to convert a standard C# class to a MongoDB document for easy insertion.  It isn't hard to manually type out and set each property by hand, but it certainly is not the most efficient way, especially when you know you are going to be doing it a lot.

For example:

Lets say I have a class called SomeClass that looks something like this:

class SomeClass {
	public string StringTest;
	public int IntTest;
}

And somewhere in my code, I have an instance of this class named someClassInstance.  If I want to create a MongoDB document from this class, I’d have to do something like this:

Document document = new Document();
document.add('StringTest', someClassInstance.StringTest);
document.add('IntTest', someClassInstance.IntTest);

So that isn't such a big deal, right? But what about when I have a class with many more properties?  Then it starts to get messy and cumbersome.  I thought that there should be an straightforward way to easily convert any class to a mongo-csharp compatible Document object. (I am using Sam Corder’s mongo-csharp driver, so that I am targeting the Document object from that library.)

Default values

I also wanted to have a way to specify what the default values were for each class property so that when we did the conversion, we would (hopefully) not end up with any null values.  Plus, if for some reason there was a document in MongoDB that was missing a particular key-value pair, the DocumentConverter would automatically fill in that empty field with the default value so in the code we should never have any nulls.

This is something that I would like for my own purposes and may not suit everyone’s needs.  If it doesn't, simply leave off the DefaultValueAttribute and you’ll never know the difference.

My proposed solution

I figured the easiest way to accomplish this was to create a class that would encapsulate all the functionality needed to convert to and from Document objects and have my other classes inherit from that one. I imagined that the above code would change to something like this:

class SomeClass : DocumentConverter {
	[Attributes.DefaultValue("Default StringTest value!")]
	public string StringTest;
	[Attributes.DefaultValue(16)]
	public int IntTest;
}

And to do the conversion would be very simple.  To convert from someClass to Document would be:

Document document = someClassInstance.ToMongoDocument();

To convert from a Document object to someClass would be:

SomeClass someOtherClassInstance = new SomeClass();
omeOtherClassInstance .FromMongoDocument(someDocumentObject);

The DefaultAttribute class

using System;
namespace MyApp.Attributes
{
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
    class DefaultValueAttribute : Attribute
    {
        private readonly object _value;

        public DefaultValueAttribute(object Value)
        {
            _value = Value;
        }

        public object GetDefaultValue()
        {
            return _value;
        }
    }
}

The DocumentConverter class

Reflection isn't something that I use too often so there may be better ways of accomplishing what I am trying to do, but this is what I’ve got for now.  If there are better ways, please let me know.  Without further ado…

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using MyApp.Classes.Attributes;
using MongoDB.Driver;

namespace MyApp.Classes
{
    public class DocumentConverter
    {
        public void FromMongoDocument(Document document)
        {
            foreach (DictionaryEntry kvp in document)
            {
                object propertyValue;
                if (kvp.Value != null && (kvp.Value.GetType() == typeof(Document)))
                {
                    // We have a document object - Now lets get a reference to the class property's type
                    var propertyType = GetType().GetProperty(kvp.Key.ToString()).PropertyType;

                    // create new instance of that class
                    var propertyInstance = Activator.CreateInstance(propertyType);

                    // call FromMongoDocument on that class and pass in the document
                    MethodInfo method = propertyInstance.GetType().GetMethod("FromMongoDocument");
                    method.Invoke(propertyInstance, new[] { kvp.Value });

                    propertyValue = propertyInstance;
                }
                else
                {
                    // This is not a Document so lets just assign the value
                    propertyValue = kvp.Value;
                }

                GetType().GetProperty(kvp.Key.ToString()).SetValue(this, propertyValue, null);
            }

        }

        public Document ToMongoDocument()
        {
            Document document = new Document();

            foreach (PropertyInfo property in GetType().GetProperties())
            {
                // Get the value of this property
                object propertyValue = property.GetValue(this, null);

                // If this value is null, then lets try to see if there is a default value attribute and assign that
                if (propertyValue == null)
                {
                    object[] attributes = property.GetCustomAttributes(typeof(DefaultValueAttribute), true);
                    foreach (DefaultValueAttribute defaultValue in attributes.Cast())
                    {
                        propertyValue = defaultValue.GetDefaultValue();
                    }
                    document.Add(property.Name, propertyValue);
                }
                else
                {
                    // We have a property, now lets see if this property has a ToMongoDocument method
                    MethodInfo method = propertyValue.GetType().GetMethod("ToMongoDocument");

                    if (method == null)
                    {
                        document.Add(property.Name, property.GetValue(this, null));
                    }
                    else
                    {
                        document.Add(property.Name, method.Invoke(propertyValue, null));
                    }
                }
            }
            return document;
        }
    }
}

That’s all for now

I hope this is useful for someone.  It is a rough draft of what I threw together last night at around 1AM while half asleep.  So far, it has passed all of my initial tests but if you have suggestions to make it better, please leave some comments here.

As a C# developer, I am often disappointed with the lack of drivers and connectors to cool services like MongoDB.  All the cool languages (and Java) get all the love but C# is often an afterthought.

Luckily for me, there are some kickass developers in the C# community who also share my frustration and as such, they have begun building their own C# MongoDB drivers.

I keep stumbling across more and more C# related MongoDB projects, so I figured I would write up a list and some short descriptions of these projects.

List of C# MongoDB Projects

Each of these projects are still rather new, so expect some features to be missing or not fully functional.  A couple of them are usable in your projects today while the rest are still under heavy development

mongodb-csharp

Originally written by Sam Corder (@SamCorder) with help from a handful of contributers, this is the most complete driver of the bunch. It has been evolving quickly and Sam & team are very quick to resolve any bugs that may arise.

I am using this driver in 2 projects that I am working on and so far things have been great.  It even includes GridFS suport.

From the project description:

Current Features

• Connect to a server.
• Query
• Insert
• Update
• Delete
• All BSON types supported
• DBRef support
• Isolation and conversion between BSON types and native .net types.
• Database, Collection and Cursor objects.
• Index handling routines (List, Create, Drop)
• Count
• Roughly 80% unit test coverage. This can and will be improved on.
• Paired connections
• Authentication (Does not reauthorize on auto reconnect yet).
• Database Commands
• Basic Linq support
• GridFS support
• Map Reduce helpers.
• hint, explain, $where

They are currently working on connection management features (auto reconnect, connection pooling, etc).

Get involved or check out the code at their mongodb-csharp project page on Github.

mongodb-net

Written by the unnamed developer at DevFuel.com, the mongo-net project aims to be a C# port of the 10Gen\MongoDB official Java driver.  While a lot of work has been done and a load of code written, it is currently unusable.  Over the past couple of weeks a significant amount of progress has been made and functionality is beginning to work but it seems that a functional state is months away.

I would keep an eye on this project, though, as having an API compatible with the official Java driver has its benefits.

Get involved or check out the code at their mongodb-net project page on Google Code.

MongoDB.Emitter

Andrew Rondeau’s MongoDB.Emitter is a pretty cool project that provides a strongly-typed Document mapper for C#.  It works in conjunction with Sam Corder’s mongodb-csharp driver allowing the programmer to define strongly typed interfaces and properties.

I have not tried this yet, but this will be on my list of things to check out.

Get involved or check out the code at their MongoDB.Emitter project page on bitbucket.

CSMongo

Hugo Bonacci (@hugoware) has been working on a driver of his own called CSMongo. CSMongo doesnt support everything that mongodb-csharp does but it does have some interesting features, such as the approach to creating Mongo Documents.  Their approach definitely has a more dynamic feel to it which fites nicely in the unstructured MongoDB world.

I am looking forward to the next version which should have more features including support for Hugo’s own jLinq.

Code doesn't appear to be released yet but you can follow his progress at his blog, Hugoware.

simple-mongodb

Simple-mongdb is another project without public source that is being worked on by Daniel Wertheim (@danielwertheim).  I am not sure if it is even being actively developed but it too has some nice ideas.  The goal of this project is to keep the driver JSON-centric and should be compatible with awesome Newtonsoft’s JSON.net library.

They have a few examples of the proposed API but no code has been released to make said examples work.  This is another one to keep an eye on in the meantime.

Check out the simple-mongodb project page on Google Code.

DocumentConverter

This is a small class I wrote that works with mongodb-csharp.  Its name will likely change at some point if and when it gets packaged up and put on source control.  It exposes two functions that will allow any C# class to convert to and from a MongoDB Document object automatically.  It makes my life a lot easier and it uses System.Reflection to do this.

Read more about DocumentConverter on this blog post.

Conclusion

Well it looks like there is a significant amount of interest in MongoDB from the C# community which is great news because it looks like MongoDB is going to continue to thrive and grow.  My bet is that Sam Corder’s driver will be the most common C# driver, simply because it is so far ahead of the rest but time will tell.  Extensions of Sam’s project, such as MongoDB.Emitter, are equally as cool as the drivers they are built on.

Thanks toeveryone who has contributed to these drivers.  Each of them have some great concepts and I hope that one day we will have a driver that supports all these great ideas and features.

If there are any more projects that I have missed – let me know in the comments!