[main] Source code updates from dotnet/efcore (#4119)

dotnet-maestro[bot] · web-flow · commit db3b7424251b · 2026-01-10T05:05:08.000Z
[main] Source code updates from dotnet/efcore
diff --git a/src/efcore/src/EFCore.Analyzers/EFCore.Analyzers.csproj b/src/efcore/src/EFCore.Analyzers/EFCore.Analyzers.csproj
@@ -5,11 +5,18 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <AssemblyName>Microsoft.EntityFrameworkCore.Analyzers</AssemblyName>
     <RootNamespace>Microsoft.EntityFrameworkCore</RootNamespace>
-    <IncludeBuildOutput>false</IncludeBuildOutput>
-    <NuspecFile>$(MSBuildProjectName).nuspec</NuspecFile>
+
+    <!-- Causes the dll/pdb to be placed in the analyzers/dotnet/cs folder in the nupkg instead of lib -->
+    <BuildOutputTargetFolder>analyzers/dotnet/cs</BuildOutputTargetFolder>
+
+    <!-- A slightly hacky way to place the dll/pdbs directly under analyzers/dotnet/cs, and not under a netstandard2.0 subfolder -->
+    <IsTool>true</IsTool>
+
+    <IncludeSymbols>true</IncludeSymbols>
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)..\..\rulesets\EFCore.noxmldocs.ruleset</CodeAnalysisRuleSet>
     <ImplicitUsings>true</ImplicitUsings>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
     <NoWarn>$(NoWarn);NU5128</NoWarn>
     <NoWarn>$(NoWarn);RS1038</NoWarn> <!-- Compiler extensions should be implemented in assemblies with compiler-provided references, #35752 -->
   </PropertyGroup>
@@ -34,19 +41,6 @@
     <PackageReference Update="NETStandard.Library" PrivateAssets="all" />
   </ItemGroup>
 
-  <Target Name="SetPackageProperties" BeforeTargets="InitializeStandardNuspecProperties" DependsOnTargets="Build">
-    <PropertyGroup>
-      <!-- Make sure we create a symbols.nupkg. -->
-      <IncludeSymbols>true</IncludeSymbols>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <NuspecProperty Include="targetFramework=$(TargetFramework)" />
-      <NuspecProperty Include="OutputBinary=$(OutputPath)$(AssemblyName).dll" />
-      <NuspecProperty Include="OutputSymbol=$(OutputPath)$(AssemblyName).pdb" />
-    </ItemGroup>
-  </Target>
-
   <ItemGroup>
     <AdditionalFiles Include="AnalyzerReleases.Shipped.md" />
     <AdditionalFiles Include="AnalyzerReleases.Unshipped.md" />
diff --git a/src/efcore/src/EFCore.Analyzers/EFCore.Analyzers.nuspec b/src/efcore/src/EFCore.Analyzers/EFCore.Analyzers.nuspec
diff --git a/src/efcore/src/EFCore.Analyzers/README.md b/src/efcore/src/EFCore.Analyzers/README.md
diff --git a/src/efcore/src/EFCore.Relational/Migrations/MigrationsSqlGenerator.cs b/src/efcore/src/EFCore.Relational/Migrations/MigrationsSqlGenerator.cs
@@ -1367,7 +1367,7 @@ protected virtual void ColumnDefinition(
         {
             builder
                 .Append(" COLLATE ")
-                .Append(operation.Collation);
+                .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Collation));
         }
 
         builder.Append(operation.IsNullable ? " NULL" : " NOT NULL");
diff --git a/src/efcore/src/EFCore.Relational/Query/QuerySqlGenerator.cs b/src/efcore/src/EFCore.Relational/Query/QuerySqlGenerator.cs
@@ -733,9 +733,13 @@ protected override Expression VisitCollate(CollateExpression collateExpression)
     {
         Visit(collateExpression.Operand);
 
+        // In some databases (e.g. SQL Server), collations aren't regular identifiers (like column or table names), and so shouldn't be
+        // quoted. However, we still default to quoting to prevent cases where arbitrary collation name inputs get integrated into the SQL.
+        // Providers which don't support quoting of collation names should override this method to provide sanitization logic,
+        // e.g. throwing if the name contains any but a restricted set of characters.
         _relationalCommandBuilder
             .Append(" COLLATE ")
-            .Append(collateExpression.Collation);
+            .Append(_sqlGenerationHelper.DelimitIdentifier(collateExpression.Collation));
 
         return collateExpression;
     }
diff --git a/src/efcore/src/EFCore.SqlServer/Migrations/SqlServerMigrationsSqlGenerator.cs b/src/efcore/src/EFCore.SqlServer/Migrations/SqlServerMigrationsSqlGenerator.cs
@@ -1646,6 +1646,18 @@ protected override void ColumnDefinition(
 
         if (operation.Collation != null)
         {
+            // SQL Server collation docs: https://learn.microsoft.com/sql/relational-databases/collations/collation-and-unicode-support
+
+            // The default behavior in MigrationsSqlGenerator is to quote collation names, but SQL Server does not support that.
+            // Instead, make sure the collation name only contains a restricted set of characters.
+            foreach (var c in operation.Collation)
+            {
+                if (!char.IsLetterOrDigit(c) && c != '_')
+                {
+                    throw new InvalidOperationException(SqlServerStrings.InvalidCollationName(operation.Collation));
+                }
+            }
+
             builder
                 .Append(" COLLATE ")
                 .Append(operation.Collation);
diff --git a/src/efcore/src/EFCore.SqlServer/Properties/SqlServerStrings.Designer.cs b/src/efcore/src/EFCore.SqlServer/Properties/SqlServerStrings.Designer.cs
diff --git a/src/efcore/src/EFCore.SqlServer/Properties/SqlServerStrings.resx b/src/efcore/src/EFCore.SqlServer/Properties/SqlServerStrings.resx
@@ -192,6 +192,9 @@
   <data name="IndexTableRequired" xml:space="preserve">
     <value>SQL Server requires the table name to be specified for index operations. Specify table name in calls to 'MigrationBuilder.RenameIndex' and 'DropIndex'.</value>
   </data>
+  <data name="InvalidCollationName" xml:space="preserve">
+    <value>Collation name '{collation}' is invalid; collation names may only contain alphanumeric characters and underscores.</value>
+  </data>
   <data name="InvalidColumnNameForFreeText" xml:space="preserve">
     <value>The expression passed to the 'propertyReference' parameter of the 'FreeText' method is not a valid reference to a property. The expression must represent a reference to a full-text indexed property on the object referenced in the from clause: 'from e in context.Entities where EF.Functions.FreeText(e.SomeProperty, textToSearchFor) select e'</value>
   </data>
diff --git a/src/efcore/src/EFCore.SqlServer/Query/Internal/SqlServerQuerySqlGenerator.cs b/src/efcore/src/EFCore.SqlServer/Query/Internal/SqlServerQuerySqlGenerator.cs
@@ -55,6 +55,35 @@ protected override bool TryGenerateWithoutWrappingSelect(SelectExpression select
         => selectExpression.Tables is not [ValuesExpression]
             && base.TryGenerateWithoutWrappingSelect(selectExpression);
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    protected override Expression VisitCollate(CollateExpression collateExpression)
+    {
+        Visit(collateExpression.Operand);
+
+        // SQL Server collation docs: https://learn.microsoft.com/sql/relational-databases/collations/collation-and-unicode-support
+
+        // The default behavior in QuerySqlGenerator is to quote collation names, but SQL Server does not support that.
+        // Instead, make sure the collation name only contains a restricted set of characters.
+        foreach (var c in collateExpression.Collation)
+        {
+            if (!char.IsLetterOrDigit(c) && c != '_')
+            {
+                throw new InvalidOperationException(SqlServerStrings.InvalidCollationName(collateExpression.Collation));
+            }
+        }
+
+        Sql
+            .Append(" COLLATE ")
+            .Append(collateExpression.Collation);
+
+        return collateExpression;
+    }
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
diff --git a/src/efcore/src/EFCore.Sqlite.Core/Migrations/SqliteMigrationsSqlGenerator.cs b/src/efcore/src/EFCore.Sqlite.Core/Migrations/SqliteMigrationsSqlGenerator.cs
@@ -377,13 +377,13 @@ private IReadOnlyList<MigrationOperation> RewriteOperations(
                 // Skip autoincrement primary key columns that are being added in this migration
                 var isAutoincrement = column.FindAnnotation(SqliteAnnotationNames.Autoincrement)?.Value as bool? == true;
                 var isPrimaryKey = column.Table.PrimaryKey?.Columns.Contains(column) == true;
-                
+
                 if (isAutoincrement && isPrimaryKey)
                 {
                     // Check if this column is being added in the current migration
                     var isNewColumn = migrationOperations.OfType<AddColumnOperation>()
                         .Any(op => op.Table == key.Table && op.Schema == key.Schema && op.Name == column.Name);
-                    
+
                     if (isNewColumn)
                     {
                         continue; // Skip newly added autoincrement columns
@@ -976,7 +976,7 @@ protected override void ComputedColumnDefinition(
         {
             builder
                 .Append(" COLLATE ")
-                .Append(operation.Collation);
+                .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Collation));
         }
     }
 
diff --git a/src/efcore/src/EFCore/Query/Internal/ExpressionTreeFuncletizer.cs b/src/efcore/src/EFCore/Query/Internal/ExpressionTreeFuncletizer.cs
@@ -2080,20 +2080,22 @@ bool PreserveConvertNode(Expression expression)
 
         if (evaluateAsParameter)
         {
-            parameterName = tempParameterName ?? "p";
-
-            var compilerPrefixIndex = parameterName.LastIndexOf('>');
-            if (compilerPrefixIndex != -1)
-            {
-                parameterName = parameterName[(compilerPrefixIndex + 1)..];
-            }
+            parameterName = string.IsNullOrWhiteSpace(tempParameterName) ? "p" : tempParameterName;
 
             // The VB compiler prefixes closure member names with $VB$Local_, remove that (#33150)
             if (parameterName.StartsWith("$VB$Local_", StringComparison.Ordinal))
             {
                 parameterName = parameterName.Substring("$VB$Local_".Length);
             }
 
+            // In many databases, parameter names must start with a letter or underscore.
+            // The same is true for C# variable names, from which we derive the parameter name, so in principle we shouldn't see an issue;
+            // but just in case, prepend an underscore if the parameter name doesn't start with a letter or underscore.
+            if (!char.IsLetter(parameterName[0]) && parameterName[0] != '_')
+            {
+                parameterName = "_" + parameterName;
+            }
+
             parameterName = Uniquifier.Uniquify(parameterName, _parameterNames, maxLength: int.MaxValue, uniquifier: _parameterNames.Count);
 
             _parameterNames.Add(parameterName);
@@ -2147,11 +2149,13 @@ static Expression RemoveConvert(Expression expression)
                         switch (memberExpression.Member)
                         {
                             case FieldInfo fieldInfo:
-                                parameterName = parameterName is null ? fieldInfo.Name : $"{parameterName}_{fieldInfo.Name}";
+                                var name = SanitizeCompilerGeneratedName(fieldInfo.Name);
+                                parameterName = parameterName is null ? name : $"{parameterName}_{name}";
                                 return fieldInfo.GetValue(instanceValue);
 
                             case PropertyInfo propertyInfo:
-                                parameterName = parameterName is null ? propertyInfo.Name : $"{parameterName}_{propertyInfo.Name}";
+                                name = SanitizeCompilerGeneratedName(propertyInfo.Name);
+                                parameterName = parameterName is null ? name : $"{parameterName}_{name}";
                                 return propertyInfo.GetValue(instanceValue);
                         }
                     }
@@ -2166,7 +2170,7 @@ static Expression RemoveConvert(Expression expression)
                     return constantExpression.Value;
 
                 case MethodCallExpression methodCallExpression:
-                    parameterName = methodCallExpression.Method.Name;
+                    parameterName = SanitizeCompilerGeneratedName(methodCallExpression.Method.Name);
                     break;
 
                 case UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked } unaryExpression
@@ -2190,6 +2194,25 @@ static Expression RemoveConvert(Expression expression)
                     exception);
             }
         }
+
+        static string SanitizeCompilerGeneratedName(string s)
+        {
+            // Compiler-generated field names intentionally contain illegal characters, specifically angle brackets <>.
+            // In cases where there's something within the angle brackets, that tends to be the original user-provided variable name
+            // (e.g. <PropertyName>k__BackingField). If we see angle brackets, extract that out, or it the angle brackets contain no
+            // content, strip them out entirely and take what comes after.
+            var closingBracket = s.IndexOf('>');
+            if (closingBracket == -1)
+            {
+                return s;
+            }
+
+            var openingBracket = s.IndexOf('<');
+
+            return openingBracket != -1 && openingBracket < closingBracket - 1
+                ? s[(openingBracket + 1)..closingBracket]
+                : s[(closingBracket + 1)..];
+        }
     }
 
     private Expression ConvertIfNeeded(Expression expression, Type type)
diff --git a/src/efcore/src/EFCore/Query/LiftableConstantProcessor.cs b/src/efcore/src/EFCore/Query/LiftableConstantProcessor.cs
@@ -286,6 +286,8 @@ protected override Expression VisitConstant(ConstantExpression node)
                 // without risk breaking existing scenarios
                 || node.Value is ParameterBindingInfo or RuntimeServiceProperty or IMaterializationInterceptor
                     or IInstantiationBindingInterceptor
+                // see #36898
+                || node.Value is ValueConverter
                 || node.Type.Name is "ProxyFactory" or "Point")
             {
                 return node;
diff --git a/src/efcore/test/EFCore.Cosmos.FunctionalTests/Query/NorthwindMiscellaneousQueryCosmosTest.cs b/src/efcore/test/EFCore.Cosmos.FunctionalTests/Query/NorthwindMiscellaneousQueryCosmosTest.cs
@@ -2031,6 +2031,18 @@ FROM root c
 SELECT VALUE c
 FROM root c
 WHERE (c["$type"] = "Order")
+""");
+            });
+
+    public override Task Captured_variable_from_switch_case_pattern_matching(bool async)
+        => Fixture.NoSyncTest(
+            async, async a =>
+            {
+                await base.Captured_variable_from_switch_case_pattern_matching(a);
+
+                AssertSql(
+                    """
+ReadItem(None, ALFKI)
 """);
             });
 
diff --git a/src/efcore/test/EFCore.Specification.Tests/Query/NorthwindMiscellaneousQueryTestBase.cs b/src/efcore/test/EFCore.Specification.Tests/Query/NorthwindMiscellaneousQueryTestBase.cs
@@ -2993,6 +2993,23 @@ public virtual Task Parameter_extraction_can_throw_exception_from_user_code_2(bo
                     && o.OrderDate.Value.Year == dateFilter.Value.Year)));
     }
 
+    [ConditionalTheory, MemberData(nameof(IsAsyncData))]
+    public virtual async Task Captured_variable_from_switch_case_pattern_matching(bool async)
+    {
+        object customerIdAsObject = "ALFKI";
+
+        switch (customerIdAsObject)
+        {
+            case string customerId:
+            {
+                await AssertQuery(
+                    async,
+                    ss => ss.Set<Customer>().Where(c => c.CustomerID == customerId));
+                break;
+            }
+        }
+    }
+
     [ConditionalTheory, MemberData(nameof(IsAsyncData))]
     public virtual Task Subquery_member_pushdown_does_not_change_original_subquery_model(bool async)
         => AssertQuery(
diff --git a/src/efcore/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindDbFunctionsQuerySqlServerTest.cs b/src/efcore/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindDbFunctionsQuerySqlServerTest.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore.SqlServer.Internal;
 using Microsoft.EntityFrameworkCore.TestModels.Northwind;
 
 // ReSharper disable InconsistentNaming
@@ -133,6 +134,17 @@ WHERE [c].[Region] IS NULL
 """);
     }
 
+    [ConditionalTheory, MemberData(nameof(IsAsyncData))]
+    public virtual async Task Collate_with_invalid_chars_throws(bool async)
+    {
+        using var context = CreateContext();
+
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => context.Customers.CountAsync(c => EF.Functions.Collate(c.ContactName, "Invalid]Collation") == "test"));
+
+        Assert.Equal(SqlServerStrings.InvalidCollationName("Invalid]Collation"), exception.Message);
+    }
+
     public override Task Least(bool async)
         => AssertTranslationFailed(() => base.Least(async));
 
diff --git a/src/efcore/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindMiscellaneousQuerySqlServerTest.cs b/src/efcore/test/EFCore.SqlServer.FunctionalTests/Query/NorthwindMiscellaneousQuerySqlServerTest.cs
@@ -3236,6 +3236,20 @@ FROM [Orders] AS [o]
 """);
     }
 
+    public override async Task Captured_variable_from_switch_case_pattern_matching(bool async)
+    {
+        await base.Captured_variable_from_switch_case_pattern_matching(async);
+
+        AssertSql(
+            """
+@customerId='ALFKI' (Size = 5) (DbType = StringFixedLength)
+
+SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
+FROM [Customers] AS [c]
+WHERE [c].[CustomerID] = @customerId
+""");
+    }
+
     public override async Task Subquery_member_pushdown_does_not_change_original_subquery_model(bool async)
     {
         await base.Subquery_member_pushdown_does_not_change_original_subquery_model(async);
diff --git a/src/efcore/test/EFCore.Sqlite.FunctionalTests/BuiltInDataTypesSqliteTest.cs b/src/efcore/test/EFCore.Sqlite.FunctionalTests/BuiltInDataTypesSqliteTest.cs
@@ -1476,7 +1476,7 @@ public virtual void Can_query_OrderBy_of_converted_types()
 SELECT "b"."Id"
 FROM "BuiltInDataTypes" AS "b"
 WHERE "b"."PartitionId" = 207
-ORDER BY "b"."TestDecimal" COLLATE EF_DECIMAL
+ORDER BY "b"."TestDecimal" COLLATE "EF_DECIMAL"
 LIMIT 1
 """);
 
@@ -1532,7 +1532,7 @@ public virtual void Can_query_ThenBy_of_converted_types()
 SELECT "b"."Id"
 FROM "BuiltInDataTypes" AS "b"
 WHERE "b"."PartitionId" = 208
-ORDER BY "b"."PartitionId", "b"."TestDecimal" COLLATE EF_DECIMAL
+ORDER BY "b"."PartitionId", "b"."TestDecimal" COLLATE "EF_DECIMAL"
 LIMIT 1
 """);
 
@@ -1591,7 +1591,7 @@ public virtual void Can_query_OrderBy_decimal_with_Turkish_culture()
             """
 SELECT "b"."Id", "b"."TestDecimal"
 FROM "BuiltInDataTypes" AS "b"
-ORDER BY "b"."TestDecimal" COLLATE EF_DECIMAL
+ORDER BY "b"."TestDecimal" COLLATE "EF_DECIMAL"
 """,
                 //
                 """
diff --git a/src/efcore/test/EFCore.Sqlite.FunctionalTests/Migrations/MigrationsSqliteTest.cs b/src/efcore/test/EFCore.Sqlite.FunctionalTests/Migrations/MigrationsSqliteTest.cs
diff --git a/src/source-manifest.json b/src/source-manifest.json

Original file line number	Diff line number	Diff line change
`@@ -1367,7 +1367,7 @@ protected virtual void ColumnDefinition(`
`1367`	`1367`	`{`
`1368`	`1368`	`builder`
`1369`	`1369`	`.Append(" COLLATE ")`
`1370`		`- .Append(operation.Collation);`
	`1370`	`+ .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Collation));`
`1371`	`1371`	`}`
`1372`	`1372`
`1373`	`1373`	`builder.Append(operation.IsNullable ? " NULL" : " NOT NULL");`
Original file line number	Diff line number	Diff line change
`@@ -733,9 +733,13 @@ protected override Expression VisitCollate(CollateExpression collateExpression)`
`733`	`733`	`{`
`734`	`734`	`Visit(collateExpression.Operand);`
`735`	`735`
	`736`	`+ // In some databases (e.g. SQL Server), collations aren't regular identifiers (like column or table names), and so shouldn't be`
	`737`	`+ // quoted. However, we still default to quoting to prevent cases where arbitrary collation name inputs get integrated into the SQL.`
	`738`	`+ // Providers which don't support quoting of collation names should override this method to provide sanitization logic,`
	`739`	`+ // e.g. throwing if the name contains any but a restricted set of characters.`
`736`	`740`	`_relationalCommandBuilder`
`737`	`741`	`.Append(" COLLATE ")`
`738`		`- .Append(collateExpression.Collation);`
	`742`	`+ .Append(_sqlGenerationHelper.DelimitIdentifier(collateExpression.Collation));`
`739`	`743`
`740`	`744`	`return collateExpression;`
`741`	`745`	`}`
Original file line number	Diff line number	Diff line change
`@@ -377,13 +377,13 @@ private IReadOnlyList<MigrationOperation> RewriteOperations(`
`377`	`377`	`// Skip autoincrement primary key columns that are being added in this migration`
`378`	`378`	`var isAutoincrement = column.FindAnnotation(SqliteAnnotationNames.Autoincrement)?.Value as bool? == true;`
`379`	`379`	`var isPrimaryKey = column.Table.PrimaryKey?.Columns.Contains(column) == true;`
`380`		`-`
	`380`	`+`
`381`	`381`	`if (isAutoincrement && isPrimaryKey)`
`382`	`382`	`{`
`383`	`383`	`// Check if this column is being added in the current migration`
`384`	`384`	`var isNewColumn = migrationOperations.OfType<AddColumnOperation>()`
`385`	`385`	`.Any(op => op.Table == key.Table && op.Schema == key.Schema && op.Name == column.Name);`
`386`		`-`
	`386`	`+`
`387`	`387`	`if (isNewColumn)`
`388`	`388`	`{`
`389`	`389`	`continue; // Skip newly added autoincrement columns`
`@@ -976,7 +976,7 @@ protected override void ComputedColumnDefinition(`
`976`	`976`	`{`
`977`	`977`	`builder`
`978`	`978`	`.Append(" COLLATE ")`
`979`		`- .Append(operation.Collation);`
	`979`	`+ .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Collation));`
`980`	`980`	`}`
`981`	`981`	`}`
`982`	`982`