diff --git a/entity-framework/core/what-is-new/ef-core-10.0/breaking-changes.md b/entity-framework/core/what-is-new/ef-core-10.0/breaking-changes.md new file mode 100644 index 0000000000..60384a3ae9 --- /dev/null +++ b/entity-framework/core/what-is-new/ef-core-10.0/breaking-changes.md @@ -0,0 +1,85 @@ +--- +title: Breaking changes in EF Core 10 (EF10) - EF Core +description: List of breaking changes introduced in Entity Framework Core 10 (EF10) +author: maumar +ms.date: 01/05/2025 +uid: core/what-is-new/ef-core-10.0/breaking-changes +--- + +# Breaking changes in EF Core 10 (EF10) + +This page documents API and behavior changes that have the potential to break existing applications updating from EF Core 9 to EF Core 10. Make sure to review earlier breaking changes if updating from an earlier version of EF Core: + +- [Breaking changes in EF Core 9](xref:core/what-is-new/ef-core-9.0/breaking-changes) +- [Breaking changes in EF Core 8](xref:core/what-is-new/ef-core-8.0/breaking-changes) +- [Breaking changes in EF Core 7](xref:core/what-is-new/ef-core-7.0/breaking-changes) +- [Breaking changes in EF Core 6](xref:core/what-is-new/ef-core-6.0/breaking-changes) + +## Summary + +| **Breaking change** | **Impact** | +|:----------------------------------------------------------------------------------------------------------|------------| +| [ExecuteUpdateAsync now accepts a regular, non-expression lambda](#ExecuteUpdateAsync-lambda) | Low | + +## Low-impact changes + + + +### ExecuteUpdateAsync now accepts a regular, non-expression lambda + +[Tracking Issue #32018](https://github.com/dotnet/efcore/issues/32018) + +#### Old behavior + +Previously, accepted an expression tree argument (`Expression>`) for the column setters. + +#### New behavior + +Starting with EF Core 10.0, now accepts a non-expression argument (`Func<...>`) for the column setters. If you were building expression trees to dynamically create the column setters argument, your code will no longer compile - but can be replaced with a much simpler alternative (see below). + +#### Why + +The fact that the column setters parameter was an expression tree made it quite difficult to do dynamic construction of the column setters, where some setters are only present based on some condition (see Mitigations below for an example). + +#### Mitigations + +Code that was building expression trees to dynamically create the column setters argument will need to be rewritten - but the result will be much simpler. For example, let's assume we want to update a Blog's Views, but conditionally also its Name. Since the setters argument was an expression tree, code such as the following needed to be written: + +```c# +// Base setters - update the Views only +Expression, SetPropertyCalls>> setters = + s => s.SetProperty(b => b.Views, 8); + +// Conditionally add SetProperty(b => b.Name, "foo") to setters, based on the value of nameChanged +if (nameChanged) +{ + var blogParameter = Expression.Parameter(typeof(Blog), "b"); + + setters = Expression.Lambda, SetPropertyCalls>>( + Expression.Call( + instance: setters.Body, + methodName: nameof(SetPropertyCalls.SetProperty), + typeArguments: [typeof(string)], + arguments: + [ + Expression.Lambda>(Expression.Property(blogParameter, nameof(Blog.Name)), blogParameter), + Expression.Constant("foo") + ]), + setters.Parameters); +} + +await context.Blogs.ExecuteUpdateAsync(setters); +``` + +Manually creating expression trees is complicated and error-prone, and made this common scenario much more difficult than it should have been. Starting with EF 10, you can now write the following instead: + +```c# +await context.Blogs.ExecuteUpdateAsync(s => +{ + s.SetProperty(b => b.Views, 8); + if (nameChanged) + { + s.SetProperty(b => b.Name, "foo"); + } +}); +``` diff --git a/entity-framework/core/what-is-new/ef-core-10.0/whatsnew.md b/entity-framework/core/what-is-new/ef-core-10.0/whatsnew.md new file mode 100644 index 0000000000..dcc6fecb37 --- /dev/null +++ b/entity-framework/core/what-is-new/ef-core-10.0/whatsnew.md @@ -0,0 +1,78 @@ +--- +title: What's New in EF Core 10 +description: Overview of new features in EF Core 10 +author: maumar +ms.date: 01/05/2025 +uid: core/what-is-new/ef-core-10.0/whatsnew +--- + +# What's New in EF Core 10 + +EF Core 10 (EF10) is the next release after EF Core 9 and is scheduled for release in November 2025. + +EF10 is available as [daily builds](https://github.com/dotnet/efcore/blob/main/docs/DailyBuilds.md) which contain all the latest EF10 features and API tweaks. The samples here make use of these daily builds. + +> [!TIP] +> You can run and debug into the samples by [downloading the sample code from GitHub](https://github.com/dotnet/EntityFramework.Docs). Each section below links to the source code specific to that section. + +EF10 requires the .NET 10 SDK to build and requires the .NET 10 runtime to run. EF10 will not run on earlier .NET versions, and will not run on .NET Framework. + +> [!TIP] +> The _What's New_ docs are updated for each preview. All the samples are set up to use the [EF10 daily builds](https://github.com/dotnet/efcore/blob/main/docs/DailyBuilds.md), which usually have several additional weeks of completed work compared to the latest preview. We strongly encourage use of the daily builds when testing new features so that you're not doing your testing against stale bits. + + + +## LINQ and SQL translation + + + +### Other query improvements + +* Translation for DateOnly.ToDateTime(timeOnly) ([#35194](https://github.com/dotnet/efcore/pull/35194), contributed by [@mseada94](https://github.com/mseada94)). +* Optimization for multiple consecutive `LIMIT`s ([#35384](https://github.com/dotnet/efcore/pull/35384)), contributed by [@ranma42](https://github.com/ranma42)). +* Optimization for use of `Count` operation on `ICollection` ([#35381](https://github.com/dotnet/efcore/pull/35381)), contributed by [@ChrisJollyAU](https://github.com/ChrisJollyAU)). + +## ExecuteUpdateAsync now accepts a regular, non-expression lambda + +The can be used to express arbitrary update operations in the database. In previous versions, the changes to be performed on the database rows were provided via an expression tree parameter; this made it quite difficult to build those changes dynamically. For example, let's assume we want to update a Blog's Views, but conditionally also its Name. Since the setters argument was an expression tree, code such as the following needed to be written: + +```c# +// Base setters - update the Views only +Expression, SetPropertyCalls>> setters = + s => s.SetProperty(b => b.Views, 8); + +// Conditionally add SetProperty(b => b.Name, "foo") to setters, based on the value of nameChanged +if (nameChanged) +{ + var blogParameter = Expression.Parameter(typeof(Blog), "b"); + + setters = Expression.Lambda, SetPropertyCalls>>( + Expression.Call( + instance: setters.Body, + methodName: nameof(SetPropertyCalls.SetProperty), + typeArguments: [typeof(string)], + arguments: + [ + Expression.Lambda>(Expression.Property(blogParameter, nameof(Blog.Name)), blogParameter), + Expression.Constant("foo") + ]), + setters.Parameters); +} + +await context.Blogs.ExecuteUpdateAsync(setters); +``` + +Manually creating expression trees is complicated and error-prone, and made this common scenario much more difficult than it should have been. Starting with EF 10, you can now write the following instead: + +```c# +await context.Blogs.ExecuteUpdateAsync(s => +{ + s.SetProperty(b => b.Views, 8); + if (nameChanged) + { + s.SetProperty(b => b.Name, "foo"); + } +}); +``` + +Thanks to [@aradalvand](https://github.com/aradalvand) for proposing and pushing for this change (in [#32018](https://github.com/dotnet/efcore/issues/32018)).