Update What's New for .NET 10 with P3 info (#45765)

* Update What's New for .NET 10 with P3 info
Fixes #45656

* lint

* Preview 3, d'oh!

* sentence case

* Review feedback

Author: Cam Soper

docs/core/whats-new/dotnet-10/libraries.md

@@ -2,14 +2,14 @@
 title: What's new in .NET libraries for .NET 10
 description: Learn about the new .NET libraries features introduced in .NET 10.
 titleSuffix: ""
-ms.date: 03/18/2025
+ms.date: 04/09/2025
 ms.topic: whats-new
 ai-usage: ai-assisted
 ---
 
 # What's new in .NET libraries for .NET 10
 
-This article describes new features in the .NET libraries for .NET 10. It's updated for Preview 2.
+This article describes new features in the .NET libraries for .NET 10. It's updated for Preview 3.
 
 ## Find certificates by thumbprints other than SHA-1
 
@@ -133,7 +133,7 @@ When you use source generators for JSON serialization, the generated context thr
 
 ## More left-handed matrix transformation methods
 
-.NET 10 adds the remaining APIs for creating left-handed transformation matrices for billboard and constrained-billboard matrices. You can use these methods like their existing right-handed counterparts [add xrefs to the existing counterparts] when using a left-handed coordinate system instead.
+.NET 10 adds the remaining APIs for creating left-handed transformation matrices for billboard and constrained-billboard matrices. You can use these methods like their existing right-handed counterparts <xref:System.Numerics.Matrix4x4.CreateBillboard(System.Numerics.Vector3,System.Numerics.Vector3,System.Numerics.Vector3,System.Numerics.Vector3)> and <xref:System.Numerics.Matrix4x4.CreateConstrainedBillboard(System.Numerics.Vector3,System.Numerics.Vector3,System.Numerics.Vector3,System.Numerics.Vector3,System.Numerics.Vector3)> when using a left-handed coordinate system instead.
 
 ```csharp
 public partial struct Matrix4x4
@@ -150,3 +150,68 @@ The new `ExportPkcs12` <!--TODO: add xref --> methods on <xref:System.Security.C
 which produces an output supported by almost every library/platform that supports reading PKCS#12/PFX by choosing an older encryption algorithm. `Pkcs12ExportPbeParameters.Pbes2Aes256Sha256` <!--TODO: add xref --> indicates that AES should be used instead of 3DES (and SHA-2-256 instead of SHA-1), but the output may not be understood by all readers (such as Windows XP).
 
 Callers who want even more control can instead utilize the overload that accepts a <xref:System.Security.Cryptography.PbeParameters>.
+
+## New AOT-safe constructor for `ValidationContext`
+
+The <xref:System.ComponentModel.DataAnnotations.ValidationContext> class, used during options validation, now includes a new constructor that explicitly accepts the `displayName` parameter. This ensures AOT safety, allowing its use in native builds without warnings:
+
+```csharp
+public sealed class ValidationContext
+{
+    public ValidationContext(object instance,
+        string displayName, 
+        IServiceProvider? serviceProvider = null, 
+        IDictionary<object, object?>? items = null);
+}
+```
+
+## Support for telemetry schema URLs in `ActivitySource` and `Meter`
+
+<xref:System.Diagnostics.ActivitySource> and <xref:System.Diagnostics.Metrics.Meter> now support specifying a telemetry schema URL during construction, aligning with OpenTelemetry specifications. This ensures consistency and compatibility for tracing and metrics data. Additionally, the update introduces `ActivitySourceOptions`, simplifying the creation of <xref:System.Diagnostics.ActivitySource> instances with multiple configuration options.
+
+```csharp
+public sealed partial class ActivitySource
+{
+    public ActivitySource(ActivitySourceOptions options);
+    public string? TelemetrySchemaUrl { get; }
+}
+
+public class ActivitySourceOptions
+{
+    public ActivitySourceOptions(string name);
+    public string Name { get; set; }
+    public string? Version { get; set; }
+    public IEnumerable<KeyValuePair<string, object?>>? Tags { get; set; }
+    public string? TelemetrySchemaUrl { get; set; }
+}
+
+public partial class Meter : IDisposable
+{
+    public string? TelemetrySchemaUrl { get; }
+}
+```
+
+## Byte-level support in BPE tokenizer
+
+The <xref:Microsoft.ML.Tokenizers.BpeTokenizer> now supports byte-level encoding, enabling compatibility with models like DeepSeek. This enhancement processes vocabulary as UTF-8 bytes. In addition, the new `BpeOptions` type simplifies tokenizer configuration.
+
+```csharp
+BpeOptions bpeOptions = new BpeOptions(vocabs);
+BpeTokenizer tokenizer = BpeTokenizer.Create(bpeOptions);
+```
+
+## Deterministic option for LightGBM trainer in ML.NET
+
+LightGBM trainers now expose options for deterministic training, ensuring consistent results with the same data and random seed. These options include `deterministic`, `force_row_wise`, and `force_col_wise`.
+
+```csharp
+LightGbmBinaryTrainer trainer = ML.BinaryClassification.Trainers.LightGbm(new LightGbmBinaryTrainer.Options
+{
+    Deterministic = true,
+    ForceRowWise = true
+});
+```
+
+## Tensor enhancements
+
+The <xref:System.Numerics.Tensors.Tensor> class now includes a nongeneric interface for operations like accessing `Lengths` and `Strides`. Slice operations no longer copy data, improving performance. Additionally, data can be accessed nongenerically by boxing to `object` when performance isn't critical.

docs/core/whats-new/dotnet-10/overview.md

@@ -2,14 +2,14 @@
 title: What's new in .NET 10
 description: Learn about the new features introduced in .NET 10 for the runtime, libraries, and SDK. Also find links to what's new in other areas, such as ASP.NET Core.
 titleSuffix: ""
-ms.date: 03/18/2025
+ms.date: 04/09/2025
 ms.topic: whats-new
 ai-usage: ai-assisted
 ---
 
 # What's new in .NET 10
 
-Learn about the new features in .NET 10 and find links to further documentation. This page is updated for Preview 2.
+Learn about the new features in .NET 10 and find links to further documentation. This page is updated for Preview 3.
 
 .NET 10, the successor to [.NET 9](../dotnet-9/overview.md), is [supported for three years](https://dotnet.microsoft.com/platform/support/policy/dotnet-core) as a long-term support (LTS) release. You can [download .NET 10 here](https://get.dot.net/10).
 
@@ -82,13 +82,21 @@ The ASP.NET Core 10.0 release introduces several new features and enhancements,
 - **Minimal APIs**:
   - Improved integration testing for apps using top-level statements.
   - Empty strings in form posts are now treated as `null` for nullable value types.
+  - Built-in validation support for query, header, route parameters, and request bodies, with customizable behavior.
 
 - **Authentication and authorization**:
   - Added new metrics for authentication and authorization events.
 
 - **Miscellaneous**:
   - Added the `RedirectHttpResult.IsLocalUrl` helper method for detecting local URLs.
   - Added support for route syntax highlighting in the <xref:Microsoft.AspNetCore.Components.RouteAttribute>.
+  - New `TypedResults.ServerSentEvents` API for streaming event messages to clients in minimal APIs and controller-based apps.
+  - Declarative state persistence simplifies state persistence in components and services during prerendering using the `SupplyParameterFromPersistentComponentState` attribute.
+  - Standalone Blazor WebAssembly apps now support referencing fingerprinted static web assets and import maps.
+  - <xref:System.Net.Http.HttpClient> response streaming is enabled by default on WebAssembly, improving performance and reducing memory usage for large responses.
+  - The app context switch `DisableMatchAllIgnoresLeftUriPart` is now renamed to `EnableMatchAllForQueryStringAndFragment`.
+  - Specify the environment for standalone Blazor WebAssembly apps at build time using the `<WasmApplicationEnvironmentName>` property.
+  - The ASP.NET Core Web API (native AOT) template now includes OpenAPI support by default.
 
 For more information, see [What's new in ASP.NET Core for .NET 10](/aspnet/core/release-notes/aspnetcore-10.0).
 
@@ -102,6 +110,8 @@ C# 14 introduces several new features and enhancements to improve developer prod
 - **Modifiers on simple lambda parameters**: Allows parameter modifiers like `ref`, `in`, or `out` in lambda expressions without specifying parameter types.
 - **Experimental feature - String literals in data section**: Enables emitting string literals as UTF-8 data into a separate section of the PE file, improving efficiency for certain scenarios.
 - **Partial events and constructors**: Adds support for partial instance constructors and partial events, complementing partial methods and properties introduced in C# 13.
+- **Extension members**: Extension methods now support static methods, instance properties, and static properties through `extension` blocks, enabling more flexible and powerful extensions.
+- **Null-conditional assignment**: Simplifies conditional assignments by allowing properties or fields to be updated only if the containing instance exists, using the `?.` operator.
 
 For more information, see [What's new in C# 14](../../../csharp/whats-new/csharp-14.md).
 
@@ -116,10 +126,19 @@ The .NET MAUI updates in .NET 10 include several new features and quality improv
   - Added `Switch.OffColor` for customizing the color of the `Switch` control when off.
   - Added `SearchBar.SearchIconColor` for customizing the search icon color.
   - New `HybridWebView.InvokeJavascriptAsync` method for invoking JavaScript without requiring generic arguments.
+  - Support for fullscreen video playback in `WebView` on Android when the `iframe` includes `allowfullscreen`.
+  - Added `Geolocation.IsEnabled` to check if geolocation services are enabled without requesting location details.
+  - A `CancellationToken` can now be passed to `WebAuthenticator.AuthenticateAsync` for programmatically canceling authentication.
 
 - **Deprecations**:
   - The `FontImageExtension` XAML markup extension is deprecated. Use `FontImageSource` instead.
   - `MessagingCenter` is now internal. Replace it with `WeakReferenceMessenger` from the `CommunityToolkit.Mvvm` package.
+  - Deprecation of `ListView`, `Cell`, and `TableView`, which will be removed in a future release.
+
+- **Performance improvements**:
+  - Property mapping improvements with new caching and optimized property application order, reducing race conditions and repetitive calls.
+  - CollectionView optimizations on iOS, eliminating `MeasureInvalidated` subscriptions and improving templated cell responsiveness.
+  - Optimized `Label` rendering for `FormattedString` on Windows, achieving a ~56% performance improvement.
 
 - **.NET for Android**:
   - Support for Android 16 (API-36) Beta 1.
@@ -132,6 +151,7 @@ The .NET MAUI updates in .NET 10 include several new features and quality improv
 - **.NET for iOS, Mac Catalyst, macOS, tvOS**:
   - Trimmer warnings are now enabled by default.
   - Bundling of original resources in libraries is now opt-out.
+  - Support for Xcode 16.3 Release Candidate
 
 For more information, see [What's new in .NET MAUI in .NET 10](/dotnet/maui/whats-new/dotnet-10).
 
@@ -152,10 +172,18 @@ The EF Core 10 release introduces several new features and improvements, includi
   - Enhanced performance for `Count` operations on `ICollection<T>`.
   - Optimized `MIN`/`MAX` operations over `DISTINCT`.
 
+- **Improved experience with Azure Cosmos DB for NoSQL**:
+  - EF Core now materializes a default value for required properties when no data is present in the document, simplifying model evolution.
+
+- **Small improvements**:
+  - Redacted inlined constants from logs when sensitive logging is off.
+  - Enhanced <xref:Microsoft.Data.Sqlite.SqliteConnection.LoadExtension(System.String,System.String)> to work correctly with `dotnet run` and libraries named with `lib*`.
+
 - **Miscellaneous**:
   - Simplified parameter names in SQL queries (for example, from `@__city_0` to `city`).
   - Added translation for date/time functions using `DatePart.Microsecond` and `DatePart.Nanosecond`.
   - Made SQL Server scaffolding compatible with Azure Data Explorer.
+  - Additional minor bug fixes and improvements.
 
 For more information, see [What's new in EF Core for .NET 10](/ef/core/what-is-new/ef-core-10.0/whatsnew).
 
@@ -211,19 +239,21 @@ The WPF updates in .NET 10 include several performance improvements, Fluent styl
   - Replaced data structures like `PartialList` with `ReadOnlyCollection` to enhance performance.
   - Optimized UI automation and file dialog operations to minimize allocations.
   - Improved pixel format conversion performance.
+  - Enhanced performance by optimizing cache operations and array handling.
+  - Migrated font collection loader to managed code.
 
 - **Fluent style changes**:
   - Updated the default style for `Label`.
   - Fixed animation issues for `Expander` by adjusting a `KeyTime` value.
+  - Introduced new Fluent styles for controls, including `NavigationWindow`, `Frame`, `ToolBar`, `ResizeGrip`, `GroupBox`, `Hyperlink`, `GridSplitter`, and `Thumb`.
+  - Fixed elevation border brushes for various controls.
+  - Corrected missing `RecognizesAccessKey` property.
 
 - **Bug fixes**:
   - Resolved issues with UI element cursor types and crashes when bitmap streams are null.
   - Fixed localization issues for `ScrollViewer` and `ContextMenu`.
   - Addressed minor bugs in `BitmapMetadata` and native dependencies.
-
-- **Engineering health**:
-  - Updated and synchronized **MilCodeGen** across WPF components.
-  - Removed deprecated .NET runtime references and unnecessary package dependencies.
-  - Conducted style cleanups and disabled code analysis for generated code to streamline builds.
+  - Addressed memory leaks, control behavior anomalies, and property recognition issues.
+  - Fixed faulty caching of `LinearGradientBrushes` when `RelativeTransform` was used with `Absolute` mapping mode.
 
 For more information, see [What's new in WPF in .NET 10](/dotnet/desktop/wpf/whats-new/net100).

docs/core/whats-new/dotnet-10/runtime.md

@@ -2,13 +2,13 @@
 title: What's new in .NET 10 runtime
 description: Learn about the new .NET features introduced in the .NET 10 runtime.
 titleSuffix: ""
-ms.date: 03/18/2025
+ms.date: 04/09/2025
 ms.topic: whats-new
 ai-usage: ai-assisted
 ---
 # What's new in the .NET 10 runtime
 
-This article describes new features and performance improvements in the .NET runtime for .NET 10. It's updated for Preview 2.
+This article describes new features and performance improvements in the .NET runtime for .NET 10. It's updated for Preview 3.
 
 ## Array interface method devirtualization
 
@@ -60,9 +60,9 @@ The JIT can now inline methods that become eligible for devirtualization due to
 
 During inlining, the JIT now updates the type of temporary variables holding return values. If all return sites in a callee yield the same type, this precise type information is used to devirtualize subsequent calls. This enhancement complements the improvements in late devirtualization and array enumeration de-abstraction. For more information, see [dotnet/runtime #111948](https://github.com/dotnet/runtime/pull/111948).
 
-## Stack allocation of arrays of value types
+## Stack allocation of small arrays of value types
 
-In .NET 9, the JIT gained the ability to allocate objects on the stack, when the object is guaranteed to not outlive its parent method. Not only does stack allocation reduce the number of objects the GC has to track, but it also unlocks other optimizations. For example, after an object is stack-allocated, the JIT can consider replacing it entirely with its scalar values. Because of this, stack allocation is key to reducing the abstraction penalty of reference types.
+In .NET 9, the JIT gained the ability to allocate objects on the stack when the object is guaranteed to not outlive its parent method. Not only does stack allocation reduce the number of objects the GC has to track, but it also unlocks other optimizations. For example, after an object is stack-allocated, the JIT can consider replacing it entirely with its scalar values. Because of this, stack allocation is key to reducing the abstraction penalty of reference types.
 
 In .NET 10, the JIT now stack-allocates small, fixed-sized arrays of value types that don't contain GC pointers when it can make the same lifetime guarantees described previously. Consider the following example:
 
@@ -83,6 +83,29 @@ static void Sum()
 
 Because the JIT knows `numbers` is an array of only three integers at compile time, and it doesn't outlive a call to `Sum`, it allocates it on the stack.
 
+## Stack allocation of small arrays of reference types
+
+Building on the stack allocation improvements introduced in .NET 9, .NET 10 extends this optimization to small arrays of reference types. Previously, arrays of reference types were always allocated on the heap, even when their lifetime was scoped to a single method. Now, the JIT can stack-allocate such arrays when it determines that they don't outlive their creation context. For example:
+
+```csharp
+static void Print()
+{
+    string[] words = {"Hello", "World!"};
+    foreach (var str in words)
+    {
+        Console.WriteLine(str);
+    }
+}
+```
+
+In this example, the array `words` is now allocated on the stack, eliminating heap allocations entirely. This reduces GC pressure and improves performance.
+
+## Improved code layout
+
+The JIT compiler in .NET 10 introduces a new approach to organizing method code into basic blocks for better runtime performance. Previously, the JIT used a reverse postorder (RPO) traversal of the program's flowgraph as an initial layout, followed by iterative transformations. While effective, this approach had limitations in modeling the trade-offs between reducing branching and increasing hot code density.
+
+In .NET 10, the JIT models the block reordering problem as a reduction of the asymmetric Travelling Salesman Problem and implements the 3-opt heuristic to find a near-optimal traversal. This optimization improves hot path density and reduces branch distances, resulting in better runtime performance. For more details, see [dotnet/runtime #107749](https://github.com/dotnet/runtime/issues/107749).
+
 ## AVX10.2 support
 
 .NET 10 introduces support for the Advanced Vector Extensions (AVX) 10.2 for x64-based processors. The new intrinsics available in the <xref:System.Runtime.Intrinsics.X86.Avx10v2?displayProperty=fullName> class can be tested once capable hardware is available.