Merged refactoring that split IBsonSerializer into 4 interfaces (with some minor changes to comments and coding style).

rstam · rstam · commit 2a6e37dd9316 · 2012-05-01T16:01:30.000-04:00
diff --git a/Bson/Serialization/IBsonIdProvider.cs b/Bson/Serialization/IBsonIdProvider.cs
@@ -1,12 +1,27 @@
-﻿using System;
+﻿/* Copyright 2010-2012 10gen 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.Collections.Generic;
 using System.Linq;
 using System.Text;
 
 namespace MongoDB.Bson.Serialization
 {
     /// <summary>
-    /// Contract for serializers that can get and set identities.
+    /// Contract for serializers that can get and set Id values.
     /// </summary>
     public interface IBsonIdProvider
     {
diff --git a/Bson/Serialization/IBsonItemSerializationInfoProvider.cs b/Bson/Serialization/IBsonItemSerializationInfoProvider.cs
@@ -1,4 +1,19 @@
-﻿using System;
+﻿/* Copyright 2010-2012 10gen 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.Collections.Generic;
 using System.Linq;
 using System.Text;
diff --git a/Bson/Serialization/IBsonMemberSerializationInfoProvider.cs b/Bson/Serialization/IBsonMemberSerializationInfoProvider.cs
@@ -1,4 +1,19 @@
-﻿using System;
+﻿/* Copyright 2010-2012 10gen 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.Collections.Generic;
 using System.Linq;
 using System.Text;
diff --git a/Bson/Serialization/Options/ArraySerializationOptions.cs b/Bson/Serialization/Options/ArraySerializationOptions.cs
@@ -71,8 +71,8 @@ public IBsonSerializationOptions ItemSerializationOptions
         public override void ApplyAttribute(IBsonSerializer serializer, Attribute attribute)
         {
             EnsureNotFrozen();
-            var itemSerializationProvider = serializer as IBsonItemSerializationInfoProvider;
-            if (itemSerializationProvider == null)
+            var itemSerializationInfoProvider = serializer as IBsonItemSerializationInfoProvider;
+            if (itemSerializationInfoProvider == null)
             {
                 var message = string.Format(
                         "A serialization options attribute of type {0} cannot be used when the serializer is of type {1}.",
@@ -81,7 +81,7 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib
                 throw new NotSupportedException(message);
             }
 
-            var itemSerializer = itemSerializationProvider.GetItemSerializationInfo().Serializer;
+            var itemSerializer = itemSerializationInfoProvider.GetItemSerializationInfo().Serializer;
             if (_itemSerializationOptions == null)
             {
                 var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();
diff --git a/Bson/Serialization/Options/DictionarySerializationOptions.cs b/Bson/Serialization/Options/DictionarySerializationOptions.cs
@@ -188,8 +188,8 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib
                 }
             }
 
-            var itemSerializationProvider = serializer as IBsonItemSerializationInfoProvider;
-            if (itemSerializationProvider == null)
+            var itemSerializationInfoProvider = serializer as IBsonItemSerializationInfoProvider;
+            if (itemSerializationInfoProvider == null)
             {
                 var message = string.Format(
                         "A serialization options attribute of type {0} cannot be used when the serializer is of type {1}.",
@@ -198,7 +198,7 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib
                 throw new NotSupportedException(message);
             }
 
-            var itemSerializer = itemSerializationProvider.GetItemSerializationInfo().Serializer;
+            var itemSerializer = itemSerializationInfoProvider.GetItemSerializationInfo().Serializer;
             if (_itemSerializationOptions == null)
             {
                 var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();
diff --git a/BsonUnitTests/Jira/CSharp81Tests.cs b/BsonUnitTests/Jira/CSharp81Tests.cs
@@ -52,9 +52,9 @@ public void TestIdMember()
             var idMemberMap = classMap.IdMemberMap;
             Assert.AreEqual("Id", idMemberMap.MemberName);
 
-            var identityProvider = BsonSerializer.LookupSerializer(typeof(User)) as IBsonIdProvider;
+            var idProvider = BsonSerializer.LookupSerializer(typeof(User)) as IBsonIdProvider;
             var idGenerator = BsonSerializer.LookupIdGenerator(typeof(ObjectId));
-            identityProvider.SetDocumentId(u, idGenerator.GenerateId(null, u));
+            idProvider.SetDocumentId(u, idGenerator.GenerateId(null, u));
             Assert.IsFalse(idGenerator.IsEmpty(u.Id));
             Assert.IsTrue(idGenerator.IsEmpty(u.FriendId));
 
diff --git a/Driver/Core/MongoCollection.cs b/Driver/Core/MongoCollection.cs
@@ -1079,18 +1079,18 @@ public virtual IEnumerable<SafeModeResult> InsertBatch(
                         if (_settings.AssignIdOnInsert)
                         {
                             var serializer = BsonSerializer.LookupSerializer(document.GetType());
-                            var identityProvider = serializer as IBsonIdProvider;
-                            if (identityProvider != null)
+                            var idProvider = serializer as IBsonIdProvider;
+                            if (idProvider != null)
                             {
                                 object id;
                                 Type idNominalType;
                                 IIdGenerator idGenerator;
-                                if (identityProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))
+                                if (idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))
                                 {
                                     if (idGenerator != null && idGenerator.IsEmpty(id))
                                     {
                                         id = idGenerator.GenerateId(this, document);
-                                        identityProvider.SetDocumentId(document, id);
+                                        idProvider.SetDocumentId(document, id);
                                     }
                                 }
                             }
@@ -1356,11 +1356,11 @@ public virtual SafeModeResult Save(Type nominalType, object document, MongoInser
                 throw new ArgumentNullException("document");
             }
             var serializer = BsonSerializer.LookupSerializer(document.GetType());
-            var identityProvider = serializer as IBsonIdProvider;
+            var idProvider = serializer as IBsonIdProvider;
             object id;
             Type idNominalType;
             IIdGenerator idGenerator;
-            if (identityProvider != null && identityProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))
+            if (idProvider != null && idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))
             {
                 if (id == null && idGenerator == null)
                 {
@@ -1370,7 +1370,7 @@ public virtual SafeModeResult Save(Type nominalType, object document, MongoInser
                 if (idGenerator != null && idGenerator.IsEmpty(id))
                 {
                     id = idGenerator.GenerateId(this, document);
-                    identityProvider.SetDocumentId(document, id);
+                    idProvider.SetDocumentId(document, id);
                     return Insert(nominalType, document, options);
                 }
                 else
diff --git a/Driver/Linq/Translators/SelectQuery.cs b/Driver/Linq/Translators/SelectQuery.cs
@@ -467,16 +467,16 @@ private IMongoQuery BuildContainsAllQuery(MethodCallExpression methodCallExpress
                     var valuesExpression = arguments[1] as ConstantExpression;
                     if (serializationInfo != null && valuesExpression != null)
                     {
-                        var itemSerializationProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
-                        if (itemSerializationProvider == null)
+                        var itemSerializationInfoProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
+                        if (itemSerializationInfoProvider == null)
                         {
                             var message = string.Format(
                                 "ContainsAll cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",
                                 BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),
                                 BsonUtils.GetFriendlyTypeName(serializationInfo.Serializer.GetType()));
                             throw new NotSupportedException(message);
                         }
-                        var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();
+                        var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();
                         var serializedValues = SerializeValues(itemSerializationInfo, (IEnumerable)valuesExpression.Value);
                         return Query.All(serializationInfo.ElementName, serializedValues);
                     }
@@ -496,16 +496,16 @@ private IMongoQuery BuildContainsAnyQuery(MethodCallExpression methodCallExpress
                     var valuesExpression = arguments[1] as ConstantExpression;
                     if (serializationInfo != null && valuesExpression != null)
                     {
-                        var itemSerializationProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
-                        if (itemSerializationProvider == null)
+                        var itemSerializationInfoProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
+                        if (itemSerializationInfoProvider == null)
                         {
                             var message = string.Format(
                                 "ContainsAny cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",
                                 BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),
                                 BsonUtils.GetFriendlyTypeName(serializationInfo.Serializer.GetType()));
                             throw new NotSupportedException(message);
                         }
-                        var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();
+                        var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();
                         var serializedValues = SerializeValues(itemSerializationInfo, (IEnumerable)valuesExpression.Value);
                         return Query.In(serializationInfo.ElementName, serializedValues);
                     }
@@ -543,16 +543,16 @@ private IMongoQuery BuildContainsQuery(MethodCallExpression methodCallExpression
 
             if (serializationInfo != null && valueExpression != null)
             {
-                var itemSerializationProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
-                if (itemSerializationProvider == null)
+                var itemSerializationInfoProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
+                if (itemSerializationInfoProvider == null)
                 {
                     var message = string.Format(
                         "Contains cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",
                         BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),
                         BsonUtils.GetFriendlyTypeName(serializationInfo.Serializer.GetType()));
                     throw new NotSupportedException(message);
                 }
-                var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();
+                var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();
                 var serializedValue = SerializeValue(itemSerializationInfo, valueExpression.Value);
                 return Query.EQ(serializationInfo.ElementName, serializedValue);
             }
@@ -1507,16 +1507,16 @@ private BsonSerializationInfo GetSerializationInfoArrayIndex(IBsonSerializer ser
             var arraySerializationInfo = GetSerializationInfo(serializer, binaryExpression.Left);
             if (arraySerializationInfo != null)
             {
-                var itemSerializationProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;
-                if (itemSerializationProvider == null)
+                var itemSerializationInfoProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;
+                if (itemSerializationInfoProvider == null)
                 {
                     var message = string.Format(
                         "Queries using an array index cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",
                         BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),
                         BsonUtils.GetFriendlyTypeName(arraySerializationInfo.Serializer.GetType()));
                     throw new NotSupportedException(message);
                 }
-                var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();
+                var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();
                 var indexEpression = binaryExpression.Right as ConstantExpression;
                 if (indexEpression != null)
                 {
@@ -1539,16 +1539,18 @@ private BsonSerializationInfo GetSerializationInfoGetItem(IBsonSerializer serial
             {
                 var indexEpression = arguments[0] as ConstantExpression;
                 if (indexEpression == null)
+                {
                     return null;
+                }
+                var index = Convert.ToInt32(indexEpression.Value);
 
                 var arraySerializationInfo = GetSerializationInfo(serializer, methodCallExpression.Object);
                 if (arraySerializationInfo != null)
                 {
-                    var itemSerializationProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;
-                    if (itemSerializationProvider != null)
+                    var itemSerializationInfoProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;
+                    if (itemSerializationInfoProvider != null)
                     {
-                        var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();
-                        var index = Convert.ToInt32(indexEpression.Value);
+                        var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();
                         return new BsonSerializationInfo(
                             arraySerializationInfo.ElementName + "." + index.ToString(),
                             itemSerializationInfo.Serializer,
@@ -1569,10 +1571,10 @@ private BsonSerializationInfo GetSerializationInfoMember(IBsonSerializer seriali
             var containingExpression = memberExpression.Expression;
             if (containingExpression.NodeType == ExpressionType.Parameter)
             {
-                var memberInfoProvider = serializer as IBsonMemberSerializationInfoProvider;
-                if(memberInfoProvider != null)
+                var memberSerializationInfoProvider = serializer as IBsonMemberSerializationInfoProvider;
+                if (memberSerializationInfoProvider != null)
                 {
-                    return memberInfoProvider.GetMemberSerializationInfo(memberName);
+                    return memberSerializationInfoProvider.GetMemberSerializationInfo(memberName);
                 }
                 else
                 {
@@ -1583,10 +1585,10 @@ private BsonSerializationInfo GetSerializationInfoMember(IBsonSerializer seriali
             else
             {
                 var containingSerializationInfo = GetSerializationInfo(serializer, containingExpression);
-                var memberInfoProvider = containingSerializationInfo.Serializer as IBsonMemberSerializationInfoProvider;
-                if(memberInfoProvider != null)
+                var memberSerializationInfoProvider = containingSerializationInfo.Serializer as IBsonMemberSerializationInfoProvider;
+                if (memberSerializationInfoProvider != null)
                 {
-                    var memberSerializationInfo = memberInfoProvider.GetMemberSerializationInfo(memberName);
+                    var memberSerializationInfo = memberSerializationInfoProvider.GetMemberSerializationInfo(memberName);
                     return new BsonSerializationInfo(
                         containingSerializationInfo.ElementName + "." + memberSerializationInfo.ElementName,
                         memberSerializationInfo.Serializer,

Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,8 @@ public IBsonSerializationOptions ItemSerializationOptions`
`71`	`71`	`public override void ApplyAttribute(IBsonSerializer serializer, Attribute attribute)`
`72`	`72`	`{`
`73`	`73`	`EnsureNotFrozen();`
`74`		`- var itemSerializationProvider = serializer as IBsonItemSerializationInfoProvider;`
`75`		`- if (itemSerializationProvider == null)`
	`74`	`+ var itemSerializationInfoProvider = serializer as IBsonItemSerializationInfoProvider;`
	`75`	`+ if (itemSerializationInfoProvider == null)`
`76`	`76`	`{`
`77`	`77`	`var message = string.Format(`
`78`	`78`	`"A serialization options attribute of type {0} cannot be used when the serializer is of type {1}.",`
`@@ -81,7 +81,7 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib`
`81`	`81`	`throw new NotSupportedException(message);`
`82`	`82`	`}`
`83`	`83`
`84`		`- var itemSerializer = itemSerializationProvider.GetItemSerializationInfo().Serializer;`
	`84`	`+ var itemSerializer = itemSerializationInfoProvider.GetItemSerializationInfo().Serializer;`
`85`	`85`	`if (_itemSerializationOptions == null)`
`86`	`86`	`{`
`87`	`87`	`var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();`
Original file line number	Diff line number	Diff line change
`@@ -188,8 +188,8 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`191`		`- var itemSerializationProvider = serializer as IBsonItemSerializationInfoProvider;`
`192`		`- if (itemSerializationProvider == null)`
	`191`	`+ var itemSerializationInfoProvider = serializer as IBsonItemSerializationInfoProvider;`
	`192`	`+ if (itemSerializationInfoProvider == null)`
`193`	`193`	`{`
`194`	`194`	`var message = string.Format(`
`195`	`195`	`"A serialization options attribute of type {0} cannot be used when the serializer is of type {1}.",`
`@@ -198,7 +198,7 @@ public override void ApplyAttribute(IBsonSerializer serializer, Attribute attrib`
`198`	`198`	`throw new NotSupportedException(message);`
`199`	`199`	`}`
`200`	`200`
`201`		`- var itemSerializer = itemSerializationProvider.GetItemSerializationInfo().Serializer;`
	`201`	`+ var itemSerializer = itemSerializationInfoProvider.GetItemSerializationInfo().Serializer;`
`202`	`202`	`if (_itemSerializationOptions == null)`
`203`	`203`	`{`
`204`	`204`	`var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();`
Original file line number	Diff line number	Diff line change
`@@ -1079,18 +1079,18 @@ public virtual IEnumerable<SafeModeResult> InsertBatch(`
`1079`	`1079`	`if (_settings.AssignIdOnInsert)`
`1080`	`1080`	`{`
`1081`	`1081`	`var serializer = BsonSerializer.LookupSerializer(document.GetType());`
`1082`		`- var identityProvider = serializer as IBsonIdProvider;`
`1083`		`- if (identityProvider != null)`
	`1082`	`+ var idProvider = serializer as IBsonIdProvider;`
	`1083`	`+ if (idProvider != null)`
`1084`	`1084`	`{`
`1085`	`1085`	`object id;`
`1086`	`1086`	`Type idNominalType;`
`1087`	`1087`	`IIdGenerator idGenerator;`
`1088`		`- if (identityProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))`
	`1088`	`+ if (idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))`
`1089`	`1089`	`{`
`1090`	`1090`	`if (idGenerator != null && idGenerator.IsEmpty(id))`
`1091`	`1091`	`{`
`1092`	`1092`	`id = idGenerator.GenerateId(this, document);`
`1093`		`- identityProvider.SetDocumentId(document, id);`
	`1093`	`+ idProvider.SetDocumentId(document, id);`
`1094`	`1094`	`}`
`1095`	`1095`	`}`
`1096`	`1096`	`}`
`@@ -1356,11 +1356,11 @@ public virtual SafeModeResult Save(Type nominalType, object document, MongoInser`
`1356`	`1356`	`throw new ArgumentNullException("document");`
`1357`	`1357`	`}`
`1358`	`1358`	`var serializer = BsonSerializer.LookupSerializer(document.GetType());`
`1359`		`- var identityProvider = serializer as IBsonIdProvider;`
	`1359`	`+ var idProvider = serializer as IBsonIdProvider;`
`1360`	`1360`	`object id;`
`1361`	`1361`	`Type idNominalType;`
`1362`	`1362`	`IIdGenerator idGenerator;`
`1363`		`- if (identityProvider != null && identityProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))`
	`1363`	`+ if (idProvider != null && idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))`
`1364`	`1364`	`{`
`1365`	`1365`	`if (id == null && idGenerator == null)`
`1366`	`1366`	`{`
`@@ -1370,7 +1370,7 @@ public virtual SafeModeResult Save(Type nominalType, object document, MongoInser`
`1370`	`1370`	`if (idGenerator != null && idGenerator.IsEmpty(id))`
`1371`	`1371`	`{`
`1372`	`1372`	`id = idGenerator.GenerateId(this, document);`
`1373`		`- identityProvider.SetDocumentId(document, id);`
	`1373`	`+ idProvider.SetDocumentId(document, id);`
`1374`	`1374`	`return Insert(nominalType, document, options);`
`1375`	`1375`	`}`
`1376`	`1376`	`else`
Original file line number	Diff line number	Diff line change
`@@ -467,16 +467,16 @@ private IMongoQuery BuildContainsAllQuery(MethodCallExpression methodCallExpress`
`467`	`467`	`var valuesExpression = arguments[1] as ConstantExpression;`
`468`	`468`	`if (serializationInfo != null && valuesExpression != null)`
`469`	`469`	`{`
`470`		`- var itemSerializationProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
`471`		`- if (itemSerializationProvider == null)`
	`470`	`+ var itemSerializationInfoProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
	`471`	`+ if (itemSerializationInfoProvider == null)`
`472`	`472`	`{`
`473`	`473`	`var message = string.Format(`
`474`	`474`	`"ContainsAll cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",`
`475`	`475`	`BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),`
`476`	`476`	`BsonUtils.GetFriendlyTypeName(serializationInfo.Serializer.GetType()));`
`477`	`477`	`throw new NotSupportedException(message);`
`478`	`478`	`}`
`479`		`- var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();`
	`479`	`+ var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();`
`480`	`480`	`var serializedValues = SerializeValues(itemSerializationInfo, (IEnumerable)valuesExpression.Value);`
`481`	`481`	`return Query.All(serializationInfo.ElementName, serializedValues);`
`482`	`482`	`}`
`@@ -496,16 +496,16 @@ private IMongoQuery BuildContainsAnyQuery(MethodCallExpression methodCallExpress`
`496`	`496`	`var valuesExpression = arguments[1] as ConstantExpression;`
`497`	`497`	`if (serializationInfo != null && valuesExpression != null)`
`498`	`498`	`{`
`499`		`- var itemSerializationProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
`500`		`- if (itemSerializationProvider == null)`
	`499`	`+ var itemSerializationInfoProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
	`500`	`+ if (itemSerializationInfoProvider == null)`
`501`	`501`	`{`
`502`	`502`	`var message = string.Format(`
`503`	`503`	`"ContainsAny cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",`
`504`	`504`	`BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),`
`505`	`505`	`BsonUtils.GetFriendlyTypeName(serializationInfo.Serializer.GetType()));`
`506`	`506`	`throw new NotSupportedException(message);`
`507`	`507`	`}`
`508`		`- var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();`
	`508`	`+ var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();`
`509`	`509`	`var serializedValues = SerializeValues(itemSerializationInfo, (IEnumerable)valuesExpression.Value);`
`510`	`510`	`return Query.In(serializationInfo.ElementName, serializedValues);`
`511`	`511`	`}`
`@@ -543,16 +543,16 @@ private IMongoQuery BuildContainsQuery(MethodCallExpression methodCallExpression`
`543`	`543`
`544`	`544`	`if (serializationInfo != null && valueExpression != null)`
`545`	`545`	`{`
`546`		`- var itemSerializationProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
`547`		`- if (itemSerializationProvider == null)`
	`546`	`+ var itemSerializationInfoProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
	`547`	`+ if (itemSerializationInfoProvider == null)`
`548`	`548`	`{`
`549`	`549`	`var message = string.Format(`
`550`	`550`	`"Contains cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",`
`551`	`551`	`BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),`
`552`	`552`	`BsonUtils.GetFriendlyTypeName(serializationInfo.Serializer.GetType()));`
`553`	`553`	`throw new NotSupportedException(message);`
`554`	`554`	`}`
`555`		`- var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();`
	`555`	`+ var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();`
`556`	`556`	`var serializedValue = SerializeValue(itemSerializationInfo, valueExpression.Value);`
`557`	`557`	`return Query.EQ(serializationInfo.ElementName, serializedValue);`
`558`	`558`	`}`
`@@ -1507,16 +1507,16 @@ private BsonSerializationInfo GetSerializationInfoArrayIndex(IBsonSerializer ser`
`1507`	`1507`	`var arraySerializationInfo = GetSerializationInfo(serializer, binaryExpression.Left);`
`1508`	`1508`	`if (arraySerializationInfo != null)`
`1509`	`1509`	`{`
`1510`		`- var itemSerializationProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
`1511`		`- if (itemSerializationProvider == null)`
	`1510`	`+ var itemSerializationInfoProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
	`1511`	`+ if (itemSerializationInfoProvider == null)`
`1512`	`1512`	`{`
`1513`	`1513`	`var message = string.Format(`
`1514`	`1514`	`"Queries using an array index cannot be run against a member whose serializer does not implement {0}. The current serializer is {1}.",`
`1515`	`1515`	`BsonUtils.GetFriendlyTypeName(typeof(IBsonItemSerializationInfoProvider)),`
`1516`	`1516`	`BsonUtils.GetFriendlyTypeName(arraySerializationInfo.Serializer.GetType()));`
`1517`	`1517`	`throw new NotSupportedException(message);`
`1518`	`1518`	`}`
`1519`		`- var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();`
	`1519`	`+ var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();`
`1520`	`1520`	`var indexEpression = binaryExpression.Right as ConstantExpression;`
`1521`	`1521`	`if (indexEpression != null)`
`1522`	`1522`	`{`
`@@ -1539,16 +1539,18 @@ private BsonSerializationInfo GetSerializationInfoGetItem(IBsonSerializer serial`
`1539`	`1539`	`{`
`1540`	`1540`	`var indexEpression = arguments[0] as ConstantExpression;`
`1541`	`1541`	`if (indexEpression == null)`
	`1542`	`+ {`
`1542`	`1543`	`return null;`
	`1544`	`+ }`
	`1545`	`+ var index = Convert.ToInt32(indexEpression.Value);`
`1543`	`1546`
`1544`	`1547`	`var arraySerializationInfo = GetSerializationInfo(serializer, methodCallExpression.Object);`
`1545`	`1548`	`if (arraySerializationInfo != null)`
`1546`	`1549`	`{`
`1547`		`- var itemSerializationProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
`1548`		`- if (itemSerializationProvider != null)`
	`1550`	`+ var itemSerializationInfoProvider = arraySerializationInfo.Serializer as IBsonItemSerializationInfoProvider;`
	`1551`	`+ if (itemSerializationInfoProvider != null)`
`1549`	`1552`	`{`
`1550`		`- var itemSerializationInfo = itemSerializationProvider.GetItemSerializationInfo();`
`1551`		`- var index = Convert.ToInt32(indexEpression.Value);`
	`1553`	`+ var itemSerializationInfo = itemSerializationInfoProvider.GetItemSerializationInfo();`
`1552`	`1554`	`return new BsonSerializationInfo(`
`1553`	`1555`	`arraySerializationInfo.ElementName + "." + index.ToString(),`
`1554`	`1556`	`itemSerializationInfo.Serializer,`
`@@ -1569,10 +1571,10 @@ private BsonSerializationInfo GetSerializationInfoMember(IBsonSerializer seriali`
`1569`	`1571`	`var containingExpression = memberExpression.Expression;`
`1570`	`1572`	`if (containingExpression.NodeType == ExpressionType.Parameter)`
`1571`	`1573`	`{`
`1572`		`- var memberInfoProvider = serializer as IBsonMemberSerializationInfoProvider;`
`1573`		`- if(memberInfoProvider != null)`
	`1574`	`+ var memberSerializationInfoProvider = serializer as IBsonMemberSerializationInfoProvider;`
	`1575`	`+ if (memberSerializationInfoProvider != null)`
`1574`	`1576`	`{`
`1575`		`- return memberInfoProvider.GetMemberSerializationInfo(memberName);`
	`1577`	`+ return memberSerializationInfoProvider.GetMemberSerializationInfo(memberName);`
`1576`	`1578`	`}`
`1577`	`1579`	`else`
`1578`	`1580`	`{`
`@@ -1583,10 +1585,10 @@ private BsonSerializationInfo GetSerializationInfoMember(IBsonSerializer seriali`
`1583`	`1585`	`else`
`1584`	`1586`	`{`
`1585`	`1587`	`var containingSerializationInfo = GetSerializationInfo(serializer, containingExpression);`
`1586`		`- var memberInfoProvider = containingSerializationInfo.Serializer as IBsonMemberSerializationInfoProvider;`
`1587`		`- if(memberInfoProvider != null)`
	`1588`	`+ var memberSerializationInfoProvider = containingSerializationInfo.Serializer as IBsonMemberSerializationInfoProvider;`
	`1589`	`+ if (memberSerializationInfoProvider != null)`
`1588`	`1590`	`{`
`1589`		`- var memberSerializationInfo = memberInfoProvider.GetMemberSerializationInfo(memberName);`
	`1591`	`+ var memberSerializationInfo = memberSerializationInfoProvider.GetMemberSerializationInfo(memberName);`
`1590`	`1592`	`return new BsonSerializationInfo(`
`1591`	`1593`	`containingSerializationInfo.ElementName + "." + memberSerializationInfo.ElementName,`
`1592`	`1594`	`memberSerializationInfo.Serializer,`