Moved class map to another file

src/MongoDB.Bson/Serialization/BsonClassMapDomain.cs

@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace MongoDB.Bson.Serialization;
+
+internal class BsonClassMapDomain : IBsonClassMapDomain
+{
+    // private fields
+    private readonly Dictionary<Type, BsonClassMap> _classMaps = new();
+
+    /// <summary>
+    /// Gets all registered class maps.
+    /// </summary>
+    /// <returns>All registered class maps.</returns>
+    public IEnumerable<BsonClassMap> GetRegisteredClassMaps()
+    {
+        BsonSerializer.ConfigLock.EnterReadLock();  //TODO It would make sense to look at this after the PR by Robert is merged
+        try
+        {
+            return _classMaps.Values.ToList(); // return a copy for thread safety
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitReadLock();
+        }
+    }
+
+    /// <summary>
+    /// Checks whether a class map is registered for a type.
+    /// </summary>
+    /// <param name="type">The type to check.</param>
+    /// <returns>True if there is a class map registered for the type.</returns>
+    public bool IsClassMapRegistered(Type type)
+    {
+        if (type == null)
+        {
+            throw new ArgumentNullException("type");
+        }
+
+        BsonSerializer.ConfigLock.EnterReadLock();
+        try
+        {
+            return _classMaps.ContainsKey(type);
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitReadLock();
+        }
+    }
+
+    /// <summary>
+    /// Looks up a class map (will AutoMap the class if no class map is registered).
+    /// </summary>
+    /// <param name="classType">The class type.</param>
+    /// <returns>The class map.</returns>
+    public BsonClassMap LookupClassMap(Type classType)
+    {
+        if (classType == null)
+        {
+            throw new ArgumentNullException("classType");
+        }
+
+        BsonSerializer.ConfigLock.EnterReadLock();
+        try
+        {
+            if (_classMaps.TryGetValue(classType, out var classMap))
+            {
+                if (classMap.IsFrozen)
+                {
+                    return classMap;
+                }
+            }
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitReadLock();
+        }
+
+        // automatically create a new classMap for classType and register it (unless another thread does first)
+        // do the work of speculatively creating a new class map outside of holding any lock
+        var classMapDefinition = typeof(BsonClassMap<>);
+        var classMapType = classMapDefinition.MakeGenericType(classType);
+        var newClassMap = (BsonClassMap)Activator.CreateInstance(classMapType);
+        newClassMap.AutoMap();
+
+        BsonSerializer.ConfigLock.EnterWriteLock();
+        try
+        {
+            if (!_classMaps.TryGetValue(classType, out var classMap))
+            {
+                RegisterClassMap(newClassMap);
+                classMap = newClassMap;
+            }
+
+            return classMap.Freeze();
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Creates and registers a class map.
+    /// </summary>
+    /// <typeparam name="TClass">The class.</typeparam>
+    /// <returns>The class map.</returns>
+    public BsonClassMap<TClass> RegisterClassMap<TClass>()
+    {
+        return RegisterClassMap<TClass>(cm => { cm.AutoMap(); });
+    }
+
+    /// <summary>
+    /// Creates and registers a class map.
+    /// </summary>
+    /// <typeparam name="TClass">The class.</typeparam>
+    /// <param name="classMapInitializer">The class map initializer.</param>
+    /// <returns>The class map.</returns>
+    public BsonClassMap<TClass> RegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)
+    {
+        var classMap = new BsonClassMap<TClass>(classMapInitializer);
+        RegisterClassMap(classMap);
+        return classMap;
+    }
+
+    /// <summary>
+    /// Registers a class map.
+    /// </summary>
+    /// <param name="classMap">The class map.</param>
+    public void RegisterClassMap(BsonClassMap classMap)
+    {
+        if (classMap == null)
+        {
+            throw new ArgumentNullException("classMap");
+        }
+
+        BsonSerializer.ConfigLock.EnterWriteLock();
+        try
+        {
+            // note: class maps can NOT be replaced (because derived classes refer to existing instance)
+            _classMaps.Add(classMap.ClassType, classMap);
+            BsonSerializer.RegisterDiscriminator(classMap.ClassType, classMap.Discriminator);
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Registers a class map if it is not already registered.
+    /// </summary>
+    /// <typeparam name="TClass">The class.</typeparam>
+    /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
+    public bool TryRegisterClassMap<TClass>()
+    {
+        return TryRegisterClassMap(ClassMapFactory);
+
+        static BsonClassMap<TClass> ClassMapFactory()
+        {
+            var classMap = new BsonClassMap<TClass>();
+            classMap.AutoMap();
+            return classMap;
+        }
+    }
+
+    /// <summary>
+    /// Registers a class map if it is not already registered.
+    /// </summary>
+    /// <typeparam name="TClass">The class.</typeparam>
+    /// <param name="classMap">The class map.</param>
+    /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
+    public bool TryRegisterClassMap<TClass>(BsonClassMap<TClass> classMap)
+    {
+        if (classMap == null)
+        {
+            throw new ArgumentNullException(nameof(classMap));
+        }
+
+        return TryRegisterClassMap(ClassMapFactory);
+
+        BsonClassMap<TClass> ClassMapFactory()
+        {
+            return classMap;
+        }
+    }
+
+    /// <summary>
+    /// Registers a class map if it is not already registered.
+    /// </summary>
+    /// <typeparam name="TClass">The class.</typeparam>
+    /// <param name="classMapInitializer">The class map initializer (only called if the class map is not already registered).</param>
+    /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
+    public bool TryRegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)
+    {
+        if (classMapInitializer == null)
+        {
+            throw new ArgumentNullException(nameof(classMapInitializer));
+        }
+
+        return TryRegisterClassMap(ClassMapFactory);
+
+        BsonClassMap<TClass> ClassMapFactory()
+        {
+            return new BsonClassMap<TClass>(classMapInitializer);
+        }
+    }
+
+    /// <summary>
+    /// Registers a class map if it is not already registered.
+    /// </summary>
+    /// <typeparam name="TClass">The class.</typeparam>
+    /// <param name="classMapFactory">The class map factory (only called if the class map is not already registered).</param>
+    /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
+    public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFactory)
+    {
+        if (classMapFactory == null)
+        {
+            throw new ArgumentNullException(nameof(classMapFactory));
+        }
+
+        BsonSerializer.ConfigLock.EnterReadLock();
+        try
+        {
+            if (_classMaps.ContainsKey(typeof(TClass)))
+            {
+                return false;
+            }
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitReadLock();
+        }
+
+        BsonSerializer.ConfigLock.EnterWriteLock();
+        try
+        {
+            if (_classMaps.ContainsKey(typeof(TClass)))
+            {
+                return false;
+            }
+            else
+            {
+                // create a classMap for TClass and register it
+                var classMap = classMapFactory();
+                RegisterClassMap(classMap);
+                return true;
+            }
+        }
+        finally
+        {
+            BsonSerializer.ConfigLock.ExitWriteLock();
+        }
+    }
+}

src/MongoDB.Bson/Serialization/IBsonClassMapDomain.cs

@@ -15,7 +15,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 
 namespace MongoDB.Bson.Serialization
@@ -25,13 +24,6 @@ namespace MongoDB.Bson.Serialization
     /// </summary>
     public interface IBsonClassMapDomain
     {
-        /// <summary>
-        /// Gets the type of a member.
-        /// </summary>
-        /// <param name="memberInfo">The member info.</param>
-        /// <returns>The type of the member.</returns>
-        Type GetMemberInfoType(MemberInfo memberInfo);
-
         /// <summary>
         /// Gets all registered class maps.
         /// </summary>
@@ -104,280 +96,4 @@ public interface IBsonClassMapDomain
         /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
         bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFactory);
     }
-
-    internal class BsonClassMapDomain : IBsonClassMapDomain
-    {
-        // private fields
-        private readonly Dictionary<Type, BsonClassMap> _classMaps = new();
-
-        /// <summary>
-        /// Gets the type of a member.
-        /// </summary>
-        /// <param name="memberInfo">The member info.</param>
-        /// <returns>The type of the member.</returns>
-        public Type GetMemberInfoType(MemberInfo memberInfo)
-        {
-            if (memberInfo == null)
-            {
-                throw new ArgumentNullException("memberInfo");
-            }
-
-            if (memberInfo is FieldInfo)
-            {
-                return ((FieldInfo)memberInfo).FieldType;
-            }
-            else if (memberInfo is PropertyInfo)
-            {
-                return ((PropertyInfo)memberInfo).PropertyType;
-            }
-
-            throw new NotSupportedException("Only field and properties are supported at this time.");
-        }
-
-        /// <summary>
-        /// Gets all registered class maps.
-        /// </summary>
-        /// <returns>All registered class maps.</returns>
-        public IEnumerable<BsonClassMap> GetRegisteredClassMaps()
-        {
-            BsonSerializer.ConfigLock.EnterReadLock();  //TODO It would make sense to look at this after the PR by Robert is merged
-            try
-            {
-                return _classMaps.Values.ToList(); // return a copy for thread safety
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitReadLock();
-            }
-        }
-
-        /// <summary>
-        /// Checks whether a class map is registered for a type.
-        /// </summary>
-        /// <param name="type">The type to check.</param>
-        /// <returns>True if there is a class map registered for the type.</returns>
-        public bool IsClassMapRegistered(Type type)
-        {
-            if (type == null)
-            {
-                throw new ArgumentNullException("type");
-            }
-
-            BsonSerializer.ConfigLock.EnterReadLock();
-            try
-            {
-                return _classMaps.ContainsKey(type);
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitReadLock();
-            }
-        }
-
-        /// <summary>
-        /// Looks up a class map (will AutoMap the class if no class map is registered).
-        /// </summary>
-        /// <param name="classType">The class type.</param>
-        /// <returns>The class map.</returns>
-        public BsonClassMap LookupClassMap(Type classType)
-        {
-            if (classType == null)
-            {
-                throw new ArgumentNullException("classType");
-            }
-
-            BsonSerializer.ConfigLock.EnterReadLock();
-            try
-            {
-                if (_classMaps.TryGetValue(classType, out var classMap))
-                {
-                    if (classMap.IsFrozen)
-                    {
-                        return classMap;
-                    }
-                }
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitReadLock();
-            }
-
-            // automatically create a new classMap for classType and register it (unless another thread does first)
-            // do the work of speculatively creating a new class map outside of holding any lock
-            var classMapDefinition = typeof(BsonClassMap<>);
-            var classMapType = classMapDefinition.MakeGenericType(classType);
-            var newClassMap = (BsonClassMap)Activator.CreateInstance(classMapType);
-            newClassMap.AutoMap();
-
-            BsonSerializer.ConfigLock.EnterWriteLock();
-            try
-            {
-                if (!_classMaps.TryGetValue(classType, out var classMap))
-                {
-                    RegisterClassMap(newClassMap);
-                    classMap = newClassMap;
-                }
-
-                return classMap.Freeze();
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitWriteLock();
-            }
-        }
-
-        /// <summary>
-        /// Creates and registers a class map.
-        /// </summary>
-        /// <typeparam name="TClass">The class.</typeparam>
-        /// <returns>The class map.</returns>
-        public BsonClassMap<TClass> RegisterClassMap<TClass>()
-        {
-            return RegisterClassMap<TClass>(cm => { cm.AutoMap(); });
-        }
-
-        /// <summary>
-        /// Creates and registers a class map.
-        /// </summary>
-        /// <typeparam name="TClass">The class.</typeparam>
-        /// <param name="classMapInitializer">The class map initializer.</param>
-        /// <returns>The class map.</returns>
-        public BsonClassMap<TClass> RegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)
-        {
-            var classMap = new BsonClassMap<TClass>(classMapInitializer);
-            RegisterClassMap(classMap);
-            return classMap;
-        }
-
-        /// <summary>
-        /// Registers a class map.
-        /// </summary>
-        /// <param name="classMap">The class map.</param>
-        public void RegisterClassMap(BsonClassMap classMap)
-        {
-            if (classMap == null)
-            {
-                throw new ArgumentNullException("classMap");
-            }
-
-            BsonSerializer.ConfigLock.EnterWriteLock();
-            try
-            {
-                // note: class maps can NOT be replaced (because derived classes refer to existing instance)
-                _classMaps.Add(classMap.ClassType, classMap);
-                BsonSerializer.RegisterDiscriminator(classMap.ClassType, classMap.Discriminator);
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitWriteLock();
-            }
-        }
-
-        /// <summary>
-        /// Registers a class map if it is not already registered.
-        /// </summary>
-        /// <typeparam name="TClass">The class.</typeparam>
-        /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public bool TryRegisterClassMap<TClass>()
-        {
-            return TryRegisterClassMap(ClassMapFactory);
-
-            static BsonClassMap<TClass> ClassMapFactory()
-            {
-                var classMap = new BsonClassMap<TClass>();
-                classMap.AutoMap();
-                return classMap;
-            }
-        }
-
-        /// <summary>
-        /// Registers a class map if it is not already registered.
-        /// </summary>
-        /// <typeparam name="TClass">The class.</typeparam>
-        /// <param name="classMap">The class map.</param>
-        /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public bool TryRegisterClassMap<TClass>(BsonClassMap<TClass> classMap)
-        {
-            if (classMap == null)
-            {
-                throw new ArgumentNullException(nameof(classMap));
-            }
-
-            return TryRegisterClassMap(ClassMapFactory);
-
-            BsonClassMap<TClass> ClassMapFactory()
-            {
-                return classMap;
-            }
-        }
-
-        /// <summary>
-        /// Registers a class map if it is not already registered.
-        /// </summary>
-        /// <typeparam name="TClass">The class.</typeparam>
-        /// <param name="classMapInitializer">The class map initializer (only called if the class map is not already registered).</param>
-        /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public bool TryRegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)
-        {
-            if (classMapInitializer == null)
-            {
-                throw new ArgumentNullException(nameof(classMapInitializer));
-            }
-
-            return TryRegisterClassMap(ClassMapFactory);
-
-            BsonClassMap<TClass> ClassMapFactory()
-            {
-                return new BsonClassMap<TClass>(classMapInitializer);
-            }
-        }
-
-        /// <summary>
-        /// Registers a class map if it is not already registered.
-        /// </summary>
-        /// <typeparam name="TClass">The class.</typeparam>
-        /// <param name="classMapFactory">The class map factory (only called if the class map is not already registered).</param>
-        /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFactory)
-        {
-            if (classMapFactory == null)
-            {
-                throw new ArgumentNullException(nameof(classMapFactory));
-            }
-
-            BsonSerializer.ConfigLock.EnterReadLock();
-            try
-            {
-                if (_classMaps.ContainsKey(typeof(TClass)))
-                {
-                    return false;
-                }
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitReadLock();
-            }
-
-            BsonSerializer.ConfigLock.EnterWriteLock();
-            try
-            {
-                if (_classMaps.ContainsKey(typeof(TClass)))
-                {
-                    return false;
-                }
-                else
-                {
-                    // create a classMap for TClass and register it
-                    var classMap = classMapFactory();
-                    RegisterClassMap(classMap);
-                    return true;
-                }
-            }
-            finally
-            {
-                BsonSerializer.ConfigLock.ExitWriteLock();
-            }
-        }
-    }
-
 }