使用MongoDB C＃驱动程序处理集合事件（v2.0）

Question

Playing with the new MongoDB driver (v2.0) has been quite challenging. Most of the examples you find on the web still refer to the legacy driver. The reference manual for v2.0 on the official Mongo site is "terse", to say the least.

I'm attempting to do a simple thing: detect when a collection has been changed in order to forward a C# event to my server application .

For doing so, I've found the following C# example (see below) that I'm trying to convert to the new API.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Builders;

namespace TestTailableCursor {
    public static class Program {
        public static void Main(string[] args) {
            try {
                var server = MongoServer.Create("mongodb://localhost/?safe=true");
                var database = server["test"];

                if (database.CollectionExists("capped")) {
                    database.DropCollection("capped");
                }
                var collectionOptions = CollectionOptions.SetCapped(true).SetMaxDocuments(5).SetMaxSize(10000);
                var commandResult = database.CreateCollection("capped", collectionOptions);
                var collection = database["capped"];

                // to test the tailable cursor manually insert documents into the test.capped collection
                // while this program is running and verify that they are echoed to the console window

                // see: http://www.mongodb.org/display/DOCS/Tailable+Cursors for C++ version of this loop
                BsonValue lastId = BsonMinKey.Value;
                while (true) {
                    var query = Query.GT("_id", lastId);
                    var cursor = collection.Find(query)
                        .SetFlags(QueryFlags.TailableCursor | QueryFlags.AwaitData)
                        .SetSortOrder("$natural");
                    using (var enumerator = (MongoCursorEnumerator<BsonDocument>) cursor.GetEnumerator()) {
                        while (true) {
                            if (enumerator.MoveNext()) {
                                var document = enumerator.Current;
                                lastId = document["_id"];
                                ProcessDocument(document);
                            } else {
                                if (enumerator.IsDead) {
                                    break;
                                }
                                if (!enumerator.IsServerAwaitCapable) {
                                    Thread.Sleep(TimeSpan.FromMilliseconds(100));
                                }
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                Console.WriteLine("Unhandled exception:");
                Console.WriteLine(ex);
            }

            Console.WriteLine("Press Enter to continue");
            Console.ReadLine();
        }

        private static void ProcessDocument(BsonDocument document) 
        {
            Console.WriteLine(document.ToJson());
        }
    }
}

A few (related) questions:

1. Is that the right approach with the new driver?
2. If so, how do I set collection options (like SetCap in the example above). The new API includes something called "CollectionSettings", which seems totally unrelated.
3. Is my only option to rely on the legacy driver?

Thanks for your help.

Answer 1

Is my only option to rely on the legacy driver?

No.

[...] how do I set collection options (like SetCap in the example above). The new API includes something called "CollectionSettings", which seems totally unrelated.

There's CreateCollectionSettings now. CollectionSettings is a setting for the driver, ie a way to specify default behavior per-collection. CreateCollectionOptions can be used like this:

db.CreateCollectionAsync("capped", new CreateCollectionOptions 
      { Capped = true, MaxDocuments = 5, MaxSize = 10000 }).Wait();

Is that the right approach with the new driver?

I think so, tailable cursors are a feature of the database, and avoiding polling always makes sense.

I converted the gist of the code and it appears to work on my machine ™:

Be careful when using .Result and .Wait() in a web or UI application.

private static void ProcessDocument<T>(T document)where T : class
{
    Console.WriteLine(document.ToJson());
}

static async Task Watch<T>(IMongoCollection<T> collection) where T: class
{ 
    try {
        BsonValue lastId = BsonMinKey.Value;
        while (true) {
            var query = Builders<T>.Filter.Gt("_id", lastId);

            using (var cursor = await collection.FindAsync(query, new FindOptions<T> { 
                CursorType = CursorType.TailableAwait, 
                Sort = Builders<T>.Sort.Ascending("$natural") }))
            {
                while (await cursor.MoveNextAsync())
                {
                    var batch = cursor.Current;
                    foreach (var document in batch)
                    {
                        lastId = document.ToBsonDocument()["_id"];
                        ProcessDocument(document);
                    }
                }
            }
        }
    }
    catch (Exception ex) {
        Console.WriteLine("Unhandled exception:");
        Console.WriteLine(ex);
    }
}