Replaces CreateTupleAccessExpressionForConstant with CloseOver, which…

… is simpler and requires less reflection.

src/JsonApiDotNetCore/Queries/QueryableBuilding/SelectClauseBuilder.cs

@@ -93,9 +93,9 @@ private Expression CreateLambdaBodyInitializerForTypeHierarchy(FieldSelection se
     private static BinaryExpression CreateRuntimeTypeCheck(LambdaScope lambdaScope, Type concreteClrType)
     {
         // Emitting "resource.GetType() == typeof(Article)" instead of "resource is Article" so we don't need to check for most-derived
-        // types first. This way, we can fallback to "anything else" at the end without worrying about order.
+        // types first. This way, we can fall back to "anything else" at the end without worrying about order.
 
-        Expression concreteTypeConstant = concreteClrType.CreateTupleAccessExpressionForConstant(typeof(Type));
+        Expression concreteTypeConstant = SystemExpressionBuilder.CloseOver(concreteClrType);
         MethodCallExpression getTypeCall = Expression.Call(lambdaScope.Accessor, TypeGetTypeMethod);
 
         return Expression.MakeBinary(ExpressionType.Equal, getTypeCall, concreteTypeConstant, false, TypeOpEqualityMethod);

src/JsonApiDotNetCore/Queries/QueryableBuilding/SkipTakeClauseBuilder.cs

@@ -36,7 +36,7 @@ public override Expression VisitPagination(PaginationExpression expression, Quer
 
     private static Expression ExtensionMethodCall(Expression source, string operationName, int value, QueryClauseBuilderContext context)
     {
-        Expression constant = value.CreateTupleAccessExpressionForConstant(typeof(int));
+        Expression constant = SystemExpressionBuilder.CloseOver(value);
 
         return Expression.Call(context.ExtensionType, operationName, [context.LambdaScope.Parameter.Type], source, constant);
     }

src/JsonApiDotNetCore/Queries/QueryableBuilding/WhereClauseBuilder.cs

@@ -245,7 +245,6 @@ public override Expression VisitNullConstant(NullConstantExpression expression,
 
     public override Expression VisitLiteralConstant(LiteralConstantExpression expression, QueryClauseBuilderContext context)
     {
-        Type type = expression.TypedValue.GetType();
-        return expression.TypedValue.CreateTupleAccessExpressionForConstant(type);
+        return SystemExpressionBuilder.CloseOver(expression.TypedValue);
     }
 }

src/JsonApiDotNetCore/Queries/SystemExpressionBuilder.cs

@@ -0,0 +1,34 @@
+using System.Linq.Expressions;
+using System.Reflection;
+
+#pragma warning disable AV1008
+
+namespace JsonApiDotNetCore.Queries;
+
+internal static class SystemExpressionBuilder
+{
+    private static readonly MethodInfo CloseOverOpenMethod =
+        typeof(SystemExpressionBuilder).GetMethods().Single(method => method is { Name: nameof(CloseOver), IsGenericMethod: true });
+
+    // To enable efficient query plan caching, inline constants (that vary per request) should be converted into query parameters.
+    // https://stackoverflow.com/questions/54075758/building-a-parameterized-entityframework-core-expression
+    //
+    // CloseOver can be used to change a query like:
+    //   SELECT ... FROM ... WHERE x."Age" = 3
+    // into:
+    //   SELECT ... FROM ... WHERE x."Age" = @p0
+
+    public static Expression CloseOver(object value)
+    {
+        ArgumentGuard.NotNull(value);
+
+        MethodInfo closeOverClosedMethod = CloseOverOpenMethod.MakeGenericMethod(value.GetType());
+        return (Expression)closeOverClosedMethod.Invoke(null, [value])!;
+    }
+
+    public static Expression CloseOver<T>(T value)
+    {
+        // From https://github.com/dotnet/efcore/issues/28151#issuecomment-1374480257.
+        return ((Expression<Func<T>>)(() => value)).Body;
+    }
+}

src/JsonApiDotNetCore/Resources/ResourceFactory.cs

@@ -102,7 +102,7 @@ public NewExpression CreateNewExpression(Type resourceClrType)
             {
                 object constructorArgument = ActivatorUtilities.GetServiceOrCreateInstance(_serviceProvider, constructorParameter.ParameterType);
 
-                Expression argumentExpression = constructorArgument.CreateTupleAccessExpressionForConstant(constructorArgument.GetType());
+                Expression argumentExpression = SystemExpressionBuilder.CloseOver(constructorArgument);
                 constructorArguments.Add(argumentExpression);
             }
 #pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException