CSHARP-4424: Added TryRegisterClassMap method to BsonClassMap.

Author: rstam

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -415,6 +415,112 @@ public static void RegisterClassMap(BsonClassMap classMap)
             }
         }
 
+        /// <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 static 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 static 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 static 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 static 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();
+            }
+        }
+
         // public methods
         /// <summary>
         /// Automaps the class.

tests/MongoDB.Bson.Tests/Jira/CSharp4424Tests.cs

@@ -0,0 +1,104 @@
+/* Copyright 2010-present MongoDB 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 FluentAssertions;
+using MongoDB.Bson.Serialization;
+using Xunit;
+
+namespace MongoDB.Bson.Tests.Jira
+{
+    public class CSharp4424Tests
+    {
+        [Fact]
+        public void TryRegisterClassMap_with_no_arguments_can_be_called_more_than_once()
+        {
+            var result = BsonClassMap.TryRegisterClassMap<C>();
+            result.Should().BeTrue();
+
+            result = BsonClassMap.TryRegisterClassMap<C>();
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void TryRegisterClassMap_with_classMap_can_be_called_more_than_once()
+        {
+            var classMap = new BsonClassMap<D>(cm => cm.AutoMap());
+
+            var result = BsonClassMap.TryRegisterClassMap(classMap);
+            result.Should().BeTrue();
+
+            result = BsonClassMap.TryRegisterClassMap(classMap);
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void TryRegisterClassMap_with_classMapInitializer_can_be_called_more_than_once()
+        {
+            var classMapInitializerCallCount = 0;
+
+            var result = BsonClassMap.TryRegisterClassMap<E>(ClassMapInitializer);
+            result.Should().BeTrue();
+            classMapInitializerCallCount.Should().Be(1);
+
+            result = BsonClassMap.TryRegisterClassMap<E>(ClassMapInitializer);
+            result.Should().BeFalse();
+            classMapInitializerCallCount.Should().Be(1);
+
+            void ClassMapInitializer(BsonClassMap<E> cm)
+            {
+                classMapInitializerCallCount++;
+                cm.AutoMap();
+            }
+        }
+
+        [Fact]
+        public void TryRegisterClassMap_with_classMapFactory_should_only_call_factory_once()
+        {
+            var classMapFactoryCallCount = 0;
+
+            var result = BsonClassMap.TryRegisterClassMap(ClassMapFactory);
+            result.Should().BeTrue();
+            classMapFactoryCallCount.Should().Be(1);
+
+            result = BsonClassMap.TryRegisterClassMap(ClassMapFactory);
+            result.Should().BeFalse();
+            classMapFactoryCallCount.Should().Be(1);
+
+            BsonClassMap<F> ClassMapFactory()
+            {
+                classMapFactoryCallCount++;
+                var classMap = new BsonClassMap<F>();
+                classMap.AutoMap();
+                return classMap;
+            }
+        }
+
+        public class C
+        {
+        }
+
+        public class D
+        {
+        }
+
+        public class E
+        {
+        }
+
+        public class F
+        {
+        }
+    }
+}