Finished comments in the Bson lib

papafe · papafe · commit 0ae768c2a92a · 2025-01-27T09:54:10.000+01:00
diff --git a/src/MongoDB.Bson/BsonDefaults.cs b/src/MongoDB.Bson/BsonDefaults.cs
@@ -42,7 +42,7 @@ public static IBsonSerializer DynamicArraySerializer
             {
                 if (!__dynamicArraySerializerWasSet)
                 {
-                    __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>();  //TODO I think we could keep this as is
+                    __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>();  //TODO ??
                 }
                 return __dynamicArraySerializer;
             }
@@ -62,7 +62,7 @@ public static IBsonSerializer DynamicDocumentSerializer
             {
                 if (!__dynamicDocumentSerializerWasSet)
                 {
-                    __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>();   //TODO I think we could keep this as is
+                    __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>();   //TODO ??
                 }
                 return __dynamicDocumentSerializer;
             }
diff --git a/src/MongoDB.Bson/BsonExtensionMethods.cs b/src/MongoDB.Bson/BsonExtensionMethods.cs
@@ -84,7 +84,7 @@ public static byte[] ToBson(
 
             if (serializer == null)
             {
-                serializer = BsonSerializer.LookupSerializer(nominalType);   //TODO I think we need another method with the domain as input
+                serializer = BsonSerializer.LookupSerializer(nominalType);   //TODO ??
             }
             if (serializer.ValueType != nominalType)
             {
@@ -165,7 +165,7 @@ public static BsonDocument ToBsonDocument(
                     return convertibleToBsonDocument.ToBsonDocument(); // use the provided ToBsonDocument method
                 }
 
-                serializer = BsonSerializer.LookupSerializer(nominalType);    //TODO I think we need another method with the domain as input
+                serializer = BsonSerializer.LookupSerializer(nominalType);  //TODO ??
             }
             if (serializer.ValueType != nominalType)
             {
@@ -236,7 +236,7 @@ public static string ToJson(
 
             if (serializer == null)
             {
-                serializer = BsonSerializer.LookupSerializer(nominalType);    //TODO I think we need another method with the domain as input
+                serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??
             }
             if (serializer.ValueType != nominalType)
             {
diff --git a/src/MongoDB.Bson/ObjectModel/BsonDocumentWrapper.cs b/src/MongoDB.Bson/ObjectModel/BsonDocumentWrapper.cs
@@ -104,7 +104,7 @@ public static BsonDocumentWrapper Create<TNominalType>(TNominalType value)
         /// <returns>A BsonDocumentWrapper.</returns>
         public static BsonDocumentWrapper Create(Type nominalType, object value)
         {
-            var serializer = BsonSerializer.LookupSerializer(nominalType);  //TODO I think this could stay. We can potentially add methods with the domain as input.
+            var serializer = BsonSerializer.LookupSerializer(nominalType);  //TODO ??
             return new BsonDocumentWrapper(value, serializer);
         }
 
@@ -121,7 +121,7 @@ public static IEnumerable<BsonDocumentWrapper> CreateMultiple<TNominalType>(IEnu
                 throw new ArgumentNullException("values");
             }
 
-            var serializer = BsonSerializer.LookupSerializer(typeof(TNominalType)); //TODO I think this could stay. We can potentially add methods with the domain as input.
+            var serializer = BsonSerializer.LookupSerializer(typeof(TNominalType)); //TODO ??
             return values.Select(v => new BsonDocumentWrapper(v, serializer));
         }
 
@@ -142,7 +142,7 @@ public static IEnumerable<BsonDocumentWrapper> CreateMultiple(Type nominalType,
                 throw new ArgumentNullException("values");
             }
 
-            var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think this could stay. We can potentially add methods with the domain as input.
+            var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??
             return values.Cast<object>().Select(v => new BsonDocumentWrapper(v, serializer));
         }
 
diff --git a/src/MongoDB.Bson/Serialization/BsonMemberMap.cs b/src/MongoDB.Bson/Serialization/BsonMemberMap.cs
@@ -301,7 +301,7 @@ public IBsonSerializer GetSerializer()
                 // return special serializer for BsonValue members that handles the _csharpnull representation
                 if (_memberTypeIsBsonValue)
                 {
-                    var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType);   //TODO We need another version of this with the domain as input
+                    var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType);  //TODO ??
                     var isBsonArraySerializer = wrappedSerializer is IBsonArraySerializer;
                     var isBsonDocumentSerializer = wrappedSerializer is IBsonDocumentSerializer;
 
@@ -329,7 +329,7 @@ public IBsonSerializer GetSerializer()
                 }
                 else
                 {
-                    _serializer = BsonSerializer.LookupSerializer(_memberType);
+                    _serializer = BsonSerializer.LookupSerializer(_memberType); //TODO ??
                 }
             }
             return _serializer;
diff --git a/src/MongoDB.Bson/Serialization/BsonSerializationProviderBase.cs b/src/MongoDB.Bson/Serialization/BsonSerializationProviderBase.cs
@@ -24,7 +24,7 @@ namespace MongoDB.Bson.Serialization
     public abstract class BsonSerializationProviderBase : IRegistryAwareBsonSerializationProvider
     {
         /// <inheritdoc/>
-        public virtual IBsonSerializer GetSerializer(Type type)  //TODO Need to make another version with the domain as input
+        public virtual IBsonSerializer GetSerializer(Type type)  //TODO We can keep this as is
         {
             return GetSerializer(type, BsonSerializer.SerializerRegistry);
         }
@@ -38,7 +38,7 @@ public virtual IBsonSerializer GetSerializer(Type type)  //TODO Need to make ano
         /// <param name="serializerTypeDefinition">The serializer type definition.</param>
         /// <param name="typeArguments">The type arguments.</param>
         /// <returns>A serializer.</returns>
-        protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments)   //TODO We need another version of this with the domain as input
+        protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments)   //TODO We can keep this as is
         {
             return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.SerializerRegistry);
         }
@@ -65,7 +65,7 @@ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDef
         /// <returns>A serializer.</returns>
         protected virtual IBsonSerializer CreateSerializer(Type serializerType)
         {
-            return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);   //TODO We need another version of this with the domain as input
+            return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is
         }
 
         /// <summary>
diff --git a/src/MongoDB.Bson/Serialization/Conventions/LookupIdGeneratorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/LookupIdGeneratorConvention.cs
@@ -35,9 +35,8 @@ public void PostProcess(BsonClassMap classMap)
             {
                 if (idMemberMap.IdGenerator == null)
                 {
-                    //TODO For this, we either add a new PostProcess method to the IPostProcessingConvention that takes the domain
                     //or we pass the domain to the BsonClassMap. The first probably makes more sense, but it's messier.
-                    var idGenerator = BsonSerializer.LookupIdGenerator(idMemberMap.MemberType);
+                    var idGenerator = BsonSerializer.LookupIdGenerator(idMemberMap.MemberType);  //TODO ??
                     if (idGenerator != null)
                     {
                         idMemberMap.SetIdGenerator(idGenerator);
diff --git a/src/MongoDB.Bson/Serialization/Conventions/ObjectDiscriminatorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/ObjectDiscriminatorConvention.cs
@@ -135,7 +135,7 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType)
                     {
                         discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator
                     }
-                    actualType = BsonSerializer.LookupActualType(nominalType, discriminator);  //TODO For this (and other discriminator conventions) we need to add methods to IDiscriminatorConvention to pass the domain
+                    actualType = BsonSerializer.LookupActualType(nominalType, discriminator);  //TODO ??
                 }
                 bsonReader.ReturnToBookmark(bookmark);
                 return actualType;
diff --git a/src/MongoDB.Bson/Serialization/Conventions/StandardDiscriminatorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/StandardDiscriminatorConvention.cs
@@ -101,10 +101,10 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType)
             if (bsonType == BsonType.Document)
             {
                 // ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer)
-                BsonSerializer.EnsureKnownTypesAreRegistered(nominalType);
+                BsonSerializer.EnsureKnownTypesAreRegistered(nominalType); //TODO ??
 
                 // we can skip looking for a discriminator if nominalType has no discriminated sub types
-                if (BsonSerializer.IsTypeDiscriminated(nominalType))
+                if (BsonSerializer.IsTypeDiscriminated(nominalType)) //TODO ??
                 {
                     var bookmark = bsonReader.GetBookmark();
                     bsonReader.ReadStartDocument();
@@ -117,7 +117,7 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType)
                         {
                             discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator
                         }
-                        actualType = BsonSerializer.LookupActualType(nominalType, discriminator);
+                        actualType = BsonSerializer.LookupActualType(nominalType, discriminator); //TODO ??
                     }
                     bsonReader.ReturnToBookmark(bookmark);
                     return actualType;
diff --git a/src/MongoDB.Bson/Serialization/Conventions/StringIdStoredAsObjectIdConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/StringIdStoredAsObjectIdConvention.cs
@@ -38,7 +38,7 @@ public void Apply(BsonMemberMap memberMap)
                 return;
             }
 
-            var defaultStringSerializer = BsonSerializer.LookupSerializer(typeof(string));  //TODO For this we'd need to add a new Apply(memberMap, domain) method to IMemberMapConvention
+            var defaultStringSerializer = BsonSerializer.LookupSerializer(typeof(string));  //TODO ??
             if (memberMap.GetSerializer() != defaultStringSerializer)
             {
                 return;
diff --git a/src/MongoDB.Bson/Serialization/IBsonSerializerExtensions.cs b/src/MongoDB.Bson/Serialization/IBsonSerializerExtensions.cs
@@ -58,7 +58,7 @@ public static TValue Deserialize<TValue>(this IBsonSerializer<TValue> serializer
         public static IDiscriminatorConvention GetDiscriminatorConvention(this IBsonSerializer serializer) =>
             serializer is IHasDiscriminatorConvention hasDiscriminatorConvention
                 ? hasDiscriminatorConvention.DiscriminatorConvention
-                : BsonSerializer.LookupDiscriminatorConvention(serializer.ValueType);   //TODO We need another version of this with the domain as input
+                : BsonSerializer.LookupDiscriminatorConvention(serializer.ValueType);   //TODO We can keep this as is
 
         /// <summary>
         /// Serializes a value.

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public static IBsonSerializer DynamicArraySerializer`
`42`	`42`	`{`
`43`	`43`	`if (!__dynamicArraySerializerWasSet)`
`44`	`44`	`{`
`45`		`- __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>(); //TODO I think we could keep this as is`
	`45`	`+ __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>(); //TODO ??`
`46`	`46`	`}`
`47`	`47`	`return __dynamicArraySerializer;`
`48`	`48`	`}`
`@@ -62,7 +62,7 @@ public static IBsonSerializer DynamicDocumentSerializer`
`62`	`62`	`{`
`63`	`63`	`if (!__dynamicDocumentSerializerWasSet)`
`64`	`64`	`{`
`65`		`- __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>(); //TODO I think we could keep this as is`
	`65`	`+ __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>(); //TODO ??`
`66`	`66`	`}`
`67`	`67`	`return __dynamicDocumentSerializer;`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ public static byte[] ToBson(`
`84`	`84`
`85`	`85`	`if (serializer == null)`
`86`	`86`	`{`
`87`		`- serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think we need another method with the domain as input`
	`87`	`+ serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??`
`88`	`88`	`}`
`89`	`89`	`if (serializer.ValueType != nominalType)`
`90`	`90`	`{`
`@@ -165,7 +165,7 @@ public static BsonDocument ToBsonDocument(`
`165`	`165`	`return convertibleToBsonDocument.ToBsonDocument(); // use the provided ToBsonDocument method`
`166`	`166`	`}`
`167`	`167`
`168`		`- serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think we need another method with the domain as input`
	`168`	`+ serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??`
`169`	`169`	`}`
`170`	`170`	`if (serializer.ValueType != nominalType)`
`171`	`171`	`{`
`@@ -236,7 +236,7 @@ public static string ToJson(`
`236`	`236`
`237`	`237`	`if (serializer == null)`
`238`	`238`	`{`
`239`		`- serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think we need another method with the domain as input`
	`239`	`+ serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??`
`240`	`240`	`}`
`241`	`241`	`if (serializer.ValueType != nominalType)`
`242`	`242`	`{`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ public static BsonDocumentWrapper Create<TNominalType>(TNominalType value)`
`104`	`104`	`/// <returns>A BsonDocumentWrapper.</returns>`
`105`	`105`	`public static BsonDocumentWrapper Create(Type nominalType, object value)`
`106`	`106`	`{`
`107`		`- var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think this could stay. We can potentially add methods with the domain as input.`
	`107`	`+ var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??`
`108`	`108`	`return new BsonDocumentWrapper(value, serializer);`
`109`	`109`	`}`
`110`	`110`
`@@ -121,7 +121,7 @@ public static IEnumerable<BsonDocumentWrapper> CreateMultiple<TNominalType>(IEnu`
`121`	`121`	`throw new ArgumentNullException("values");`
`122`	`122`	`}`
`123`	`123`
`124`		`- var serializer = BsonSerializer.LookupSerializer(typeof(TNominalType)); //TODO I think this could stay. We can potentially add methods with the domain as input.`
	`124`	`+ var serializer = BsonSerializer.LookupSerializer(typeof(TNominalType)); //TODO ??`
`125`	`125`	`return values.Select(v => new BsonDocumentWrapper(v, serializer));`
`126`	`126`	`}`
`127`	`127`
`@@ -142,7 +142,7 @@ public static IEnumerable<BsonDocumentWrapper> CreateMultiple(Type nominalType,`
`142`	`142`	`throw new ArgumentNullException("values");`
`143`	`143`	`}`
`144`	`144`
`145`		`- var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think this could stay. We can potentially add methods with the domain as input.`
	`145`	`+ var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO ??`
`146`	`146`	`return values.Cast<object>().Select(v => new BsonDocumentWrapper(v, serializer));`
`147`	`147`	`}`
`148`	`148`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ public IBsonSerializer GetSerializer()`
`301`	`301`	`// return special serializer for BsonValue members that handles the _csharpnull representation`
`302`	`302`	`if (_memberTypeIsBsonValue)`
`303`	`303`	`{`
`304`		`- var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType); //TODO We need another version of this with the domain as input`
	`304`	`+ var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType); //TODO ??`
`305`	`305`	`var isBsonArraySerializer = wrappedSerializer is IBsonArraySerializer;`
`306`	`306`	`var isBsonDocumentSerializer = wrappedSerializer is IBsonDocumentSerializer;`
`307`	`307`
`@@ -329,7 +329,7 @@ public IBsonSerializer GetSerializer()`
`329`	`329`	`}`
`330`	`330`	`else`
`331`	`331`	`{`
`332`		`- _serializer = BsonSerializer.LookupSerializer(_memberType);`
	`332`	`+ _serializer = BsonSerializer.LookupSerializer(_memberType); //TODO ??`
`333`	`333`	`}`
`334`	`334`	`}`
`335`	`335`	`return _serializer;`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace MongoDB.Bson.Serialization`
`24`	`24`	`public abstract class BsonSerializationProviderBase : IRegistryAwareBsonSerializationProvider`
`25`	`25`	`{`
`26`	`26`	`/// <inheritdoc/>`
`27`		`- public virtual IBsonSerializer GetSerializer(Type type) //TODO Need to make another version with the domain as input`
	`27`	`+ public virtual IBsonSerializer GetSerializer(Type type) //TODO We can keep this as is`
`28`	`28`	`{`
`29`	`29`	`return GetSerializer(type, BsonSerializer.SerializerRegistry);`
`30`	`30`	`}`
`@@ -38,7 +38,7 @@ public virtual IBsonSerializer GetSerializer(Type type) //TODO Need to make ano`
`38`	`38`	`/// <param name="serializerTypeDefinition">The serializer type definition.</param>`
`39`	`39`	`/// <param name="typeArguments">The type arguments.</param>`
`40`	`40`	`/// <returns>A serializer.</returns>`
`41`		`- protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments) //TODO We need another version of this with the domain as input`
	`41`	`+ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments) //TODO We can keep this as is`
`42`	`42`	`{`
`43`	`43`	`return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.SerializerRegistry);`
`44`	`44`	`}`
`@@ -65,7 +65,7 @@ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDef`
`65`	`65`	`/// <returns>A serializer.</returns>`
`66`	`66`	`protected virtual IBsonSerializer CreateSerializer(Type serializerType)`
`67`	`67`	`{`
`68`		`- return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry); //TODO We need another version of this with the domain as input`
	`68`	`+ return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry); //TODO We can keep this as is`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -35,9 +35,8 @@ public void PostProcess(BsonClassMap classMap)`
`35`	`35`	`{`
`36`	`36`	`if (idMemberMap.IdGenerator == null)`
`37`	`37`	`{`
`38`		`- //TODO For this, we either add a new PostProcess method to the IPostProcessingConvention that takes the domain`
`39`	`38`	`//or we pass the domain to the BsonClassMap. The first probably makes more sense, but it's messier.`
`40`		`- var idGenerator = BsonSerializer.LookupIdGenerator(idMemberMap.MemberType);`
	`39`	`+ var idGenerator = BsonSerializer.LookupIdGenerator(idMemberMap.MemberType); //TODO ??`
`41`	`40`	`if (idGenerator != null)`
`42`	`41`	`{`
`43`	`42`	`idMemberMap.SetIdGenerator(idGenerator);`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType)`
`135`	`135`	`{`
`136`	`136`	`discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator`
`137`	`137`	`}`
`138`		`- actualType = BsonSerializer.LookupActualType(nominalType, discriminator); //TODO For this (and other discriminator conventions) we need to add methods to IDiscriminatorConvention to pass the domain`
	`138`	`+ actualType = BsonSerializer.LookupActualType(nominalType, discriminator); //TODO ??`
`139`	`139`	`}`
`140`	`140`	`bsonReader.ReturnToBookmark(bookmark);`
`141`	`141`	`return actualType;`
Original file line number	Diff line number	Diff line change
`@@ -101,10 +101,10 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType)`
`101`	`101`	`if (bsonType == BsonType.Document)`
`102`	`102`	`{`
`103`	`103`	`// ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer)`
`104`		`- BsonSerializer.EnsureKnownTypesAreRegistered(nominalType);`
	`104`	`+ BsonSerializer.EnsureKnownTypesAreRegistered(nominalType); //TODO ??`
`105`	`105`
`106`	`106`	`// we can skip looking for a discriminator if nominalType has no discriminated sub types`
`107`		`- if (BsonSerializer.IsTypeDiscriminated(nominalType))`
	`107`	`+ if (BsonSerializer.IsTypeDiscriminated(nominalType)) //TODO ??`
`108`	`108`	`{`
`109`	`109`	`var bookmark = bsonReader.GetBookmark();`
`110`	`110`	`bsonReader.ReadStartDocument();`
`@@ -117,7 +117,7 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType)`
`117`	`117`	`{`
`118`	`118`	`discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator`
`119`	`119`	`}`
`120`		`- actualType = BsonSerializer.LookupActualType(nominalType, discriminator);`
	`120`	`+ actualType = BsonSerializer.LookupActualType(nominalType, discriminator); //TODO ??`
`121`	`121`	`}`
`122`	`122`	`bsonReader.ReturnToBookmark(bookmark);`
`123`	`123`	`return actualType;`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public void Apply(BsonMemberMap memberMap)`
`38`	`38`	`return;`
`39`	`39`	`}`
`40`	`40`
`41`		`- var defaultStringSerializer = BsonSerializer.LookupSerializer(typeof(string)); //TODO For this we'd need to add a new Apply(memberMap, domain) method to IMemberMapConvention`
	`41`	`+ var defaultStringSerializer = BsonSerializer.LookupSerializer(typeof(string)); //TODO ??`
`42`	`42`	`if (memberMap.GetSerializer() != defaultStringSerializer)`
`43`	`43`	`{`
`44`	`44`	`return;`