Implemented CSHARP-460. Classes that implement collection interfaces are now serialized using either an EnumerableSerializer or a DictionarySerializer. Also added a KeyValuePairSerializer. Thanks to Alex Nagy for providing a prototype that a good bit of this is based on.

Author: rstam

Bson/Bson.csproj

@@ -112,6 +112,7 @@
     <Compile Include="Serialization\Options\DateTimeSerializationOptions.cs" />
     <Compile Include="Serialization\Options\DictionarySerializationOptions.cs" />
     <Compile Include="Serialization\Options\DocumentSerializationOptions.cs" />
+    <Compile Include="Serialization\Options\KeyValuePairSerializationOptions.cs" />
     <Compile Include="Serialization\Options\RepresentationSerializationOptions.cs" />
     <Compile Include="Exceptions\TruncationException.cs" />
     <Compile Include="IO\BsonDocumentReader.cs" />
@@ -145,6 +146,7 @@
     <Compile Include="Serialization\BsonSerializationInfo.cs" />
     <Compile Include="Serialization\Serializers\CollectionGenericSerializers.cs" />
     <Compile Include="Serialization\Serializers\CollectionSerializers.cs" />
+    <Compile Include="Serialization\Serializers\KeyValuePairSerializer.cs" />
     <Compile Include="Serialization\Serializers\DictionaryGenericSerializer.cs" />
     <Compile Include="Serialization\Serializers\DictionarySerializer.cs" />
     <Compile Include="Serialization\Serializers\ImageSerializers.cs" />

Bson/Serialization/BsonClassMapSerializer.cs

@@ -275,15 +275,6 @@ public bool GetDocumentId(
             }
         }
 
-        /// <summary>
-        /// Gets the serialization info for individual items of an enumerable type.
-        /// </summary>
-        /// <returns>The serialization info for the items.</returns>
-        public BsonSerializationInfo GetItemSerializationInfo()
-        {
-            throw new NotSupportedException("BsonClassMapSerializer does not implement the GetItemSerializationInfo method.");
-        }
-
         /// <summary>
         /// Gets the serialization info for a member.
         /// </summary>

Bson/Serialization/BsonDefaultSerializationProvider.cs

@@ -41,7 +41,6 @@ static BsonDefaultSerializationProvider()
         {
             __serializers = new Dictionary<Type, IBsonSerializer>
             {
-                { typeof(ArrayList), EnumerableSerializer.Instance },
                 { typeof(BitArray), BitArraySerializer.Instance },
                 { typeof(Bitmap), BitmapSerializer.Instance },
                 { typeof(Boolean), BooleanSerializer.Instance },
@@ -76,26 +75,18 @@ static BsonDefaultSerializationProvider()
                 { typeof(Double), DoubleSerializer.Instance },
                 { typeof(System.Drawing.Size), DrawingSizeSerializer.Instance },
                 { typeof(Guid), GuidSerializer.Instance },
-                { typeof(Hashtable), DictionarySerializer.Instance },
                 { typeof(IBsonSerializable), BsonIBsonSerializableSerializer.Instance },
-                { typeof(ICollection), EnumerableSerializer.Instance },
-                { typeof(IDictionary), DictionarySerializer.Instance },
-                { typeof(IEnumerable), EnumerableSerializer.Instance },
-                { typeof(IList), EnumerableSerializer.Instance },
                 { typeof(Image), ImageSerializer.Instance },
                 { typeof(Int16), Int16Serializer.Instance },
                 { typeof(Int32), Int32Serializer.Instance },
                 { typeof(Int64), Int64Serializer.Instance },
                 { typeof(IPAddress), IPAddressSerializer.Instance },
                 { typeof(IPEndPoint), IPEndPointSerializer.Instance },
-                { typeof(ListDictionary), DictionarySerializer.Instance },
                 { typeof(Object), ObjectSerializer.Instance },
                 { typeof(ObjectId), ObjectIdSerializer.Instance },
-                { typeof(OrderedDictionary), DictionarySerializer.Instance },
                 { typeof(Queue), QueueSerializer.Instance },
                 { typeof(SByte), SByteSerializer.Instance },
                 { typeof(Single), SingleSerializer.Instance },
-                { typeof(SortedList), DictionarySerializer.Instance },
                 { typeof(Stack), StackSerializer.Instance },
                 { typeof(String), StringSerializer.Instance },
                 { typeof(TimeSpan), TimeSpanSerializer.Instance },
@@ -108,20 +99,9 @@ static BsonDefaultSerializationProvider()
 
             __genericSerializerDefinitions = new Dictionary<Type, Type>
             {
-                { typeof(Collection<>), typeof(EnumerableSerializer<>)},
-                { typeof(Dictionary<,>), typeof(DictionarySerializer<,>) },
-                { typeof(HashSet<>), typeof(EnumerableSerializer<>) },
-                { typeof(ICollection<>), typeof(EnumerableSerializer<>) },
-                { typeof(IDictionary<,>), typeof(DictionarySerializer<,>) },
-                { typeof(IEnumerable<>), typeof(EnumerableSerializer<>) },
-                { typeof(IList<>), typeof(EnumerableSerializer<>) },
-                { typeof(LinkedList<>), typeof(EnumerableSerializer<>) },
-                { typeof(List<>), typeof(EnumerableSerializer<>) },
+                { typeof(KeyValuePair<,>), typeof(KeyValuePairSerializer<,>) },
                 { typeof(Nullable<>), typeof(NullableSerializer<>) },
-                { typeof(ObservableCollection<>), typeof(EnumerableSerializer<>)},
                 { typeof(Queue<>), typeof(QueueSerializer<>) },
-                { typeof(SortedDictionary<,>), typeof(DictionarySerializer<,>) },
-                { typeof(SortedList<,>), typeof(DictionarySerializer<,>) },
                 { typeof(Stack<>), typeof(StackSerializer<>) }
             };
         }
@@ -187,6 +167,82 @@ public IBsonSerializer GetSerializer(Type type)
                 return EnumSerializer.Instance;
             }
 
+            // classes that implement IDictionary or IEnumerable are serialized using either DictionarySerializer or EnumerableSerializer
+            // this does mean that any additional public properties the class might have won't be serialized (just like the XmlSerializer)
+            var collectionSerializer = GetCollectionSerializer(type);
+            if (collectionSerializer != null)
+            {
+                return collectionSerializer;
+            }
+
+            return null;
+        }
+
+        // private methods
+        private IBsonSerializer GetCollectionSerializer(Type type)
+        {
+            Type implementedGenericDictionaryInterface = null;
+            Type implementedGenericEnumerableInterface = null;
+            Type implementedDictionaryInterface = null;
+            Type implementedEnumerableInterface = null;
+
+            var implementedInterfaces = new List<Type>(type.GetInterfaces());
+            if (type.IsInterface)
+            {
+                implementedInterfaces.Add(type);
+            }
+            foreach (var implementedInterface in implementedInterfaces)
+            {
+                if (implementedInterface.IsGenericType)
+                {
+                    var genericInterfaceDefinition = implementedInterface.GetGenericTypeDefinition();
+                    if (genericInterfaceDefinition == typeof(IDictionary<,>))
+                    {
+                        implementedGenericDictionaryInterface = implementedInterface;
+                    }
+                    if (genericInterfaceDefinition == typeof(IEnumerable<>))
+                    {
+                        implementedGenericEnumerableInterface = implementedInterface;
+                    }
+                }
+                else
+                {
+                    if (implementedInterface == typeof(IDictionary))
+                    {
+                        implementedDictionaryInterface = implementedInterface;
+                    }
+                    if (implementedInterface == typeof(IEnumerable))
+                    {
+                        implementedEnumerableInterface = implementedInterface;
+                    }
+                }
+            }
+
+            // the order of the tests is important
+            if (implementedGenericDictionaryInterface != null)
+            {
+                var keyType = implementedGenericDictionaryInterface.GetGenericArguments()[0];
+                var valueType = implementedGenericDictionaryInterface.GetGenericArguments()[1];
+                var genericSerializerDefinition = typeof(DictionarySerializer<,>);
+                var genericSerializerType = genericSerializerDefinition.MakeGenericType(keyType, valueType);
+                return (IBsonSerializer)Activator.CreateInstance(genericSerializerType);
+            }
+            else if (implementedDictionaryInterface != null)
+            {
+                return DictionarySerializer.Instance;
+            }
+            else if (implementedGenericEnumerableInterface != null)
+            {
+                var valueType = implementedGenericEnumerableInterface.GetGenericArguments()[0];
+                var genericSerializerDefinition = typeof(EnumerableSerializer<>);
+                var genericSerializerType = genericSerializerDefinition.MakeGenericType(valueType);
+                return (IBsonSerializer)Activator.CreateInstance(genericSerializerType);
+            }
+            else if (implementedEnumerableInterface != null)
+            {
+                return EnumerableSerializer.Instance;
+            }
+
             return null;
         }
     }

Bson/Serialization/Options/DictionarySerializationOptions.cs

@@ -58,7 +58,7 @@ public class DictionarySerializationOptions : BsonBaseSerializationOptions
 
         // private fields
         private DictionaryRepresentation _representation = DictionaryRepresentation.Dynamic;
-        private IBsonSerializationOptions _itemSerializationOptions;
+        private IBsonSerializationOptions _valueSerializationOptions;
 
         // constructors
         /// <summary>
@@ -81,11 +81,11 @@ public DictionarySerializationOptions(DictionaryRepresentation representation)
         /// Initializes a new instance of the DictionarySerializationOptions class.
         /// </summary>
         /// <param name="representation">The representation to use for a Dictionary.</param>
-        /// <param name="itemSerializationOptions">The serialization options for the items in the dictionary.</param>
-        public DictionarySerializationOptions(DictionaryRepresentation representation, IBsonSerializationOptions itemSerializationOptions)
+        /// <param name="valueSerializationOptions">The serialization options for the values in the dictionary.</param>
+        public DictionarySerializationOptions(DictionaryRepresentation representation, IBsonSerializationOptions valueSerializationOptions)
         {
             _representation = representation;
-            _itemSerializationOptions = itemSerializationOptions;
+            _valueSerializationOptions = valueSerializationOptions;
         }
 
         // public static properties
@@ -131,6 +131,16 @@ public static DictionarySerializationOptions Dynamic
         }
 
         // public properties
+        /// <summary>
+        /// Gets or sets the serialization options for the values in the dictionary.
+        /// </summary>
+        [Obsolete("Use ValueSerializationOptions instead.")]
+        public IBsonSerializationOptions ItemSerializationOptions
+        {
+            get { return ValueSerializationOptions; }
+            set { ValueSerializationOptions = value; }
+        }
+
         /// <summary>
         /// Gets the representation to use for a Dictionary.
         /// </summary>
@@ -145,15 +155,15 @@ public DictionaryRepresentation Representation
         }
 
         /// <summary>
-        /// Gets or sets the serialization options for the items in the dictionary.
+        /// Gets or sets the serialization options for the values in the dictionary.
         /// </summary>
-        public IBsonSerializationOptions ItemSerializationOptions
+        public IBsonSerializationOptions ValueSerializationOptions
         {
-            get { return _itemSerializationOptions; }
+            get { return _valueSerializationOptions; }
             set
             {
                 EnsureNotFrozen();
-                _itemSerializationOptions = value;
+                _valueSerializationOptions = value;
             }
         }
 
@@ -173,7 +183,7 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib
                 return;
             }
 
-            // for backward compatibility reasons representations Array and Document apply to the Dictionary and not the items
+            // for backward compatibility reasons representations Array and Document apply to the Dictionary and not the values
             var representationAttribute = attribute as BsonRepresentationAttribute;
             if (representationAttribute != null)
             {
@@ -188,43 +198,39 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib
                 }
             }
 
-            var itemSerializationInfoProvider = serializer as IBsonItemSerializationInfoProvider;
-            if (itemSerializationInfoProvider == null)
+            var valueType = typeof(object);
+            if (serializer.GetType().IsGenericType)
             {
-                var message = string.Format(
-                        "A serialization options attribute of type {0} cannot be used when the serializer is of type {1}.",
-                        BsonUtils.GetFriendlyTypeName(attribute.GetType()),
-                        BsonUtils.GetFriendlyTypeName(serializer.GetType()));
-                throw new NotSupportedException(message);
+                valueType = serializer.GetType().GetGenericArguments()[1];
             }
+            var valueSerializer = BsonSerializer.LookupSerializer(valueType);
 
-            var itemSerializer = itemSerializationInfoProvider.GetItemSerializationInfo().Serializer;
-            if (_itemSerializationOptions == null)
+            if (_valueSerializationOptions == null)
             {
-                var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();
+                var valueDefaultSerializationOptions = valueSerializer.GetDefaultSerializationOptions();
 
                 // special case for legacy dictionaries: allow BsonRepresentation on object
-                if (itemDefaultSerializationOptions == null && 
+                if (valueDefaultSerializationOptions == null && 
                     serializer.GetType() == typeof(DictionarySerializer) && 
                     attribute.GetType() == typeof(BsonRepresentationAttribute))
                 {
-                    itemDefaultSerializationOptions = new RepresentationSerializationOptions(BsonType.Null); // will be modified later by ApplyAttribute
+                    valueDefaultSerializationOptions = new RepresentationSerializationOptions(BsonType.Null); // will be modified later by ApplyAttribute
                 }
 
-                if (itemDefaultSerializationOptions == null)
+                if (valueDefaultSerializationOptions == null)
                 {
                     var message = string.Format(
-                        "A serialization options attribute of type {0} cannot be used when the serializer is of type {1} and the item serializer is of type {2}.",
+                        "A serialization options attribute of type {0} cannot be used when the serializer is of type {1} and the value serializer is of type {2}.",
                         BsonUtils.GetFriendlyTypeName(attribute.GetType()),
                         BsonUtils.GetFriendlyTypeName(serializer.GetType()),
-                        BsonUtils.GetFriendlyTypeName(itemSerializer.GetType()));
+                        BsonUtils.GetFriendlyTypeName(valueSerializer.GetType()));
                     throw new NotSupportedException(message);
                 }
 
-                _itemSerializationOptions = itemDefaultSerializationOptions.Clone();
+                _valueSerializationOptions = valueDefaultSerializationOptions.Clone();
             }
 
-            _itemSerializationOptions.ApplyAttribute(itemSerializer, attribute);
+            _valueSerializationOptions.ApplyAttribute(valueSerializer, attribute);
         }
 
         /// <summary>
@@ -233,7 +239,7 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib
         /// <returns>A cloned copy of the serialization options.</returns>
         public override IBsonSerializationOptions Clone()
         {
-            return new DictionarySerializationOptions(_representation, _itemSerializationOptions);
+            return new DictionarySerializationOptions(_representation, _valueSerializationOptions);
         }
 
         /// <summary>
@@ -244,9 +250,9 @@ public override IBsonSerializationOptions Freeze()
         {
             if (!IsFrozen)
             {
-                if (_itemSerializationOptions != null)
+                if (_valueSerializationOptions != null)
                 {
-                    _itemSerializationOptions.Freeze();
+                    _valueSerializationOptions.Freeze();
                 }
             }
             return base.Freeze();