CSHARP-4534: Allow anonymous types in ObjectSerializer.DefaultAllowedTypes.

Author: rstam

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -71,7 +71,7 @@ public BsonClassMap(Type classType)
             _classType = classType;
             _creatorMaps = new List<BsonCreatorMap>();
             _conventionPack = ConventionRegistry.Lookup(classType);
-            _isAnonymous = IsAnonymousType(classType);
+            _isAnonymous = classType.IsAnonymousType();
             _allMemberMaps = new List<BsonMemberMap>();
             _allMemberMapsReadonly = _allMemberMaps.AsReadOnly();
             _declaredMemberMaps = new List<BsonMemberMap>();
@@ -1370,16 +1370,6 @@ private Func<object, bool> GetShouldSerializeMethod(MemberInfo memberInfo)
             }
         }
 
-        private bool IsAnonymousType(Type type)
-        {
-            // don't test for too many things in case implementation details change in the future
-            var typeInfo = type.GetTypeInfo();
-            return
-                typeInfo.GetCustomAttributes<CompilerGeneratedAttribute>(false).Any() &&
-                typeInfo.IsGenericType &&
-                type.Name.Contains("Anon"); // don't check for more than "Anon" so it works in mono also
-        }
-
         private void ThrowFrozenException()
         {
             var message = string.Format("Class map for {0} has been frozen and no further changes are allowed.", _classType.FullName);

src/MongoDB.Bson/Serialization/Serializers/ObjectSerializer.cs

@@ -567,20 +567,16 @@ private static class DefaultFrameworkAllowedTypes
 
             private static bool AllowedTypesImplementation(Type type)
             {
-                if (typeof(BsonValue).IsAssignableFrom(type))
-                {
-                    return true;
-                }
-
                 return type.IsConstructedGenericType ? IsAllowedGenericType(type) : IsAllowedType(type);
 
                 static bool IsAllowedType(Type type) =>
+                    typeof(BsonValue).IsAssignableFrom(type) ||
                     __allowedNonGenericTypesSet.Contains(type) ||
                     type.IsArray && AllowedTypesImplementation(type.GetElementType()) ||
                     type.IsEnum;
 
                 static bool IsAllowedGenericType(Type type) =>
-                    __allowedGenericTypesSet.Contains(type.GetGenericTypeDefinition()) &&
+                    (__allowedGenericTypesSet.Contains(type.GetGenericTypeDefinition()) || type.IsAnonymousType()) &&
                     type.GetGenericArguments().All(__allowedTypes);
             }
         }

src/MongoDB.Bson/Serialization/TypeExtensions.cs

@@ -0,0 +1,33 @@
+/* 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 System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+
+namespace MongoDB.Bson.Serialization
+{
+    internal static class TypeExtensions
+    {
+        public static bool IsAnonymousType(this Type type)
+        {
+            // don't test for too many things in case implementation details change in the future
+            return
+                type.GetCustomAttributes(false).Any(x => x is CompilerGeneratedAttribute) &&
+                type.IsGenericType &&
+                type.Name.Contains("Anon"); // don't check for more than "Anon" so it works in mono also
+        }
+    }
+}

tests/MongoDB.Bson.Tests/Serialization/Serializers/ObjectSerializerTests.cs

@@ -828,4 +828,18 @@ public void Serialize_guid_should_throw_when_guid_representation_is_unspecified_
 #pragma warning restore 618
         }
     }
+
+    public class DefaultAllowedTypesTests
+    {
+        [Fact]
+        public void DefaultAllowedTypes_with_anonymous_type_should_return_true()
+        {
+            var anonymousInstance = new { X = 1 };
+            var anonymousType = anonymousInstance.GetType();
+
+            var result = ObjectSerializer.DefaultAllowedTypes(anonymousType);
+
+            result.Should().BeTrue();
+        }
+    }
 }