Merge branch 'master' of git://github.com/optimiz3/mongo-csharp-driver into csharp451

Author: Robert Stam

Bson/Serialization/BsonClassMap.cs

@@ -47,6 +47,7 @@ public abstract class BsonClassMap
         private bool _frozen; // once a class map has been frozen no further changes are allowed
         private BsonClassMap _baseClassMap; // null for class object and interfaces
         private Type _classType;
+        private volatile IDiscriminatorConvention _cachedDiscriminatorConvention;
         private Func<object> _creator;
         private ConventionProfile _conventions;
         private string _discriminator;
@@ -965,6 +966,22 @@ public void UnmapProperty(string propertyName)
             UnmapMember(propertyInfo);
         }
 
+        // internal methods
+        /// <summary>
+        /// Gets the discriminator convention for the member type.
+        /// </summary>
+        /// <returns>The discriminator convention for the member type.</returns>
+        internal IDiscriminatorConvention GetDiscriminatorConvention()
+        {
+            var classDiscriminatorConvention = _cachedDiscriminatorConvention;
+            if (classDiscriminatorConvention == null)
+            {
+                classDiscriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_classType);
+                _cachedDiscriminatorConvention = classDiscriminatorConvention;
+            }
+            return classDiscriminatorConvention;
+        }
+
         // private methods
         private void AutoMapClass()
         {
@@ -1485,7 +1502,7 @@ public void UnmapProperty<TMember>(Expression<Func<TClass, TMember>> propertyLam
             UnmapMember(propertyLambda);
         }
 
-        // private methods
+        // private static methods
         private static MemberInfo GetMemberInfoFromLambda<TMember>(Expression<Func<TClass, TMember>> memberLambda)
         {
             var body = memberLambda.Body;

Bson/Serialization/BsonClassMapSerializer.cs

@@ -63,7 +63,7 @@ public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializ
             }
             else
             {
-                var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                var discriminatorConvention = _classMap.GetDiscriminatorConvention();
                 var actualType = discriminatorConvention.GetActualType(bsonReader, nominalType);
                 if (actualType != nominalType)
                 {
@@ -131,7 +131,7 @@ public object Deserialize(
 
                 bsonReader.ReadStartDocument();
                 var missingElementMemberMaps = new HashSet<BsonMemberMap>(classMap.AllMemberMaps); // make a copy!
-                var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                var discriminatorConvention = classMap.GetDiscriminatorConvention();
                 while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
                 {
                     var elementName = bsonReader.ReadName();
@@ -337,7 +337,7 @@ public void Serialize(
                     // never write out a discriminator for an anonymous class
                     if (!classMap.IsAnonymous)
                     {
-                        var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                        var discriminatorConvention = classMap.GetDiscriminatorConvention();
                         var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
                         if (discriminator != null)
                         {
@@ -443,7 +443,7 @@ private void DeserializeMember(BsonReader bsonReader, object obj, BsonMemberMap
                 }
                 else
                 {
-                    var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+                    var discriminatorConvention = memberMap.GetDiscriminatorConvention();
                     actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found
                 }
                 var serializer = memberMap.GetSerializer(actualType);

Bson/Serialization/BsonMemberMap.cs

@@ -44,6 +44,8 @@ public class BsonMemberMap
         private Action<object, object> _setter;
         private IBsonSerializationOptions _serializationOptions;
         private IBsonSerializer _serializer;
+        private volatile IDiscriminatorConvention _cachedDiscriminatorConvention;
+        private volatile IBsonSerializer _cachedSerializer;
         private IIdGenerator _idGenerator;
         private bool _isRequired;
         private Func<object, bool> _shouldSerializeMethod;
@@ -291,7 +293,20 @@ public IBsonSerializer GetSerializer(Type actualType)
             }
             else
             {
-                return BsonSerializer.LookupSerializer(actualType);
+                if (actualType == _memberType)
+                {
+                    var cachedSerializer = _cachedSerializer;
+                    if (cachedSerializer == null)
+                    {
+                        cachedSerializer = BsonSerializer.LookupSerializer(_memberType);
+                        _cachedSerializer = cachedSerializer;
+                    }
+                    return cachedSerializer;
+                }
+                else
+                {
+                    return BsonSerializer.LookupSerializer(actualType);
+                }
             }
         }
 
@@ -483,6 +498,22 @@ public bool ShouldSerialize(object obj, object value)
             return true;
         }
 
+        // internal methods
+        /// <summary>
+        /// Gets the discriminator convention for the member type.
+        /// </summary>
+        /// <returns>The discriminator convention for the member type.</returns>
+        internal IDiscriminatorConvention GetDiscriminatorConvention()
+        {
+            var classDiscriminatorConvention = _cachedDiscriminatorConvention;
+            if (classDiscriminatorConvention == null)
+            {
+                classDiscriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(_memberType);
+                _cachedDiscriminatorConvention = classDiscriminatorConvention;
+            }
+            return classDiscriminatorConvention;
+        }
+
         // private methods
         private static object GetDefaultValue(Type type)
         {

Bson/Serialization/BsonSerializer.cs

@@ -43,7 +43,6 @@ public static class BsonSerializer
         // static constructor
         static BsonSerializer()
         {
-            RegisterDefaultSerializationProvider();
             RegisterIdGenerators();
         }
 
@@ -359,7 +358,7 @@ public static IIdGenerator LookupIdGenerator(Type type)
         }
 
         /// <summary>
-        /// Looks up a serializer for a Type.
+        /// Looks up and populates the serializer singleton for a type.
         /// </summary>
         /// <param name="type">The Type.</param>
         /// <returns>A serializer for the Type.</returns>
@@ -368,7 +367,7 @@ public static IBsonSerializer LookupSerializer(Type type)
             __configLock.EnterReadLock();
             try
             {
-                IBsonSerializer serializer;
+               IBsonSerializer serializer;
                 if (__serializers.TryGetValue(type, out serializer))
                 {
                     return serializer;
@@ -385,6 +384,18 @@ 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))
                     {
@@ -404,14 +415,7 @@ public static IBsonSerializer LookupSerializer(Type type)
 
                     if (serializer == null)
                     {
-                        foreach (var serializationProvider in __serializationProviders)
-                        {
-                            serializer = serializationProvider.GetSerializer(type);
-                            if (serializer != null)
-                            {
-                                break;
-                            }
-                        }
+                        serializer = BsonDefaultSerializer.Instance.GetSerializer(type);
                     }
 
                     if (serializer == null)
@@ -475,6 +479,11 @@ 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
             {
@@ -497,7 +506,12 @@ public static void RegisterSerializer(Type type, IBsonSerializer serializer)
             __configLock.EnterWriteLock();
             try
             {
-                __serializers[type] = serializer;
+                if (__serializers.ContainsKey(type))
+                {
+                    var message = string.Format("There is already a serializer registered for type {0}.", type.FullName);
+                    throw new BsonSerializationException(message);
+                }
+                __serializers.Add(type, serializer);
             }
             finally
             {
@@ -555,24 +569,12 @@ public static void Serialize(
             object value,
             IBsonSerializationOptions options)
         {
-            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);