added interface serializer and support for top-level serializer specificity to allow for customer serializers to get injected/built at runtime.

Author: craiggwilson

MongoDB.Bson/MongoDB.Bson.csproj

@@ -258,6 +258,7 @@
     <Compile Include="Serialization\Serializers\Int16Serializer.cs" />
     <Compile Include="Serialization\Serializers\Int32Serializer.cs" />
     <Compile Include="Serialization\Serializers\Int64Serializer.cs" />
+    <Compile Include="Serialization\Serializers\InterfaceSerializer.cs" />
     <Compile Include="Serialization\Serializers\IPAddressSerializer.cs" />
     <Compile Include="Serialization\Serializers\IPEndPointSerializer.cs" />
     <Compile Include="Serialization\Serializers\KeyValuePairSerializer.cs" />

MongoDB.Bson/Serialization/BsonDefaultSerializationProvider.cs

@@ -183,6 +183,13 @@ public IBsonSerializer GetSerializer(Type type)
                 return collectionSerializer;
             }
 
+            // we'll try our best by attempting to find a discriminator hoping it points
+            // us to a concrete type with a serializer.
+            if (type.IsInterface)
+            {
+                return InterfaceSerializer.Instance;
+            }
+
             return null;
         }
 

MongoDB.Bson/Serialization/Serializers/InterfaceSerializer.cs

@@ -0,0 +1,131 @@
+/* Copyright 2010-2013 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Bson.Serialization.Serializers
+{
+    /// <summary>
+    /// Represents a serializer for Interfaces.
+    /// </summary>
+    public class InterfaceSerializer : BsonBaseSerializer
+    {
+        // private static fields
+        private static InterfaceSerializer __instance = new InterfaceSerializer();
+
+        // constructors
+        /// <summary>
+        /// Initializes a new instance of the InterfaceSerializer class.
+        /// </summary>
+        public InterfaceSerializer()
+        {
+        }
+
+        // public static properties
+        /// <summary>
+        /// Gets an instance of the InterfaceSerializer class.
+        /// </summary>
+        public static InterfaceSerializer Instance
+        {
+            get { return __instance; }
+        }
+
+        // public methods
+        /// <summary>
+        /// Deserializes a document from a BsonReader.
+        /// </summary>
+        /// <param name="bsonReader">The BsonReader.</param>
+        /// <param name="nominalType">The nominal type of the document.</param>
+        /// <param name="options">The serialization options.</param>
+        /// <returns>A document.</returns>
+        public override object Deserialize(
+            BsonReader bsonReader,
+            Type nominalType,
+            IBsonSerializationOptions options)
+        {
+            if (!nominalType.IsInterface)
+            {
+                var message = string.Format("Nominal type must be an interface, not {0}.", nominalType.FullName);
+                throw new ArgumentException(message, "nominalType");
+            }
+
+            var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(nominalType);
+            var actualType = discriminatorConvention.GetActualType(bsonReader, nominalType);
+            if (actualType == nominalType)
+            {
+                var message = string.Format("Unable to determine actual type of object to deserialize. NominalType is the interface {0}.", nominalType);
+                throw new FileFormatException(message);
+            }
+
+            return Deserialize(bsonReader, nominalType, actualType, options);
+        }
+
+        /// <summary>
+        /// Deserializes a document from a BsonReader.
+        /// </summary>
+        /// <param name="bsonReader">The BsonReader.</param>
+        /// <param name="nominalType">The nominal type of the document.</param>
+        /// <param name="actualType">The actual type of the document..</param>
+        /// <param name="options">The serialization options.</param>
+        /// <returns>A document.</returns>
+        public override object Deserialize(
+            BsonReader bsonReader,
+            Type nominalType,
+            Type actualType,
+            IBsonSerializationOptions options)
+        {
+            var serializer = BsonSerializer.LookupSerializer(actualType);
+            return serializer.Deserialize(bsonReader, nominalType, actualType, options);
+        }
+
+        /// <summary>
+        /// Serializes a document to a BsonWriter.
+        /// </summary>
+        /// <param name="bsonWriter">The BsonWriter.</param>
+        /// <param name="nominalType">The nominal type.</param>
+        /// <param name="value">The document.</param>
+        /// <param name="options">The serialization options.</param>
+        public override void Serialize(
+            BsonWriter bsonWriter,
+            Type nominalType,
+            object value,
+            IBsonSerializationOptions options)
+        {
+            if (!nominalType.IsInterface)
+            {
+                var message = string.Format("Nominal type must be an interface, not {0}.", nominalType.FullName);
+                throw new ArgumentException(message, "nominalType");
+            }
+
+            if (value == null)
+            {
+                bsonWriter.WriteNull();
+            }
+            else
+            {
+                var actualType = value.GetType();
+                var serializer = BsonSerializer.LookupSerializer(actualType);
+                serializer.Serialize(bsonWriter, nominalType, value, options);
+            }
+        }
+    }
+}

MongoDB.Driver/Communication/Messages/MongoReplyMessage.cs

@@ -25,18 +25,20 @@ namespace MongoDB.Driver.Internal
     internal class MongoReplyMessage<TDocument> : MongoMessage
     {
         // private fields
-        private BsonBinaryReaderSettings _readerSettings;
+        private readonly BsonBinaryReaderSettings _readerSettings;
+        private readonly IBsonSerializer _serializer;
         private ResponseFlags _responseFlags;
         private long _cursorId;
         private int _startingFrom;
         private int _numberReturned;
         private List<TDocument> _documents;
 
         // constructors
-        internal MongoReplyMessage(BsonBinaryReaderSettings readerSettings)
+        internal MongoReplyMessage(BsonBinaryReaderSettings readerSettings, IBsonSerializer serializer)
             : base(MessageOpcode.Reply)
         {
             _readerSettings = readerSettings;
+            _serializer = serializer;
         }
 
         // internal properties
@@ -117,10 +119,10 @@ internal void ReadFrom(BsonBuffer buffer, IBsonSerializationOptions serializatio
 
                 using (var bsonReader = new BsonBinaryReader(sliceBuffer, true, _readerSettings))
                 {
-                    var document = (TDocument)BsonSerializer.Deserialize(bsonReader, typeof(TDocument), serializationOptions);
+                    var document = (TDocument)_serializer.Deserialize(bsonReader, typeof(TDocument), serializationOptions);
                     _documents.Add(document);
                 }
             }
         }
     }
-}
+}

MongoDB.Driver/Communication/MongoConnection.cs

@@ -22,6 +22,7 @@
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Communication.Security;
 
 namespace MongoDB.Driver.Internal
@@ -267,7 +268,7 @@ internal CommandResult RunCommand(
                 GuidRepresentation = GuidRepresentation.Unspecified,
                 MaxDocumentSize = _serverInstance.MaxDocumentSize
             };
-            var reply = ReceiveMessage<BsonDocument>(readerSettings, null);
+            var reply = ReceiveMessage<BsonDocument>(readerSettings, BsonDocumentSerializer.Instance, null);
             if (reply.NumberReturned == 0)
             {
                 var message = string.Format("Command '{0}' failed. No response returned.", commandName);
@@ -285,6 +286,7 @@ internal CommandResult RunCommand(
 
         internal MongoReplyMessage<TDocument> ReceiveMessage<TDocument>(
             BsonBinaryReaderSettings readerSettings,
+            IBsonSerializer serializer,
             IBsonSerializationOptions serializationOptions)
         {
             if (_state == MongoConnectionState.Closed) { throw new InvalidOperationException("Connection is closed."); }
@@ -304,7 +306,7 @@ internal MongoReplyMessage<TDocument> ReceiveMessage<TDocument>(
                     using (var bsonBuffer = new BsonBuffer(byteBuffer, true))
                     {
                         byteBuffer.MakeReadOnly();
-                        var reply = new MongoReplyMessage<TDocument>(readerSettings);
+                        var reply = new MongoReplyMessage<TDocument>(readerSettings, serializer);
                         reply.ReadFrom(bsonBuffer, serializationOptions);
                         return reply;
                     }
@@ -373,7 +375,7 @@ internal WriteConcernResult SendMessage(BsonBuffer buffer, MongoRequestMessage m
                         GuidRepresentation = message.WriterSettings.GuidRepresentation,
                         MaxDocumentSize = _serverInstance.MaxDocumentSize
                     };
-                    var replyMessage = ReceiveMessage<BsonDocument>(readerSettings, null);
+                    var replyMessage = ReceiveMessage<BsonDocument>(readerSettings, BsonDocumentSerializer.Instance, null);
                     var getLastErrorResponse = replyMessage.Documents[0];
                     writeConcernResult = new WriteConcernResult();
                     writeConcernResult.Initialize(getLastErrorCommand, getLastErrorResponse);

MongoDB.Driver/MongoCollection.cs

@@ -543,7 +543,8 @@ public virtual FindAndModifyResult FindAndRemove(IMongoQuery query, IMongoSortBy
         /// <returns>A <see cref="MongoCursor{TDocument}"/>.</returns>
         public virtual MongoCursor<TDocument> FindAs<TDocument>(IMongoQuery query)
         {
-            return new MongoCursor<TDocument>(this, query, _settings.ReadPreference);
+            var serializer = BsonSerializer.LookupSerializer(typeof(TDocument));
+            return new MongoCursor<TDocument>(this, query, _settings.ReadPreference, serializer);
         }
 
         /// <summary>
@@ -554,7 +555,8 @@ public virtual MongoCursor<TDocument> FindAs<TDocument>(IMongoQuery query)
         /// <returns>A <see cref="MongoCursor{TDocument}"/>.</returns>
         public virtual MongoCursor FindAs(Type documentType, IMongoQuery query)
         {
-            return MongoCursor.Create(documentType, this, query, _settings.ReadPreference);
+            var serializer = BsonSerializer.LookupSerializer(documentType);
+            return MongoCursor.Create(documentType, this, query, _settings.ReadPreference, serializer);
         }
 
         /// <summary>

MongoDB.Driver/MongoCursor.cs

@@ -19,6 +19,7 @@
 using System.Linq;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Builders;
 
 namespace MongoDB.Driver
@@ -30,10 +31,11 @@ namespace MongoDB.Driver
     public abstract class MongoCursor : IEnumerable
     {
         // private fields
-        private MongoServer _server;
-        private MongoDatabase _database;
-        private MongoCollection _collection;
-        private IMongoQuery _query;
+        private readonly MongoCollection _collection;
+        private readonly MongoDatabase _database;
+        private readonly IMongoQuery _query;
+        private readonly IBsonSerializer _serializer;
+        private readonly MongoServer _server;
         private IMongoFields _fields;
         private BsonDocument _options;
         private QueryFlags _flags;
@@ -51,12 +53,14 @@ public abstract class MongoCursor : IEnumerable
         /// <param name="collection">The collection.</param>
         /// <param name="query">The query.</param>
         /// <param name="readPreference">The read preference.</param>
-        protected MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference)
+        /// <param name="serializer">The serializer.</param>
+        protected MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer)
         {
-            _server = collection.Database.Server;
-            _database = collection.Database;
             _collection = collection;
+            _database = collection.Database;
+            _server = collection.Database.Server;
             _query = query;
+            _serializer = serializer;
             _readPreference = readPreference;
         }
 
@@ -224,6 +228,14 @@ public virtual IBsonSerializationOptions SerializationOptions
             }
         }
 
+        /// <summary>
+        /// Gets the serializer.
+        /// </summary>
+        public virtual IBsonSerializer Serializer
+        {
+            get { return _serializer; }
+        }
+
         /// <summary>
         /// Gets whether the cursor has been frozen to prevent further changes.
         /// </summary>
@@ -241,13 +253,14 @@ public virtual bool IsFrozen
         /// <param name="collection">The collection to query.</param>
         /// <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)
+        public static MongoCursor Create(Type documentType, MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer)
         {
             var cursorDefinition = typeof(MongoCursor<>);
             var cursorType = cursorDefinition.MakeGenericType(documentType);
-            var constructorInfo = cursorType.GetConstructor(new Type[] { typeof(MongoCollection), typeof(IMongoQuery), typeof(ReadPreference) });
-            return (MongoCursor)constructorInfo.Invoke(new object[] { collection, query, readPreference });
+            var constructorInfo = cursorType.GetConstructor(new Type[] { typeof(MongoCollection), typeof(IMongoQuery), typeof(ReadPreference), typeof(IBsonSerializer)});
+            return (MongoCursor)constructorInfo.Invoke(new object[] { collection, query, readPreference, serializer });
         }
 
         // public methods
@@ -261,14 +274,36 @@ public virtual MongoCursor<TDocument> Clone<TDocument>()
             return (MongoCursor<TDocument>)Clone(typeof(TDocument));
         }
 
+        /// <summary>
+        /// Creates a clone of the cursor.
+        /// </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)
+        {
+            return (MongoCursor<TDocument>)Clone(typeof(TDocument), serializer);
+        }
+
         /// <summary>
         /// Creates a clone of the cursor.
         /// </summary>
         /// <param name="documentType">The type of the documents returned.</param>
         /// <returns>A clone of the cursor.</returns>
         public virtual MongoCursor Clone(Type documentType)
         {
-            var clone = Create(documentType, _collection, _query, _readPreference);
+            return Clone(documentType, _serializer);
+        }
+
+        /// <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)
+        {
+            var clone = Create(documentType, _collection, _query, _readPreference, serializer);
             clone._options = _options == null ? null : (BsonDocument)_options.Clone();
             clone._flags = _flags;
             clone._skip = _skip;
@@ -312,7 +347,7 @@ public virtual BsonDocument Explain()
         public virtual BsonDocument Explain(bool verbose)
         {
             _isFrozen = true;
-            var clone = Clone<BsonDocument>();
+            var clone = Clone<BsonDocument>(BsonDocumentSerializer.Instance);
             clone.SetOption("$explain", true);
             clone._limit = -clone._limit; // TODO: should this be -1?
             var explanation = clone.FirstOrDefault();
@@ -647,8 +682,9 @@ public class MongoCursor<TDocument> : MongoCursor, IEnumerable<TDocument>
         /// <param name="collection">The collection.</param>
         /// <param name="query">The query.</param>
         /// <param name="readPreference">The read preference.</param>
-        public MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference)
-            : base(collection, query, readPreference)
+        /// <param name="serializer">The serializer.</param>
+        public MongoCursor(MongoCollection collection, IMongoQuery query, ReadPreference readPreference, IBsonSerializer serializer)
+            : base(collection, query, readPreference, serializer)
         {
         }
 

MongoDB.Driver/MongoCursorEnumerator.cs

@@ -371,7 +371,7 @@ private MongoReplyMessage<TDocument> GetReply(MongoConnection connection, MongoR
         {
             var readerSettings = _cursor.Collection.GetReaderSettings(connection);
             connection.SendMessage(message, null, _cursor.Database.Name); // write concern doesn't apply to queries
-            var reply = connection.ReceiveMessage<TDocument>(readerSettings, _cursor.SerializationOptions);
+            var reply = connection.ReceiveMessage<TDocument>(readerSettings, _cursor.Serializer, _cursor.SerializationOptions);
             _responseFlags = reply.ResponseFlags;
             _openCursorId = reply.CursorId;
             return reply;