.NET 10 – New Features and Enhancements

By the end of 2025, Microsoft plans to release .NET 10 as a Long-Term Support (LTS) release (targeted for November 2025). The preview versions of .NET 10 are already available, giving developers a glimpse of upcoming improvements. In this 5-minute overview, we’ll explore the key new features and enhancements in .NET 10 – spanning runtime performance, libraries, C# 14 language updates, and major framework innovations across ASP.NET Core, Entity Framework Core, WPF, and WinForms.

.NET 10 Runtime – Performance and Optimization

.NET 10 introduces several runtime improvements focused on performance and efficiency. The Just-In-Time (JIT) compiler has been enhanced with smarter method inlining, de-virtualization, and loop optimizations, resulting in faster execution of hot code paths. Notably, .NET 10 can de-virtualize interface calls on arrays and inline those methods, reducing overhead for common collections. Small arrays (of certain value types) are now allocated on the stack instead of the heap, eliminating some garbage collection (GC) pressure. This stack allocation for fixed-size arrays, including small reference-type arrays that don’t outlive their scope, helps reduce GC frequency and improves memory efficiency for short-lived data.

The runtime also adds support for AVX 10.2 CPU instructions (Advanced Vector Extensions). While this hardware support is forward-looking (pending compatible processors), it paves the way for accelerated numeric, AI, and graphics computations on future CPUs. In the meantime, .NET 10’s JIT and code generation enhancements (like improved code layout and basic block reordering) optimize hot path density and shorten branch distances, yielding speedups for compute-intensive and long-running applications.

Garbage collection has been fine-tuned as well. .NET 10’s background GC is optimized to reduce memory fragmentation via better compaction, which lowers latency spikes in real-world applications. Overall, the runtime enhancements in .NET 10 emphasize throughput, lower latency, and making high-level .NET features cost less in terms of execution overhead.

.NET 10 Library Enhancements

On top of runtime gains, .NET 10 brings a slew of new APIs and library improvements aimed at developer productivity, performance, and security:

• Span/Memory APIs: New APIs for working with Span<T> and ReadOnlySpan<T> help reduce unnecessary allocations. For example, .NET 10 introduces string normalization methods that operate on spans (e.g. GetNormalizedLength, IsNormalized, TryNormalize for ReadOnlySpan<char>) to efficiently handle Unicode normalization without creating new string instances.

• Collections and Data: The ZipArchive API has been optimized – it now loads only needed entries into memory instead of all entries, greatly improving performance when reading or modifying ZIP files. The OrderedDictionary<TKey, TValue> collection gets new overloads like TryAdd and TryGetValue that provide the index of inserted/retrieved items, simplifying usage in certain scenarios. A new AOT-safe constructor is added to ValidationContext (for attribute-based validation) to better support ahead-of-time compilation.

• Globalization & Text: .NET 10 finally introduces numeric string comparison support. With the new CompareOptions.NumericOrdering flag in string comparison, you can compare strings “numerically” rather than lexicographically. This means, for example, "10" will be considered greater than "2" when sorting strings with numeric content, aligning with human expectations. Simply create a StringComparer with CompareOptions.NumericOrdering to sort strings like numbers instead of Unicode code points. This feature is highly anticipated for scenarios like sorting version numbers or file names with numerical parts.

• JSON and Serialization: The built-in JSON serialization (System.Text.Json) gets stricter and more flexible. New options allow disallowing duplicate property names in JSON payloads and enabling strict serialization settings for better security. .NET 10’s libraries also expand post-quantum cryptography support (integration with Windows CNG), preparing .NET apps for the future of cryptographic algorithms.

• Time & Date: A new overload for TimeSpan.FromMilliseconds(long) is introduced, which takes a single parameter (milliseconds) without needing a second, optional microseconds parameter. This simplifies creating TimeSpan values from millisecond counts in C# 14.

In summary, .NET 10’s library updates span performance boosts (ZipArchive, collections), globalization improvements (numeric string sorting), and convenience APIs that reduce boilerplate (e.g. new span and TimeSpan methods). These enhancements aim to make code faster and easier to write correctly.

C# 14 – Language Features in .NET 10

Alongside the runtime and libraries, .NET 10 ships with C# 14, which brings many language improvements to boost productivity and code clarity. Some highlights include:

• Field-Backed Properties: You can now seamlessly transition from auto-properties to custom property accessors using the new field keyword. The compiler provides a backing field for auto-properties, accessible via the contextual keyword field inside your get/set. This means you can write a property and in the setter use field = value to refer to the underlying storage. For example:

public string Address { get; set => field = value ?? throw new ArgumentNullException(nameof(value)); }

• This ensures Address is never set to null, without manually declaring a private field. This feature makes property code more concise and maintainable.

• Lambda Expression Enhancements: C# 14 allows lambda parameters to have modifiers like ref, in, out, etc., without explicitly specifying types. In previous C# versions, to use out parameters in lambdas (for example, a TryParse pattern), you had to explicitly type the parameters. Now you can write:

TryParse<int> parseInt = (string text, out int result) => int.TryParse(text, out result); // or even omit types: TryParse<int> parseInt2 = (text, out result) => int.TryParse(text, out result);

• This makes lambdas more flexible and readable, especially when using out parameters or ref locals in functional patterns.

• Partial Constructors and Events: Building on C#’s partial class capability, you can now declare partial constructors and partial events across partial class definitions. This lets you separate a class’s construction logic or event hookup logic into multiple files for clarity or generated code scenarios. A partial constructor is declared in one part and implemented in another, similar to partial methods. Partial events allow splitting the event definition (the delegate and name) from its add/remove accessor implementations. These features are mainly useful in code generation or separating concerns in large classes.

• Null-Conditional Assignment: A small but handy addition – you can use the ?. operator on the left-hand side of assignments. For example:

employee?.DepartmentId = GetDepartmentId(empId);

• This will assign a DepartmentId if employee is not null, and do nothing if employee is null. Previously, such null-checks required a verbose if (employee != null) { employee.Prop = ...; }. This feature reduces boilerplate null checks, making code cleaner and less error-prone.

• Implicit Span Conversions: C# 14 provides first-class support for Span<T> and ReadOnlySpan<T> by allowing implicit conversions from regular arrays, stackalloc memory, string (to ReadOnlySpan<char>), and pointers to these span types. You can now directly assign an array to a Span<T> variable without calling MemoryExtensions.AsSpan, improving performance and readability when working with spans. For example, ReadOnlySpan<string> span = myStringArray; is now valid.

• Other Notable Features: The nameof operator now works with unbound generic types (e.g. nameof(List<>) yields "List" without needing a type argument). C# 14 also introduces extension members via extension static classes (allowing static extension methods and even extension properties in a special extension block), as well as user-defined operators enhancements (like custom +=/-= or ++/-- operators). These advanced features further empower library authors and advanced scenarios, though they are less commonly used in everyday code.

C# 14 is packed with features that smooth out rough edges (like the field keyword and lambda improvements) and give developers more expressive power. To try these out in Visual Studio, remember to set your project’s <LangVersion>preview</LangVersion> or use the latest Roslyn compiler with .NET 10.

Entity Framework Core 10 – Data Access Improvements

Entity Framework Core 10 (EF Core 10) comes alongside .NET 10 with many enhancements to make database interactions more powerful and flexible. EF Core 10 is tied to .NET 10’s release schedule (also expected in November 2025, and currently in preview). Key new features in EF Core 10 include:

• LINQ Enhancements – Left Join & Right Join: Writing LINQ queries that translate to left outer joins has historically been tricky in EF. In .NET 10, the LINQ API gains first-class support for LeftJoin and RightJoin extension methods, making those queries much simpler to write and comprehend. EF Core 10 recognizes these new methods and can translate them to SQL directly, so developers no longer need workarounds for outer joins.

• Full-Text Search for Azure Cosmos DB: Azure Cosmos DB (NoSQL) now supports full-text search on text fields, and EF Core 10 lights up this feature for your applications. You can mark certain string properties as full-text searchable and use new EF.Functions.FullTextContains (and related functions) in LINQ queries to perform rich text search queries against Cosmos DB. This allows efficient searching of text content stored in Cosmos, with ranking by relevance. Even more powerfully, EF Core 10 supports hybrid search, combining full-text search with vector similarity search for AI scenarios (using the EF.Functions.Rrf – Reciprocal Rank Fusion – to blend text relevance and vector distance in queries). These additions enable sophisticated search capabilities in Cosmos DB-backed applications.

• Stored Procedure Mapping for CUD: In earlier versions, using stored procedures for insert/update/delete (CUD) operations required extra work. EF Core 10 makes it easier by providing fluent APIs to map CUD operations to stored procedures. For example, in your model configuration you can do:

modelBuilder.Entity<Person>() .InsertUsingStoredProcedure("Person_Insert") .UpdateUsingStoredProcedure("Person_Update") .DeleteUsingStoredProcedure("Person_Delete");

• You can specify parameters and result mappings in code, and EF will call those sprocs instead of generating SQL for those operations. This simplifies integration with databases where CUD must go through stored procs (common in some enterprise scenarios).

• ExecuteUpdate with Regular Lambdas: EF Core 10 improves the recently introduced bulk update feature. The ExecuteUpdateAsync method now accepts a regular lambda for setting property values (with full C# support inside), instead of requiring an expression tree. In EF Core 7/8, to use conditional logic in an update, one had to manually build expression trees – which was cumbersome. Now you can write natural code inside an ExecuteUpdateAsync lambda, including if statements or loops, and EF will perform the batch update accordingly. This makes bulk updates (and deletes via ExecuteDeleteAsync) far easier to use, especially when updating multiple properties or conditionally updating rows.

• Other EF Core 10 Features: EF 10 introduces named query filters to allow multiple global query filters on an entity (each can be turned on/off by name), improving multi-tenancy and soft-delete scenarios. There are also improvements to evolving Cosmos DB schemas – if you add a new required property, EF can now supply a default for older documents instead of throwing, easing incremental model changes. EF Core 10 also removes the experimental tag from vector search (making it fully supported) and adds minor enhancements like more translated string functions, better SQLite support for decimal max/min, etc.

Overall, EF Core 10 focuses on enabling more advanced querying scenarios and smoothing out pain points in data access. Developers can leverage these to build richer search features and maintain legacy database patterns more easily.

ASP.NET Core 10 – Modern Web Development Features

ASP.NET Core 10 (which includes updates to Blazor, SignalR, Minimal APIs, and more) brings a wave of enhancements to make web apps more efficient and. Here are some of the most significant ASP.NET Core 10 improvements:

• Blazor Enhancements: Blazor (for web UI with .NET) gets many quality-of-life updates. The built-in QuickGrid component (for data grids) now supports a RowClass parameter to apply CSS classes to rows conditionally (e.g., highlight rows based on data). There’s also a new CloseColumnOptionsAsync API to programmatically close a column’s filter/menu UI – useful when building custom filter widgets. Under the hood, Blazor WebAssembly apps now preload framework static assets using <link rel="preload"> headers, which can speed up initial load times by telling the browser to fetch Blazor’s JS and WASM files early. The Blazor WebAssembly project template was updated to use an import map for these preloaded assets. Additionally, Blazor’s default reconnect UI (for Server) is now customizable via a provided ReconnectModal component, giving developers control over how to handle lost connections more gracefully.

• Minimal APIs – Input Validation: One of the coolest additions in ASP.NET Core 10 is first-class validation support in minimal APIs. You can now have your minimal API endpoints automatically validate incoming data (from body, query, headers) based on validation attributes or custom validators, similar to what MVC [Binders + DataAnnotations] could do. This is enabled by calling builder.Services.AddValidation() in your Program.cs, which wires up a validation filter for minimal routes. For example, if your DTO has [Required] or [StringLength] attributes, the framework will produce a HTTP 400 response with problem details if the model is invalid, without you writing manual checks. You can also integrate fluent validation by registering an IValidator<T> for your model. If needed, validation can be disabled on a per-endpoint basis (using .DisableValidation() in the route builder). This feature greatly simplifies handling of bad requests, making minimal APIs more robust out-of-the-box.

• OpenAPI/Swagger Improvements: ASP.NET Core’s built-in OpenAPI support is upgraded to OpenAPI 3.1 (with full JSON Schema 2020-12 support). The default generated swagger documents now use the new specification, which among other things means nullable: true is replaced by proper JSON Schema types, ensuring better compatibility with tools. You can still target OpenAPI 3.0 if needed via options, but 3.1 is now the default for .NET 10. Additionally, ASP.NET Core 10 can serve the OpenAPI spec in YAML format for those who prefer YAML over JSON. Simply map an endpoint with a .yaml path (e.g. app.MapOpenApi("/openapi/v1.yaml")) and the swagger middleware will output YAML. Other OpenAPI refinements include improved support for XML comments (you can include documentation from external assemblies by adding their XML docs to the Swagger generation), and a switch from OpenApiObject to JsonObject in the internals of example generation (for those customizing Swagger docs in code, this is a breaking change but aligns with the new spec). Overall these changes lead to richer and more correct API documentation with less hassle.

• HTTP APIs and Networking: ASP.NET Core 10 adds built-in support for JSON Patch using System.Text.Json. A new NuGet package Microsoft.AspNetCore.JsonPatch.SystemTextJson provides a JsonPatchDocument<T> that works with the modern JSON library (previously JSON Patch was tied to Newtonsoft.Json). This means you can accept patch documents and apply them to your models using patchDoc.ApplyTo(model) with full support for JSON Patch operations (add, remove, replace, etc.), all without pulling in a third-party serializer. Another notable addition is support for Server-Sent Events (SSE) responses. Minimal APIs and controllers can now return a TypedResults.ServerSentEvents(...) result, streaming data to web clients that accept SSE. This makes real-time one-way updates (like live notifications or feed updates) easier to implement natively, complementing SignalR’s two-way WebSocket capabilities.

• Other Web Improvements: For API controllers using [ProducesResponseType] or [Produces] attributes, you can now include a description for response types. This allows adding human-readable notes to your Swagger responses (e.g., description of what a 200 OK contains) directly in the attribute, improving API documentation. Authentication and Authorization also see some tweaks: additional metrics are exposed (such as counters for authentication challenges, sign-ins, and duration of auth events) to help monitor and profile auth in your app. ASP.NET Core Identity now supports passkeys (WebAuthn/FIDO2) for passwordless login, which is an important step towards more secure authentication (especially relevant as an LTS platform feature). Lastly, a small helper RedirectHttpResult.IsLocalUrl(url) was added – it helps safely determine if a given URL is local, to avoid open redirect vulnerabilities when redirecting users.

In summary, ASP.NET Core 10 focuses on developer ergonomics (validation, improved OpenAPI), modern web standards (passkeys, SSE), and performance (Blazor preloading, memory pool optimizations in servers). Whether you build APIs or interactive web UIs, there are plenty of enhancements to make your life easier and your apps faster.

Desktop: WPF 10 and Windows Forms 10 Updates

Even desktop developers get some love in .NET 10:

• WPF 10: Windows Presentation Foundation in .NET 10 mainly delivers performance improvements and updated Fluent styling. Common controls like Label, Hyperlink, GroupBox, GridSplitter, and NavigationWindow gain refreshed Fluent styles out-of-the-box to better match modern Windows UI guidelines. Under the hood, WPF benefits from optimizations such as moving certain font collection operations to managed code and improving internal array handling, which can reduce load times and memory usage. Many bug fixes have been included as well, focusing on memory leaks and stability. While no major new WPF-specific features were added, these fixes and style updates ensure WPF applications run more smoothly on .NET 10.

• Windows Forms 10: WinForms continues to modernize in .NET 10 with improvements for both developers and users. The WinForms designer in Visual Studio has been enhanced for better performance, and there’s improved interoperability with modern input and accessibility tools. Notably, WinForms and WPF now share a common clipboard implementation, making it easier to copy data between these frameworks consistently. There have been accessibility improvements (better screen reader support for controls, including popular screen readers like NVDA). WinForms also added new APIs for JSON-based object serialization (as part of removing the old BinaryFormatter usage). This aligns with Microsoft’s security push while making it easier to save and load UI state in a modern, interoperable format. These enhancements help keep WinForms applications feel up-to-date and secure on the latest runtime.

Conclusion and Takeaways

.NET 10 is shaping up to be a major LTS release, emphasizing stability, performance, and modern developer experiences. With its runtime optimizations and memory enhancements, applications are expected to run faster and more efficiently than on prior versions. The new language features in C# 14 make it easier to write clean, safe, and concise code – reducing boilerplate around null checks, property backing fields, and more. Framework and library improvements (spanning ASP.NET Core’s web development, EF Core’s data access, and even desktop tech) provide developers with powerful tools out-of-the-box, from automatic request validation in minimal APIs to robust search in Cosmos DB, to improved UI frameworks.

As an LTS, .NET 10 will be supported for three years, making it an attractive target for enterprise adoption once it stabilizes. Microsoft’s investment in areas like AOT (Ahead-Of-Time compilation, hinted by NativeAOT enhancements) and cloud-native tooling (container image creation built into the SDK, etc.) further indicates that .NET 10 is geared toward modern app deployment and performance at scale.

For developers, now is a great time to download the .NET 10 preview and start experimenting with these features. Whether it’s trying out new C# 14 syntax, validating your APIs with minimal code, or measuring the performance gains in your scenario, early adoption can provide valuable feedback and preparation for the full release. .NET 10’s improvements aim to make our .NET applications faster, leaner, and more expressive – ensuring that as the technology landscape evolves, .NET remains a productive and forward-looking platform for the next generation of apps.