CSHARP-5506: Support Dictionary get_Item for keys that aren't strings but are serialized as strings.

rstam · rstam · commit 067ddb620b0a · 2025-03-27T13:02:26.000-07:00
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/DictionaryMethod.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/DictionaryMethod.cs
@@ -21,16 +21,15 @@ namespace MongoDB.Driver.Linq.Linq3Implementation.Reflection
     internal static class DictionaryMethod
     {
         // public static methods
-        public static bool IsGetItemWithStringMethod(MethodInfo method)
+        public static bool IsGetItemWithKeyMethod(MethodInfo method)
         {
             return
                 !method.IsStatic &&
                 method.Name == "get_Item" &&
+                method.DeclaringType.ImplementsDictionaryInterface(out var keyType, out var valueType) &&
                 method.GetParameters() is var parameters &&
                 parameters.Length == 1 &&
-                parameters[0].ParameterType == typeof(string) &&
-                method.DeclaringType.ImplementsDictionaryInterface(out var keyType, out var valueType) &&
-                keyType == typeof(string) &&
+                parameters[0].ParameterType == keyType &&
                 method.ReturnType == valueType;
         }
     }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/GetItemMethodToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/GetItemMethodToAggregationExpressionTranslator.cs
@@ -19,9 +19,9 @@
 using System.Reflection;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Options;
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
-using MongoDB.Driver.Linq.Linq3Implementation.ExtensionMethods;
 using MongoDB.Driver.Linq.Linq3Implementation.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
 
@@ -55,9 +55,9 @@ public static TranslatedExpression Translate(TranslationContext context, Express
                 return TranslateIListGetItemWithInt(context, expression, sourceExpression, arguments[0]);
             }
 
-            if (DictionaryMethod.IsGetItemWithStringMethod(method))
+            if (DictionaryMethod.IsGetItemWithKeyMethod(method))
             {
-                return TranslateIDictionaryGetItemWithString(context, expression, sourceExpression, arguments[0]);
+                return TranslateIDictionaryGetItemWithKey(context, expression, sourceExpression, arguments[0]);
             }
 
             throw new ExpressionNotSupportedException(expression);
@@ -112,13 +112,55 @@ private static TranslatedExpression TranslateIListGetItemWithInt(TranslationCont
             return new TranslatedExpression(expression, ast, serializer);
         }
 
-        private static TranslatedExpression TranslateIDictionaryGetItemWithString(TranslationContext context, Expression expression, Expression sourceExpression, Expression keyExpression)
+        private static TranslatedExpression TranslateIDictionaryGetItemWithKey(TranslationContext context, Expression expression, Expression dictionaryExpression, Expression keyExpression)
         {
-            var sourceTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, sourceExpression);
-            var key = keyExpression.GetConstantValue<string>(containingExpression: expression);
-            var ast = AstExpression.GetField(sourceTranslation.Ast, key); // TODO: verify that dictionary is using Document representation
-            var valueSerializer = GetDictionaryValueSerializer(sourceTranslation.Serializer);
-            return new TranslatedExpression(expression, ast, valueSerializer);
+            var dictionaryTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, dictionaryExpression);
+            if (!(dictionaryTranslation.Serializer is IBsonDictionarySerializer dictionarySerializer))
+            {
+                throw new ExpressionNotSupportedException(expression, because: $"dictionary serializer class {dictionaryTranslation.Serializer.GetType()} does not implement {nameof(IBsonDictionarySerializer)}");
+            }
+            if (dictionarySerializer.DictionaryRepresentation != DictionaryRepresentation.Document)
+            {
+                throw new ExpressionNotSupportedException(expression, because: "dictionary is not represented as a document");
+            }
+
+            var keySerializer = dictionarySerializer.KeySerializer;
+            AstExpression keyFieldNameAst;
+
+            if (keyExpression is ConstantExpression constantKeyExpression)
+            {
+                var key = constantKeyExpression.Value;
+                var serializedKey = SerializationHelper.SerializeValue(keySerializer, key);
+
+                if (!(serializedKey is BsonString))
+                {
+                    throw new ExpressionNotSupportedException(expression, because: "key did not serialize as a string");
+                }
+
+                keyFieldNameAst = AstExpression.Constant(serializedKey);
+            }
+            else
+            {
+                if (!(keySerializer is IHasRepresentationSerializer hasRepresentationSerializer))
+                {
+                    throw new ExpressionNotSupportedException(expression, because: $"key serializer class {keySerializer.GetType()} does not implement {nameof(IHasRepresentationSerializer)}");
+                }
+                if (hasRepresentationSerializer.Representation != BsonType.String)
+                {
+                    throw new ExpressionNotSupportedException(expression, because: $"key serializer class {keySerializer.GetType()} does not serialize as a string");
+                }
+
+                var keyTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, keyExpression);
+                if (!keyTranslation.Serializer.Equals(keySerializer))
+                {
+                    throw new ExpressionNotSupportedException(expression, because: "key expression serializer is not equal to the key serializer");
+                }
+
+                keyFieldNameAst = keyTranslation.Ast;
+            }
+
+            var ast = AstExpression.GetField(dictionaryTranslation.Ast, keyFieldNameAst);
+            return new TranslatedExpression(expression, ast, dictionarySerializer.ValueSerializer);
         }
     }
 }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ToFilterFieldTranslators/GetItemMethodToFilterFieldTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ToFilterFieldTranslators/GetItemMethodToFilterFieldTranslator.cs
@@ -16,11 +16,12 @@
 using System.Collections.ObjectModel;
 using System.Linq.Expressions;
 using System.Reflection;
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Options;
 using MongoDB.Bson.Serialization.Serializers;
-using MongoDB.Driver.Linq.Linq3Implementation.Ast.Filters;
 using MongoDB.Driver.Linq.Linq3Implementation.ExtensionMethods;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToFilterTranslators.ToFilterFieldTranslators
@@ -53,9 +54,9 @@ public static TranslatedFilterField Translate(TranslationContext context, Expres
                 return TranslateIListGetItemWithInt(context, expression, fieldExpression, arguments[0]);
             }
 
-            if (DictionaryMethod.IsGetItemWithStringMethod(method))
+            if (DictionaryMethod.IsGetItemWithKeyMethod(method))
             {
-                return TranslateDictionaryGetItemWithString(context, expression, fieldExpression, arguments[0]);
+                return TranslateDictionaryGetItemWithKey(context, expression, fieldExpression, arguments[0]);
             }
 
             throw new ExpressionNotSupportedException(expression);
@@ -79,19 +80,30 @@ private static TranslatedFilterField TranslateIListGetItemWithInt(TranslationCon
             return ArrayIndexExpressionToFilterFieldTranslator.Translate(context, expression, fieldExpression, indexExpression);
         }
 
-        private static TranslatedFilterField TranslateDictionaryGetItemWithString(TranslationContext context, Expression expression, Expression fieldExpression, Expression keyExpression)
+        private static TranslatedFilterField TranslateDictionaryGetItemWithKey(TranslationContext context, Expression expression, Expression fieldExpression, Expression keyExpression)
         {
             var fieldTranslation = ExpressionToFilterFieldTranslator.Translate(context, fieldExpression);
-            var key = keyExpression.GetConstantValue<string>(containingExpression: expression);
+            var key = keyExpression.GetConstantValue<object>(containingExpression: expression);
 
-            if (fieldTranslation.Serializer is IBsonDictionarySerializer dictionarySerializer &&
-                dictionarySerializer.DictionaryRepresentation == DictionaryRepresentation.Document)
+            if (!(fieldTranslation.Serializer is IBsonDictionarySerializer dictionarySerializer))
+            {
+                throw new ExpressionNotSupportedException(expression, because: $"dictionary serializer class {fieldTranslation.Serializer.GetType()} does not implement {nameof(IBsonDictionarySerializer)}");
+            }
+            if (dictionarySerializer.DictionaryRepresentation != DictionaryRepresentation.Document)
             {
-                var valueSerializer = dictionarySerializer.ValueSerializer;
-                return fieldTranslation.SubField(key, valueSerializer);
+                throw new ExpressionNotSupportedException(expression, because: "dictionary is not represented as a document");
             }
 
-            throw new ExpressionNotSupportedException(expression);
+            var keySerializer = dictionarySerializer.KeySerializer;
+            var valueSerializer = dictionarySerializer.ValueSerializer;
+
+            var serializedKey = SerializationHelper.SerializeValue(keySerializer, key);
+            if (serializedKey is not BsonString)
+            {
+                throw new ExpressionNotSupportedException(expression, because: "key did not serialize as a string");
+            }
+
+            return fieldTranslation.SubField(serializedKey.AsString, valueSerializer);
         }
     }
 }
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp5506Tests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp5506Tests.cs
@@ -0,0 +1,96 @@
+﻿/* 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.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Options;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.TestHelpers;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3Implementation.Jira;
+
+public class CSharp5506Tests : LinqIntegrationTest<CSharp5506Tests.ClassFixture>
+{
+    static CSharp5506Tests()
+    {
+        var keySerializer = new GuidSerializer(BsonType.String);
+        var valueSerializer = Int32Serializer.Instance;
+        var dictionarySerializer = new DictionaryInterfaceImplementerSerializer<Dictionary<Guid, int>>(
+            DictionaryRepresentation.Document,
+            keySerializer,
+            valueSerializer);
+
+        BsonClassMap.RegisterClassMap<C>(cm =>
+        {
+            cm.AutoMap();
+            cm.MapMember(x => x.Dictionary).SetSerializer(dictionarySerializer);
+        });
+    }
+
+    public CSharp5506Tests(ClassFixture fixture)
+        : base(fixture)
+    {
+    }
+
+    [Fact]
+    public void Where_Dictionary_item_equals_value_should_work()
+    {
+        var collection = Fixture.Collection;
+        var guid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
+
+        var queryable = collection.AsQueryable().Where(x => x.Dictionary[guid] == 2);
+
+        var stages = Translate(collection, queryable);
+        AssertStages(stages, "{ $match : { 'Dictionary.01020304-0506-0708-090a-0b0c0d0e0f10' : 2 } }");
+
+        var result = Queryable.Single(queryable);
+        result.Id.Should().Be(1);
+    }
+
+    [Fact]
+    public void Select_Dictionary_item_equals_value_should_work()
+    {
+        var collection = Fixture.Collection;
+        var guid = Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10");
+
+        var queryable = collection.AsQueryable()
+            .Select(x => x.Dictionary[guid]);
+
+        var stages = Translate(collection, queryable);
+        AssertStages(stages, "{ $project : { _v : '$Dictionary.01020304-0506-0708-090a-0b0c0d0e0f10', _id : 0 } }");
+
+        var result = Queryable.Single(queryable);
+        result.Should().Be(2);
+    }
+
+    public class C
+    {
+        public int Id { get; set; }
+        public Dictionary<Guid, int> Dictionary { get; set; }
+    }
+
+    public sealed class ClassFixture : MongoCollectionFixture<C>
+    {
+        protected override IEnumerable<C> InitialData =>
+        [
+            new C { Id = 1, Dictionary = new Dictionary<Guid, int> { [Guid.Parse("01020304-0506-0708-090a-0b0c0d0e0f10")] = 2 } },
+        ];
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -21,16 +21,15 @@ namespace MongoDB.Driver.Linq.Linq3Implementation.Reflection`
`21`	`21`	`internal static class DictionaryMethod`
`22`	`22`	`{`
`23`	`23`	`// public static methods`
`24`		`- public static bool IsGetItemWithStringMethod(MethodInfo method)`
	`24`	`+ public static bool IsGetItemWithKeyMethod(MethodInfo method)`
`25`	`25`	`{`
`26`	`26`	`return`
`27`	`27`	`!method.IsStatic &&`
`28`	`28`	`method.Name == "get_Item" &&`
	`29`	`+ method.DeclaringType.ImplementsDictionaryInterface(out var keyType, out var valueType) &&`
`29`	`30`	`method.GetParameters() is var parameters &&`
`30`	`31`	`parameters.Length == 1 &&`
`31`		`- parameters[0].ParameterType == typeof(string) &&`
`32`		`- method.DeclaringType.ImplementsDictionaryInterface(out var keyType, out var valueType) &&`
`33`		`- keyType == typeof(string) &&`
	`32`	`+ parameters[0].ParameterType == keyType &&`
`34`	`33`	`method.ReturnType == valueType;`
`35`	`34`	`}`
`36`	`35`	`}`