Matt Long (.com.au) Thoughts and Ideas on Software, Technology and Development Processes…

Starting out with MongoDb and C#

MongoDb, the document oriented database which allows us to store our domain objects/view model objects in a simple, scalable and performant manner.   In this article I’m going to be discussing the basics of getting up and running with mongoDb and achieving the basic Create, Retrieve, Update and Delete operations.

Configuring & Running MongoDb

The process of setting up MongoDb really couldn’t be any simpler for what we’re trying to achieve with this post.  First download MongoDb here, the version I’m working with in this article is 1.6.5, but the latest version should do.  Unzip the zip file and locate mongod.exe, but before running mongod.exe make sure that the directory ‘c:\Data\db’ exists.  This is where MongoDb will store it’s data files and while it is configurable, that’s beyond the scope of this post.  Once you’ve confirmed the data directory exists you can go ahead and run mongod.exe, and with that we have a running instance of MongoDb.

The MongoDb .NET provider

There are various .NET providers for MongoDb available currently, the one I’ve chosen for the purposes of this article is, MongoDB-CSharp which although is still in beta has a nearly complete Linq implementation which is important to me.

The Code

To get started let’s have a look at how we first connect to, and disconnect from our instance of the mongoDb we’ve setup.

        private static void ConnectToDb()
        {
            Mongo mongo = new Mongo();

            mongo.Connect();

            IMongoDatabase nbaTeamsDb = mongo.GetDatabase("NbaTeams"); 

            mongo.Disconnect();
        }

The first line here gives us a connection instance to the localhost instance of mongoDb, if we need to connect to a remote instance of mongoDb then the constructor can also accept a connection string.

Then we simply open the connection and call GetDatabase(), to retrieve the database we wish to be working with, if the database does not already exist then a new one will be created.  Because we don’t need a schema, we don’t need to tell mongoDb anything about the objects we are planning to persist.  Finally we just call Disconnect() to disconnect from our mongoDb instance.

Our Object Model

In the spirit of simplicity I’ve come up with a pretty basic object model of a Team which has a few attributes along with a collection of Players.

    public class Team
    {
        public Oid Id { get; set; }
        public string City { get; set; }
        public string Name { get; set; }
        public IList<Player> Players { get; set; }
    }

    public class Player
    {
        public int Number { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public Position Position { get; set; }
    }

What’s interesting to us in this code is the type of the Id field on the Team object, Oid or Object Id is a mongo type which will allow the mongoDb service to assign unique identifiers to our objects.  Without this field mongo would have no way of recognising whether our objects are new or have already been peristed when ask it to save one.  ie. if an object is to be added or updated.

You will also notice that the Player object does not contain an identifier field, this is because in our simple example Players are not persisted on their own, but only as part of the Players collection on the Team object.  Thus a Player cannot exist without a Team.

Preparing our Objects for Persistence

Before we talk about persisting our objects let’s first prepare them with some test data,

public static Team BuildUpCelticsTeam()
{
    return new Team()
    {
       City = "Boston",
       Name = "Celtics",
       Players = new List<Player>()
       {
         new Player()
            {Number = 43, FirstName = "Kendrick",
                LastName = "Perkins", Position = Position.Center},
         new Player()
            {Number = 5, FirstName = "Kevin",
                LastName = "Garnett", Position = Position.PowerForward},
         new Player()
            {Number = 34, FirstName = "Paul",
                LastName = "Pierce", Position = Position.SmallForward},
         new Player()
            {Number = 20, FirstName = "Ray",
                LastName = "Allen", Position = Position.ShootingGuard},
         new Player()
            {Number = 9, FirstName = "Rajon",
                LastName = "Rondo", Position = Position.PointGuard}
       }
    };
}

public static Team BuildUpLakersTeam()
{
    return new Team()
    {
        City = "Los Angeles",
        Name = "Lakers",
        Players = new List<Player>()
       {
         new Player()
            {Number = 17, FirstName = "Andrew",
                LastName = "Bynum", Position = Position.Center},
         new Player()
            {Number = 16, FirstName = "Pau",
                LastName = "Gasol", Position = Position.PowerForward},
         new Player()
            {Number = 15, FirstName = "Ron",
                LastName = "Artest", Position = Position.SmallForward},
         new Player()
            {Number = 24, FirstName = "Kobe",
                LastName = "Bryant", Position = Position.ShootingGuard},
         new Player()
            {Number = 2, FirstName = "Derek",
                LastName = "Fisher", Position = Position.PointGuard}
       }
    };
}

Like I mentioned earlier, players only exist as part of a team.  And notice that we haven’t had to initialise the Id fields because this will be automatically assigned by mongoDb as part of the persistence process.

Adding an Object to MongoDb

Let’s have a look at a simple example of saving new objects to the mongoDb data store,

    private static void AddTeams()
    {
        Mongo mongo = new Mongo();
        mongo.Connect();

        IMongoDatabase nbaTeamsDb = mongo.GetDatabase("NbaTeams");

        var teams = nbaTeamsDb.GetCollection<Team>();

        var celtics = BuildUpCelticsTeam();

        teams.Save(celtics);

        var lakers = BuildUpLakersTeam();

        teams.Save(lakers);

        mongo.Disconnect();
    }

What’s happening here is using the code we looked at earlier we’re connecting to our mongoDb instance and getting a reference to our database NbaTeams, if it already exists it will be retrieved and if not a new one will be created.

We then get a reference to the collection in which we want to persist our object, and since we’re persisting objects of type Team that is what collection we will retrieve.  Then using the build up methods I mentioned earlier we’re populating our objects and to persist them we simply call Save() on our object collection passing the object to be saved as the parameter.

So as you can see it’s a simple process to persist our objects to mongoDb, we don’t at any time need to tell mongoDb anything about the type of objects we plan to persist, we simply need to retrieve a collection of the type of object we plan to persist and call Save().

Retrieving an Object from MongoDb

Retrieving persisted objects from mongoDb is as simple as querying a collection of objects using linq.

    private static void QueryTeams()
    {
        Mongo mongo = new Mongo();
        mongo.Connect();

        IMongoDatabase nbaTeamsDb = mongo.GetDatabase("NbaTeams");

        var teams = nbaTeamsDb.GetCollection<Team>();

        //Example 1.
        var celtics = teams.Linq()
                           .Where(t => t.City == "Boston")
                           .FirstOrDefault();

        //Example 2.
        var lakers = teams.Linq()
                          .Where(t => t.City == "Los Angeles");

        //Example 3.
        var teamsWith5Players = teams.Linq()
                                     .Where(t => t.Players.Count == 5);

        mongo.Disconnect();
    }

In our first example here we are querying mongoDb for a single Team instance where the team comes from “Boston”.  If more than one team is from the city of Boston then only the first object that mongoDb finds will be retrieved.

In our second example the result will be a collection of Team objects that come from the city of “Los Angeles”.  That may be 0 or more.

And finally our third example will return a collection of 0 or more Team objects that contain exactly 5 players.

Updating an Object in MongoDb

If for example two of our Teams complete a trade where one player from Boston will go to Los Angeles and in return a player from Los Angeles will go to Boston, let’s have a look at how we would update our database to be consistent with the Team changes.

    private static void UpdateTeams()
    {
        Mongo mongo = new Mongo();
        mongo.Connect();

        IMongoDatabase nbaTeamsDb = mongo.GetDatabase("NbaTeams");

        var teams = nbaTeamsDb.GetCollection<Team>();

        //Step 1.
        var celtics = teams.Linq()
                           .FirstOrDefault(t => t.City == "Boston");

        var lakers = teams.Linq()
                          .FirstOrDefault(t => t.City == "Los Angeles"
                                               && t.Name == "Lakers");

        //Step 2.
        var rayAllen = celtics.Players
                              .FirstOrDefault(p => p.FirstName == "Ray"
                                                   && p.LastName == "Allen");

        var ronArtest = lakers.Players
                              .FirstOrDefault(p => p.FirstName == "Ron"
                                                   && p.LastName == "Artest");

        //Step 4.
        celtics.Players.Remove(rayAllen);
        celtics.Players.Add(ronArtest);

        lakers.Players.Remove(ronArtest);
        lakers.Players.Add(rayAllen);

        //Step 5.
        teams.Save(celtics);
        teams.Save(lakers);

        mongo.Disconnect();
    }

Firstly in step one we need to query mongoDb for a reference to each of the Teams who have been involved in the trade, secondly we query our Team objects for a reference to each of the Players who have been traded.  Then we remove each Player from their original Team and add them to their new Teams, and finally we call Save() on the Team collection passing our updated Teams as parameters.

Deleting an Object from MongoDb

To delete a Team from our datastore, we simply retrieve a reference to the Team collection and call Remove() on it while using a lamda statement to specify the one or many Teams we wish to delete.

    private static void DeleteTeams()
    {
        Mongo mongo = new Mongo();
        mongo.Connect();

        IMongoDatabase nbaTeamsDb = mongo.GetDatabase("NbaTeams");

        var teams = nbaTeamsDb.GetCollection<Team>();

        teams.Remove(t => t.City == "Los Angeles" && t.Name == "Lakers");

        mongo.Disconnect();
    }

In this example we specify that we want to delete any team that has a city of “Los Angeles” and a name of “Lakers”.  With this level of detail, the statement would obviously only delete one Team from the database as there would never be two Teams with the same city and name.  But if we were to remove the name from the statement, then any Teams (1 or more) that come from the city of “Los Angeles” would be removed.

Wrapping Up

I hope I’ve been able to demonstrate just how simple persisting and retrieving objects from mongoDb can be.  Without having to worry as much about schemas and database technologies, we are free to focus more on our domain models and the complexity within our software.