Merged pull request for CSHARP-451 with changes. Restored explicit registration of default serialization provider. Registering a serializer for any type that implements IBsonSerializable is not allowed for performance reasons.

Author: Robert Stam

Bson/Serialization/BsonClassMap.cs

@@ -968,18 +968,20 @@ public void UnmapProperty(string propertyName)
 
         // internal methods
         /// <summary>
-        /// Gets the discriminator convention for the member type.
+        /// Gets the discriminator convention for the class.
         /// </summary>
-        /// <returns>The discriminator convention for the member type.</returns>
+        /// <returns>The discriminator convention for the class.</returns>
         internal IDiscriminatorConvention GetDiscriminatorConvention()
         {
-            var classDiscriminatorConvention = _cachedDiscriminatorConvention;
-            if (classDiscriminatorConvention == null)
+            // return a cached discriminator convention when possible
+            var discriminatorConvention = _cachedDiscriminatorConvention;
+            if (discriminatorConvention == null)
             {
-                classDiscriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_classType);
-                _cachedDiscriminatorConvention = classDiscriminatorConvention;
+                // it's possible but harmless for multiple threads to do the initial lookup at the same time
+                discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_classType);
+                _cachedDiscriminatorConvention = discriminatorConvention;
             }
-            return classDiscriminatorConvention;
+            return discriminatorConvention;
         }
 
         // private methods

Bson/Serialization/BsonMemberMap.cs

@@ -287,21 +287,24 @@ public void ApplyDefaultValue(object obj)
         /// <returns>The member map.</returns>
         public IBsonSerializer GetSerializer(Type actualType)
         {
+            // if a custom serializer is configured always return it
             if (_serializer != null)
             {
                 return _serializer;
             }
             else
             {
+                // return a cached serializer when possible
                 if (actualType == _memberType)
                 {
-                    var cachedSerializer = _cachedSerializer;
-                    if (cachedSerializer == null)
+                    var serializer = _cachedSerializer;
+                    if (serializer == null)
                     {
-                        cachedSerializer = BsonSerializer.LookupSerializer(_memberType);
-                        _cachedSerializer = cachedSerializer;
+                        // it's possible but harmless for multiple threads to do the initial lookup at the same time
+                        serializer = BsonSerializer.LookupSerializer(_memberType);
+                        _cachedSerializer = serializer;
                     }
-                    return cachedSerializer;
+                    return serializer;
                 }
                 else
                 {
@@ -505,13 +508,15 @@ public bool ShouldSerialize(object obj, object value)
         /// <returns>The discriminator convention for the member type.</returns>
         internal IDiscriminatorConvention GetDiscriminatorConvention()
         {
-            var classDiscriminatorConvention = _cachedDiscriminatorConvention;
-            if (classDiscriminatorConvention == null)
+            // return a cached discriminator convention when possible
+            var discriminatorConvention = _cachedDiscriminatorConvention;
+            if (discriminatorConvention == null)
             {
-                classDiscriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_memberType);
-                _cachedDiscriminatorConvention = classDiscriminatorConvention;
+                // it's possible but harmless for multiple threads to do the initial lookup at the same time
+                discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_memberType);
+                _cachedDiscriminatorConvention = discriminatorConvention;
             }
-            return classDiscriminatorConvention;
+            return discriminatorConvention;
         }
 
         // private methods

Bson/Serialization/BsonSerializer.cs

@@ -43,6 +43,7 @@ public static class BsonSerializer
         // static constructor
         static BsonSerializer()
         {
+            RegisterDefaultSerializationProvider();
             RegisterIdGenerators();
         }
 
@@ -358,16 +359,22 @@ public static IIdGenerator LookupIdGenerator(Type type)
         }
 
         /// <summary>
-        /// Looks up and populates the serializer singleton for a type.
+        /// Looks up a serializer for a Type.
         /// </summary>
         /// <param name="type">The Type.</param>
         /// <returns>A serializer for the Type.</returns>
         public static IBsonSerializer LookupSerializer(Type type)
         {
+            // since we don't allow registering serializers for classes that implement IBsonSerializable no lookup is needed
+            if (typeof(IBsonSerializable).IsAssignableFrom(type))
+            {
+                return Serializers.BsonIBsonSerializableSerializer.Instance;
+            }
+
             __configLock.EnterReadLock();
             try
             {
-               IBsonSerializer serializer;
+                IBsonSerializer serializer;
                 if (__serializers.TryGetValue(type, out serializer))
                 {
                     return serializer;
@@ -384,24 +391,6 @@ public static IBsonSerializer LookupSerializer(Type type)
                 IBsonSerializer serializer;
                 if (!__serializers.TryGetValue(type, out serializer))
                 {
-                    if (serializer == null)
-                    {
-                        foreach (var serializationProvider in __serializationProviders)
-                        {
-                            serializer = serializationProvider.GetSerializer(type);
-                            if (serializer != null)
-                            {
-                                break;
-                            }
-                        }
-                    }
-
-                    // special case for IBsonSerializable
-                    if (serializer == null && typeof(IBsonSerializable).IsAssignableFrom(type))
-                    {
-                        serializer = Serializers.BsonIBsonSerializableSerializer.Instance;
-                    }
-
                     if (serializer == null && type.IsGenericType)
                     {
                         var genericTypeDefinition = type.GetGenericTypeDefinition();
@@ -415,7 +404,14 @@ public static IBsonSerializer LookupSerializer(Type type)
 
                     if (serializer == null)
                     {
-                        serializer = BsonDefaultSerializer.Instance.GetSerializer(type);
+                        foreach (var serializationProvider in __serializationProviders)
+                        {
+                            serializer = serializationProvider.GetSerializer(type);
+                            if (serializer != null)
+                            {
+                                break;
+                            }
+                        }
                     }
 
                     if (serializer == null)
@@ -479,11 +475,6 @@ public static void RegisterIdGenerator(Type type, IIdGenerator idGenerator)
         /// <param name="provider">The serialization provider.</param>
         public static void RegisterSerializationProvider(IBsonSerializationProvider provider)
         {
-            if (provider == BsonDefaultSerializer.Instance)
-            {
-                throw new ArgumentException("BsonDefaultSerializer is implicitly registered", "provider");
-            }
-
             __configLock.EnterWriteLock();
             try
             {
@@ -503,6 +494,12 @@ public static void RegisterSerializationProvider(IBsonSerializationProvider prov
         /// <param name="serializer">The serializer.</param>
         public static void RegisterSerializer(Type type, IBsonSerializer serializer)
         {
+            if (typeof(IBsonSerializable).IsAssignableFrom(type))
+            {
+                var message = string.Format("A serializer cannot be registered for type {0} because it implements IBsonSerializable.", BsonUtils.GetFriendlyTypeName(type));
+                throw new BsonSerializationException(message);
+            }
+
             __configLock.EnterWriteLock();
             try
             {
@@ -569,12 +566,25 @@ public static void Serialize(
             object value,
             IBsonSerializationOptions options)
         {
+            // since we don't allow registering serializers for classes that implement IBsonSerializable no lookup is needed
+            var bsonSerializable = value as IBsonSerializable;
+            if (bsonSerializable != null)
+            {
+                bsonSerializable.Serialize(bsonWriter, nominalType, options);
+                return;
+            }
+
             var actualType = (value == null) ? nominalType : value.GetType();
             var serializer = LookupSerializer(actualType);
             serializer.Serialize(bsonWriter, nominalType, value, options);
         }
 
         // private static methods
+        private static void RegisterDefaultSerializationProvider()
+        {
+            RegisterSerializationProvider(BsonDefaultSerializer.Instance);
+        }
+
         private static void RegisterIdGenerators()
         {
             BsonSerializer.RegisterIdGenerator(typeof(BsonObjectId), BsonObjectIdGenerator.Instance);