Merge Craig and Robert's work around CommandResults.

rstam · rstam · commit b252bcc13ccf · 2013-03-26T15:33:50.000-04:00
diff --git a/MongoDB.Driver/CommandResults/DistinctCommandResult.cs b/MongoDB.Driver/CommandResults/DistinctCommandResult.cs
@@ -28,7 +28,7 @@ namespace MongoDB.Driver
     public class DistinctCommandResult<TValue> : CommandResult
     {
         // private fields
-        private IEnumerable<TValue> _values;
+        private readonly IEnumerable<TValue> _values;
 
         // constructors
         /// <summary>
diff --git a/MongoDB.Driver/CommandResults/DistinctCommandResultSerializer.cs b/MongoDB.Driver/CommandResults/DistinctCommandResultSerializer.cs
@@ -29,6 +29,30 @@ namespace MongoDB.Driver
     /// <typeparam name="TValue">The type of the value.</typeparam>
     public class DistinctCommandResultSerializer<TValue> : BsonBaseSerializer
     {
+        // private fields
+        private readonly IBsonSerializer _valueSerializer;
+        private readonly IBsonSerializationOptions _valueSerializationOptions;
+
+        // constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DistinctCommandResultSerializer{TValue}"/> class.
+        /// </summary>
+        public DistinctCommandResultSerializer()
+            : this(BsonSerializer.LookupSerializer(typeof(TValue)), null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DistinctCommandResultSerializer{TValue}"/> class.
+        /// </summary>
+        /// <param name="valueSerializer">The value serializer.</param>
+        /// <param name="valueSerializationOptions">The value serialization options.</param>
+        public DistinctCommandResultSerializer(IBsonSerializer valueSerializer, IBsonSerializationOptions valueSerializationOptions)
+        {
+            _valueSerializer = valueSerializer;
+            _valueSerializationOptions = valueSerializationOptions;
+        }
+
         /// <summary>
         /// Deserializes an object from a BsonReader.
         /// </summary>
@@ -50,8 +74,7 @@ public override object Deserialize(BsonReader bsonReader, Type nominalType, Type
                 var name = bsonReader.ReadName();
                 if (name == "values")
                 {
-                    var enumerableSerializer = new EnumerableSerializer<TValue>();
-                    values = (IEnumerable<TValue>)enumerableSerializer.Deserialize(bsonReader, typeof(List<TValue>), null);
+                    values = ReadValues(bsonReader);
                 }
                 else
                 {
@@ -63,5 +86,20 @@ public override object Deserialize(BsonReader bsonReader, Type nominalType, Type
 
             return new DistinctCommandResult<TValue>(response, values);
         }
+
+        // private methods
+        private IEnumerable<TValue> ReadValues(BsonReader bsonReader)
+        {
+            var values = new List<TValue>();
+
+            bsonReader.ReadStartArray();
+            while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
+            {
+                values.Add((TValue)_valueSerializer.Deserialize(bsonReader, typeof(TValue), _valueSerializationOptions));
+            }
+            bsonReader.ReadEndArray();
+
+            return values;
+        }
     }
 }
diff --git a/MongoDB.Driver/Communication/MongoConnection.cs b/MongoDB.Driver/Communication/MongoConnection.cs
@@ -287,6 +287,7 @@ internal TCommandResult RunCommandAs<TCommandResult>(
                 var message = string.Format("Command '{0}' failed. No response returned.", commandName);
                 throw new MongoCommandException(message);
             }
+
             var commandResult = reply.Documents[0];
             commandResult.Command = command;
 
@@ -390,8 +391,7 @@ internal WriteConcernResult SendMessage(BsonBuffer buffer, MongoRequestMessage m
                         MaxDocumentSize = _serverInstance.MaxDocumentSize
                     };
                     var writeConcernResultSerializer = BsonSerializer.LookupSerializer(typeof(WriteConcernResult));
-                    IBsonSerializationOptions writeConcernSerializationOptions = null;
-                    var replyMessage = ReceiveMessage<WriteConcernResult>(readerSettings, writeConcernResultSerializer, writeConcernSerializationOptions);
+                    var replyMessage = ReceiveMessage<WriteConcernResult>(readerSettings, writeConcernResultSerializer, null);
                     writeConcernResult = replyMessage.Documents[0];
                     writeConcernResult.Command = getLastErrorCommand;
                     if (!writeConcernResult.Ok)
diff --git a/MongoDB.Driver/MongoCollection.cs b/MongoDB.Driver/MongoCollection.cs
@@ -24,6 +24,7 @@
 using MongoDB.Driver.Builders;
 using MongoDB.Driver.Internal;
 using MongoDB.Driver.Wrappers;
+using MongoDB.Bson.Serialization.Serializers;
 
 namespace MongoDB.Driver
 {
@@ -246,14 +247,7 @@ public virtual IEnumerable<BsonValue> Distinct(string key)
         /// <returns>The distint values of the field.</returns>
         public virtual IEnumerable<BsonValue> Distinct(string key, IMongoQuery query)
         {
-            var command = new CommandDocument
-            {
-                { "distinct", _name },
-                { "key", key },
-                { "query", BsonDocumentWrapper.Create(query), query != null } // query is optional
-            };
-            var result = RunCommand(command);
-            return result.Response["values"].AsBsonArray;
+            return Distinct<BsonValue>(key, query, BsonValueSerializer.Instance, null);
         }
 
         /// <summary>
@@ -276,14 +270,8 @@ public virtual IEnumerable<TValue> Distinct<TValue>(string key)
         /// <returns>The distint values of the field.</returns>
         public virtual IEnumerable<TValue> Distinct<TValue>(string key, IMongoQuery query)
         {
-            var command = new CommandDocument
-            {
-                { "distinct", _name },
-                { "key", key },
-                { "query", BsonDocumentWrapper.Create(query), query != null } // query is optional
-            };
-            var result = RunCommandAs<DistinctCommandResult<TValue>>(command);
-            return result.Values;
+            var valueSerializer = BsonSerializer.LookupSerializer(typeof(TValue));
+            return Distinct<TValue>(key, query, valueSerializer, null);
         }
 
         /// <summary>
@@ -570,7 +558,7 @@ public virtual FindAndModifyResult FindAndRemove(IMongoQuery query, IMongoSortBy
         public virtual MongoCursor<TDocument> FindAs<TDocument>(IMongoQuery query)
         {
             var serializer = BsonSerializer.LookupSerializer(typeof(TDocument));
-            return new MongoCursor<TDocument>(this, query, _settings.ReadPreference, serializer);
+            return FindAs<TDocument>(query, serializer, null);
         }
 
         /// <summary>
@@ -582,7 +570,7 @@ public virtual MongoCursor<TDocument> FindAs<TDocument>(IMongoQuery query)
         public virtual MongoCursor FindAs(Type documentType, IMongoQuery query)
         {
             var serializer = BsonSerializer.LookupSerializer(documentType);
-            return MongoCursor.Create(documentType, this, query, _settings.ReadPreference, serializer);
+            return FindAs(documentType, query, serializer, null);
         }
 
         /// <summary>
@@ -1702,12 +1690,24 @@ internal TCommandResult RunCommandAs<TCommandResult>(IMongoCommand command)
             return (TCommandResult)RunCommandAs(typeof(TCommandResult), command);
         }
 
+        internal TCommandResult RunCommandAs<TCommandResult>(IMongoCommand command, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
+            where TCommandResult : CommandResult
+        {
+            return (TCommandResult)RunCommandAs(typeof(TCommandResult), command, serializer, serializationOptions);
+        }
+
         internal CommandResult RunCommandAs(Type commandResultType, IMongoCommand command)
+        {
+            var commandResultSerializer = BsonSerializer.LookupSerializer(commandResultType);
+            return RunCommandAs(commandResultType, command, commandResultSerializer, null);
+        }
+
+        internal CommandResult RunCommandAs(Type commandResultType, IMongoCommand command, IBsonSerializer commandResultSerializer, IBsonSerializationOptions commandResultSerializationOptions)
         {
             // if necessary delegate running the command to the _commandCollection
             if (_name == "$cmd")
             {
-                var commandResult = (CommandResult)FindOneAs(commandResultType, command);
+                var commandResult = (CommandResult)FindOneAs(commandResultType, command, commandResultSerializer, commandResultSerializationOptions);
                 if (commandResult == null)
                 {
                     var commandName = command.ToBsonDocument().GetElement(0).Name;
@@ -1729,11 +1729,48 @@ internal CommandResult RunCommandAs(Type commandResultType, IMongoCommand comman
             }
             else
             {
-                return _commandCollection.RunCommandAs(commandResultType, command);
+                return _commandCollection.RunCommandAs(commandResultType, command, commandResultSerializer, commandResultSerializationOptions);
             }
         }
 
         // private methods
+        private IEnumerable<TValue> Distinct<TValue>(
+            string key,
+            IMongoQuery query,
+            IBsonSerializer valueSerializer,
+            IBsonSerializationOptions valueSerializationOptions)
+        {
+            var command = new CommandDocument
+            {
+                { "distinct", _name },
+                { "key", key },
+                { "query", BsonDocumentWrapper.Create(query), query != null } // query is optional
+            };
+            var resultSerializer = new DistinctCommandResultSerializer<TValue>(valueSerializer, valueSerializationOptions);
+            var result = RunCommandAs<DistinctCommandResult<TValue>>(command, resultSerializer, null);
+            return result.Values;
+        }
+
+        private MongoCursor FindAs(Type documentType, IMongoQuery query, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
+        {
+            return MongoCursor.Create(documentType, this, query, _settings.ReadPreference, serializer, serializationOptions);
+        }
+
+        private MongoCursor<TDocument> FindAs<TDocument>(IMongoQuery query, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
+        {
+            return new MongoCursor<TDocument>(this, query, _settings.ReadPreference, serializer, serializationOptions);
+        }
+
+        private CommandResult FindOneAs(Type documentType, IMongoQuery query, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
+        {
+            return FindAs(documentType, query, serializer, serializationOptions).SetLimit(1).Cast<CommandResult>().FirstOrDefault();
+        }
+
+        private TDocument FindOneAs<TDocument>(IMongoQuery query, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
+        {
+            return FindAs<TDocument>(query, serializer, serializationOptions).SetLimit(1).FirstOrDefault();
+        }
+
         private string GetIndexName(BsonDocument keys, BsonDocument options)
         {
             if (options != null)
diff --git a/MongoDB.Driver/MongoCursor.cs b/MongoDB.Driver/MongoCursor.cs
@@ -54,13 +54,15 @@ public abstract class MongoCursor : IEnumerable
         /// <param name="query">The query.</param>
         /// <param name="readPreference">The read preference.</param>
         /// <param name="serializer">The serializer.</param>
-        protected MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer)
+        /// <param name="serializationOptions">The serialization options.</param>
+        protected MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
         {
             _collection = collection;
             _database = collection.Database;
             _server = collection.Database.Server;
             _query = query;
             _serializer = serializer;
+            _serializationOptions = serializationOptions;
             _readPreference = readPreference;
         }
 
@@ -254,13 +256,16 @@ public virtual bool IsFrozen
         /// <param name="query">A query.</param>
         /// <param name="readPreference">The read preference.</param>
         /// <param name="serializer">The serializer.</param>
-        /// <returns>A cursor.</returns>
-        public static MongoCursor Create(Type documentType, MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer)
+        /// <param name="serializationOptions">The serialization options.</param>
+        /// <returns>
+        /// A cursor.
+        /// </returns>
+        public static MongoCursor Create(Type documentType, MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
         {
             var cursorDefinition = typeof(MongoCursor<>);
             var cursorType = cursorDefinition.MakeGenericType(documentType);
-            var constructorInfo = cursorType.GetConstructor(new Type[] { typeof(MongoCollection), typeof(IMongoQuery), typeof(ReadPreference), typeof(IBsonSerializer)});
-            return (MongoCursor)constructorInfo.Invoke(new object[] { collection, query, readPreference, serializer });
+            var constructorInfo = cursorType.GetConstructor(new Type[] { typeof(MongoCollection), typeof(IMongoQuery), typeof(ReadPreference), typeof(IBsonSerializer), typeof(IBsonSerializationOptions)});
+            return (MongoCursor)constructorInfo.Invoke(new object[] { collection, query, readPreference, serializer, serializationOptions });
         }
 
         // public methods
@@ -279,10 +284,13 @@ public virtual MongoCursor<TDocument> Clone<TDocument>()
         /// </summary>
         /// <typeparam name="TDocument">The type of the documents returned.</typeparam>
         /// <param name="serializer">The serializer to use.</param>
-        /// <returns>A clone of the cursor.</returns>
-        public virtual MongoCursor<TDocument> Clone<TDocument>(IBsonSerializer serializer)
+        /// <param name="serializationOptions">The serialization options.</param>
+        /// <returns>
+        /// A clone of the cursor.
+        /// </returns>
+        public virtual MongoCursor<TDocument> Clone<TDocument>(IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
         {
-            return (MongoCursor<TDocument>)Clone(typeof(TDocument), serializer);
+            return (MongoCursor<TDocument>)Clone(typeof(TDocument), serializer, serializationOptions);
         }
 
         /// <summary>
@@ -292,18 +300,22 @@ public virtual MongoCursor<TDocument> Clone<TDocument>(IBsonSerializer serialize
         /// <returns>A clone of the cursor.</returns>
         public virtual MongoCursor Clone(Type documentType)
         {
-            return Clone(documentType, _serializer);
+            var serializer = BsonSerializer.LookupSerializer(documentType);
+            return Clone(documentType, serializer, null);
         }
 
         /// <summary>
         /// Creates a clone of the cursor.
         /// </summary>
         /// <param name="documentType">The type of the documents returned.</param>
         /// <param name="serializer">The serializer to use.</param>
-        /// <returns>A clone of the cursor.</returns>
-        public virtual MongoCursor Clone(Type documentType, IBsonSerializer serializer)
+        /// <param name="serializationOptions">The serialization options.</param>
+        /// <returns>
+        /// A clone of the cursor.
+        /// </returns>
+        public virtual MongoCursor Clone(Type documentType, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
         {
-            var clone = Create(documentType, _collection, _query, _readPreference, serializer);
+            var clone = Create(documentType, _collection, _query, _readPreference, serializer, serializationOptions);
             clone._options = _options == null ? null : (BsonDocument)_options.Clone();
             clone._flags = _flags;
             clone._skip = _skip;
@@ -347,7 +359,7 @@ public virtual BsonDocument Explain()
         public virtual BsonDocument Explain(bool verbose)
         {
             _isFrozen = true;
-            var clone = Clone<BsonDocument>(BsonDocumentSerializer.Instance);
+            var clone = Clone<BsonDocument>(BsonDocumentSerializer.Instance, null);
             clone.SetOption("$explain", true);
             clone._limit = -clone._limit; // TODO: should this be -1?
             var explanation = clone.FirstOrDefault();
@@ -683,8 +695,9 @@ public class MongoCursor<TDocument> : MongoCursor, IEnumerable<TDocument>
         /// <param name="query">The query.</param>
         /// <param name="readPreference">The read preference.</param>
         /// <param name="serializer">The serializer.</param>
-        public MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer)
-            : base(collection, query, readPreference, serializer)
+        /// <param name="serializationOptions">The serialization options.</param>
+        public MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer, IBsonSerializationOptions serializationOptions)
+            : base(collection, query, readPreference, serializer, serializationOptions)
         {
         }
 

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ namespace MongoDB.Driver`
`28`	`28`	`public class DistinctCommandResult<TValue> : CommandResult`
`29`	`29`	`{`
`30`	`30`	`// private fields`
`31`		`- private IEnumerable<TValue> _values;`
	`31`	`+ private readonly IEnumerable<TValue> _values;`
`32`	`32`
`33`	`33`	`// constructors`
`34`	`34`	`/// <summary>`