.NET 10 and C# 14 is out today (November 11, 2025).

As a Long-Term Support (LTS) release, .NET 10 will receive three years of support until November 14, 2028. This makes it a solid choice for production applications that need long-term stability.

In this post, we will explore:

• What's New in .NET 10
• What's New in C# 14
• What's New in ASP.NET Core in .NET 10
• What's New in EF Core 10
• Other Changes in .NET 10

Let's dive in!

The biggest addition in .NET 10 is support for file-based apps. This feature changes how you can write C# code for scripts and small utilities.

Traditionally, even the simplest C# application required three things: a solution file (sln), a project file (csproj), and your source code file (*.cs). You would then use your IDE or the dotnet run command to build and run the app.

Starting with .NET 10, you can create a single *.cs file and run it directly:

bash
1dotnet run main.cs

This puts C# on equal with Python, JavaScript, TypeScript and other scripting languages. This makes C# a good option for CLI utilities, automation scripts, and tooling, without a project setup.

File-based apps can reference NuGet packages and SDKs using special # directives at the top of your file. This lets you include any library you need without a project file.

You can even create a single-file app that uses EF Core and runs a Minimal API:

csharp
1#:sdk Microsoft.NET.Sdk.Web
2#:package [email protected]
3
4using Microsoft.EntityFrameworkCore;
5
6var builder = WebApplication.CreateBuilder();
7
8builder.Services.AddDbContext<OrderDbContext>(options =>
9{
10    options.UseSqlite("Data Source=orders.db");
11});
12
13var app = builder.Build();
14
15app.MapGet("/orders", async (OrderDbContext db) =>
16{
17    return await db.Orders.ToListAsync();
18});
19
20app.Run();
21return;
22
23public record Order(string OrderNumber, decimal Amount);
24
25public class OrderDbContext : DbContext
26{
27    public OrderDbContext(DbContextOptions<OrderDbContext> options) : base(options) { }
28    public DbSet<Order> Orders { get; set; }
29}

You can also reference existing project files from your script:

csharp
1#:project ../ClassLib/ClassLib.csproj

Cross-Platform Shell Scripts

You can write cross-platform C# shell scripts that are executed directly on Unix-like systems. Use the #! directive to specify the command to run the script:

bash
1#!/usr/bin/env dotnet

Then make the file executable and run it:

bash
1chmod +x app.cs
2./app.cs

Converting to a Full Project

When your script grows and needs more structure, you can convert it to a regular project using the dotnet project convert command:

bash
1dotnet project convert app.cs

Note: Support for file-based apps with multiple files will likely come in future .NET releases.

You can see the complete list of new features in .NET 10 here.

C# 14 is one of the most significant releases in recent years.

Let's explore the key features:

Extension members are my favorite feature in C# 14. They represent a modern evolution of extension methods that have been part of C# since version 3.0.

Traditional Extension Method Syntax

Before C# 14, you created extensions by writing static methods with a this parameter:

csharp
1public static class StringExtensions
2{
3    public static bool IsNullOrEmpty(this string value)
4    {
5        return string.IsNullOrEmpty(value);
6    }
7
8    public static string Truncate(this string value, int maxLength)
9    {
10        if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
11        {
12            return value;
13        }
14
15        return value.Substring(0, maxLength);
16    }
17}

New Extension Keyword Syntax

The new syntax separates the receiver (the type you're extending) from the members you're adding. Instead of putting this on each method parameter, you declare an extension block that specifies the receiver once:

csharp
1public static class StringExtensions
2{
3    extension(string value)
4    {
5        public bool IsNullOrEmpty()
6        {
7            return string.IsNullOrEmpty(value);
8        }
9
10        public string Truncate(int maxLength)
11        {
12            if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
13                return value;
14
15            return value.Substring(0, maxLength);
16        }
17    }
18}

The extension block takes the receiver as a parameter. Inside the block, you write your methods and properties just like they were actual members of the type. The value parameter is available to all members within the block.

Both old and a new syntax compile to identical code, so they work the same way. You can even use both styles in the same static class.

The new extension syntax supports:

• Instance methods
• Instance properties
• Static methods
• Static properties

Extension properties make your code more readable and expressive. Instead of calling methods, you can use properties that feel more natural.

For example, when working with collections, you frequently check if they're empty. Instead of writing !items.Any() everywhere, you can create an IsEmpty property:

csharp
1public static class CollectionExtensions
2{
3    extension<T>(IEnumerable<T> source)
4    {
5        public bool IsEmpty => !source.Any();
6
7        public bool HasItems => source.Any();
8
9        public int Count => source.Count();
10    }
11}
12
13public void ProcessOrders(IEnumerable<Order> orders)
14{
15    if (orders.IsEmpty)
16    {
17        Console.WriteLine("No orders to process");
18        return;
19    }
20
21    foreach (var order in orders)
22    {
23        // Process order
24    }
25}

Inside an extension block, you can define private fields and methods, just like in a regular class. This is useful when you need to cache expensive calculations:

csharp
1public static class CollectionExtensions
2{
3    extension<T>(IEnumerable<T> source)
4    {
5        private List<T>? _materializedList;
6
7        public List<T> MaterializedList => _materializedList ??= source.ToList();
8
9        public bool IsEmpty => MaterializedList.Count == 0;
10
11        public T FirstItem => MaterializedList[0];
12    }
13}

The backing field _materializedList ensures that ToList() is only called once, no matter how many times you access the properties.

Static extensions let you add factory methods or utility functions to a type, not the instance. To create static extensions, use extension without naming the receiver parameter:

csharp
1public static class ProductExtensions
2{
3    extension(Product)
4    {
5        public static Product CreateDefault() =>
6            new Product
7            {
8                Name = "Unnamed Product",
9                Price = 0,
10                StockQuantity = 0,
11                Category = "Uncategorized",
12                CreatedDate = DateTime.UtcNow
13            };
14
15        public static bool IsValidPrice(decimal price) =>
16            price >= 0 && price <= 1000000;
17
18        public static string DefaultCategory => "General";
19    }
20}

You can call these static members directly on the type:

csharp
1var product = Product.CreateDefault();
2if (Product.IsValidPrice(999.99m))
3{
4    product.Price = 999.99m;
5}

The null-conditional operators (?. and ?[]) can now be used for assignment, not just for accessing members.

Before C# 14, you needed an explicit null check before assigning to a property:

csharp
1if (user is not null)
2{
3    user.Profile = LoadProfile();
4}

Now you can simplify this using the ?. operator:

csharp
1user?.Profile = LoadProfile();

This is cleaner and more consistent with how null-conditional operators work for reading values.

The field keyword eliminates the need for explicit backing fields in many common property scenarios.

Previously, you needed to declare a private backing field:

csharp
1public class Record
2{
3    private string _msg;
4
5    public string Message
6    {
7        get => _msg;
8        set => _msg = value ?? throw new ArgumentNullException(nameof(value));
9    }
10}

With the field keyword, you can reference the compiler-generated backing field directly:

csharp
1public class Record
2{
3    public string Message
4    {
5        get;
6        set => field = value ?? throw new ArgumentNullException(nameof(value));
7    }
8}

You can use field in any accessor: get, set, or init.

If you already use "field" as a variable name in your code, you can avoid conflicts by using @field or this.field, or by renaming your existing variable.

The field keyword is particularly useful for lazy initialization and default values:

csharp
1public class ConfigReader
2{
3    public string FilePath
4    {
5        get => field ??= "data/config.json";
6        set => field = value;
7    }
8
9    public Dictionary<string, string> ConfigValues
10    {
11        get => field ??= new Dictionary<string, string>();
12        set => field = value;
13    }
14}

This avoids declaring separate backing fields for FilePath and ConfigValues.

C# 14 allows you to use parameter modifiers like out, ref, in, scoped, and ref readonly in lambda expressions without specifying parameter types.

Previously, you had to include complete type declarations when using modifiers:

csharp
1delegate bool TryParse<T>(string text, out T result);
2
3TryParse<int> parse = (string text, out int result) => Int32.TryParse(text, out result);

Now you can omit the types and let the compiler infer them:

csharp
1delegate bool TryParse<T>(string text, out T result);
2
3TryParse<int> parse = (text, out result) => Int32.TryParse(text, out result);

This makes lambda expressions more concise while maintaining type safety.

C# 14 extends partial member support to include constructors and events. This is particularly useful for source generators.

Partial constructors must have one defining declaration and one implementing declaration:

csharp
1public partial class User
2{
3    // This is the defining part
4    public partial User(string name);
5}
6
7public partial class User
8{
9    // This is the implementing part
10    public partial User(string name)
11        : this() // Calls another constructor in the same class
12    {
13        Name = name;
14    }
15
16    public User() { }
17
18    public string Name { get; set; }
19}

Rules for partial constructors:

• Only the implementing part can use this() or base() to call another constructor
• Only one part of the class can use a primary constructor

Partial events also require one defining and one implementing declaration:

csharp
1public partial class Downloader
2{
3    public partial event Action<string> DownloadCompleted;
4}
5
6public partial class Downloader
7{
8    public partial event Action<string> DownloadCompleted
9    {
10        add { }
11        remove { }
12    }
13}

The implementing part must include both add and remove accessors.

You can see the complete list of new features in C# 14 here.

ASP.NET Core 10 adds built-in validation support for Minimal APIs. This feature automatically validates data sent to your endpoints, including query parameters, headers, and request bodies.

Register validation services by calling AddValidation:

csharp
1builder.Services.AddValidation();

The validation system automatically discovers types used in your Minimal API handlers and validates them using attributes from the System.ComponentModel.DataAnnotations namespace.

You can apply validation attributes directly to endpoint parameters:

csharp
1app.MapPost("/products",
2    ([Range(1, int.MaxValue)] int productId, [Required] string name) =>
3    {
4        return TypedResults.Ok(new { productId, name });
5    });

Record types work with validation too:

csharp
1public record Product(
2    [Required] string Name,
3    [Range(1, 1000)] int Quantity);
4
5app.MapPost("/products", (Product product) =>
6{
7    return TypedResults.Ok(product);
8});

When validation fails, the runtime automatically returns a 400 Bad Request response with details about the validation errors.

You can disable validation for specific endpoints:

csharp
1app.MapPost("/products", (int productId, string name) =>
2    TypedResults.Ok(productId))
3    .DisableValidation();

You can customize error responses by implementing IProblemDetailsService and registering it in the dependency injection container. This lets you create consistent, user-friendly error messages across your application.

To enable JSON Patch support with System.Text.Json, install the package:

bash
1dotnet add package Microsoft.AspNetCore.JsonPatch.SystemTextJson --prerelease

Server-Sent Events (SSE) provide a lightweight, reliable way for ASP.NET Core apps to push continuous streams of data without the complexity of bidirectional protocols.

Server-Sent Events (SSE) is a web standard that enables a server to push real-time data to web clients over a single HTTP connection. Unlike traditional request-response patterns where clients must repeatedly poll the server for updates, SSE allows the server to initiate communication and send data whenever new information becomes available.

For sending Server-Sent Events, you need to provide a data stream via IAsyncEnumerable<T>.

Here's a service that generates stock price updates:

csharp
1public record StockPriceEvent(string Id, string Symbol, decimal Price, DateTime Timestamp);
2
3public class StockService
4{
5    public async IAsyncEnumerable<StockPriceEvent> GenerateStockPrices(
6       [EnumeratorCancellation] CancellationToken cancellationToken)
7    {
8       var symbols = new[] { "MSFT", "AAPL", "GOOG", "AMZN" };
9
10       while (!cancellationToken.IsCancellationRequested)
11       {
12          var symbol = symbols[Random.Shared.Next(symbols.Length)];
13          var price = Math.Round((decimal)(100 + Random.Shared.NextDouble() * 50), 2);
14          var id = DateTime.UtcNow.ToString("o");
15
16          yield return new StockPriceEvent(id, symbol, price, DateTime.UtcNow);
17
18          await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
19       }
20    }
21}

Use TypedResults.ServerSentEvents to create an endpoint that streams data:

csharp
1builder.Services.AddSingleton<StockService>();
2
3app.MapGet("/stocks", (StockService stockService, CancellationToken ct) =>
4{
5    return TypedResults.ServerSentEvents(
6       stockService.GenerateStockPrices(ct),
7       eventType: "stockUpdate"
8    );
9});

Clients can connect to this endpoint and receive real-time updates as they're generated.

You can read an in-depth guide on Server-Sent Events with ASP.NET Core here.

ASP.NET Core 10 adds support for generating OpenAPI 3.1 documents. While the version number suggests a minor update, OpenAPI 3.1 is significant because it includes full support for JSON Schema draft 2020-12.

Key Changes in OpenAPI 3.1:

• Nullable types use a type array that includes null instead of a nullable: true property
• Integer types (int and long) may appear without the type: integer field and use a pattern field instead, depending on your JSON serialization settings
• The default OpenAPI version is now 3.1

You can explicitly set the OpenAPI version when adding OpenAPI support:

csharp
1builder.Services.AddOpenApi(options =>
2{
3    options.OpenApiVersion = Microsoft.OpenApi.OpenApiSpecVersion.OpenApi3_1;
4});

YAML Format Support

ASP.NET Core now supports serving OpenAPI documents in YAML format. YAML is more concise than JSON and supports multi-line strings, making it easier to read long descriptions.

To serve YAML documents, specify a .yaml or .yml extension:

csharp
1if (app.Environment.IsDevelopment())
2{
3    app.MapOpenApi("/openapi/{documentName}.yaml");
4}

Blazor receives several improvements in .NET 10:

• Hot Reload for Blazor WebAssembly and .NET on WebAssembly
• Environment configuration in standalone Blazor WebAssembly apps
• Performance profiling and diagnostic counters for Blazor WebAssembly
• NotFoundPage parameter for the Blazor router
• Static asset preloading in Blazor Web Apps
• Improved form validation

You can see the complete list of ASP.NET Core 10 features here.

Complex types let you model data that belongs to an entity but doesn't have its own identity. While entity types map to database tables, complex types can map to columns in the same table (table splitting) or to a JSON column.

Complex types enable document modeling patterns that can improve performance by avoiding JOINs and simplifying your database schema.

Table Splitting

Map a customer's addresses as complex types:

csharp
1modelBuilder.Entity<Customer>(b =>
2{
3    b.ComplexProperty(c => c.ShippingAddress);
4    b.ComplexProperty(c => c.BillingAddress);
5});

Optional Complex Types

EF 10 adds support for optional complex types:

csharp
1public class Customer
2{
3    public int Id { get; set; }
4    public Address ShippingAddress { get; set; }
5    public Address? BillingAddress { get; set; }
6}

JSON Mapping

Map complex types to JSON columns:

csharp
1modelBuilder.Entity<Customer>(b =>
2{
3    b.ComplexProperty(c => c.ShippingAddress, c => c.ToJson());
4    b.ComplexProperty(c => c.BillingAddress, c => c.ToJson());
5});

Struct Support

Complex types support .NET structs:

csharp
1public struct Address
2{
3    public required string Street { get; set; }
4    public required string City { get; set; }
5    public required string ZipCode { get; set; }
6}

LEFT JOIN is common in database queries, but previous versions of EF Core made it complicated to write. You needed to combine SelectMany, GroupJoin, and DefaultIfEmpty in a specific way.

.NET 10 adds first-class LINQ support for LeftJoin, making these queries much simpler:

csharp
1var query = context.Students
2    .LeftJoin(
3        context.Departments,
4        student => student.DepartmentID,
5        department => department.ID,
6        (student, department) => new
7        {
8            student.FirstName,
9            student.LastName,
10            Department = department.Name ?? "[NONE]"
11        });

EF 10 also supports RightJoin, which keeps all data from the second collection and only matching data from the first.

Both methods translate to the appropriate SQL JOIN operations.

Note that C# query syntax (from x select x.Id) doesn't yet support these operators.

While EF Core has supported JSON columns for several versions, ExecuteUpdate couldn't modify them. EF 10 changes this by allowing you to update JSON properties in bulk operations.

Given this model with a JSON column:

csharp
1public class Blog
2{
3    public int Id { get; set; }
4    public BlogDetails Details { get; set; }
5}
6
7public class BlogDetails
8{
9    public string Title { get; set; }
10    public int Views { get; set; }
11}
12
13protected override void OnModelCreating(ModelBuilder modelBuilder)
14{
15    modelBuilder.Entity<Blog>().ComplexProperty(b => b.Details, bd => bd.ToJson());
16}

You can now update properties within the JSON column:

csharp
1await context.Blogs.ExecuteUpdateAsync(s =>
2    s.SetProperty(b => b.Details.Views, b => b.Details.Views + 1));

This generates efficient SQL that updates the JSON data directly in the database.

Global query filters let you define conditions that apply to all queries for an entity type. This simplifies implementing patterns like soft deletion and multi-tenancy.

Previously, EF Core supported only one query filter per entity type.

EF 10 introduces named query filters, letting you define multiple filters and control them independently:

csharp
1modelBuilder.Entity<Blog>()
2    .HasQueryFilter("SoftDeletionFilter", b => !b.IsDeleted)
3    .HasQueryFilter("TenantFilter", b => b.TenantId == tenantId);

You can selectively disable specific filters in individual queries:

csharp
1var allBlogs = await context.Blogs
2    .IgnoreQueryFilters(["SoftDeletionFilter"])
3    .ToListAsync();

This gives you fine-grained control over which filters apply to each query.

ExecuteUpdateAsync lets you perform bulk updates directly in the database without loading entities into memory.

In previous versions, you had to provide changes as expression trees, making it challenging to build dynamic updates.

EF 10 allows regular lambdas with conditional logic:

csharp
1await context.Blogs.ExecuteUpdateAsync(s =>
2{
3    s.SetProperty(b => b.Views, 8);
4    
5    if (nameChanged)
6    {
7        s.SetProperty(b => b.Name, "foo");
8    }
9});

This is much simpler than manually building expression trees and makes conditional updates straightforward.

You can see the complete list of EF Core 10 features here.

Additional resources for .NET 10:

• Breaking changes in .NET 10
• What's New in the .NET 10 SDK
• What's New in the .NET 10 runtime
• What's New in .NET libraries for .NET 10
• Performance Improvements in .NET 10
• What's New in .NET Aspire

.NET 10 and C# 14 represent a significant step forward for the .NET ecosystem.

The file-based apps feature makes C# viable for scripting scenarios that were previously dominated by Python, Node.js and JavaScript.

Extension members give you flexibility by letting you add properties to types, not just methods.

The improvements to Minimal APIs, EF Core, and ASP.NET Core make building modern web applications faster and more intuitive.

As an LTS release, .NET 10 provides a stable foundation for both new and existing applications.

Whether you're building Web APIs, desktop applications, or CLI tools, this release offers features that improve productivity and code quality.

I've been testing .NET 10 in personal projects and will begin migrating commercial projects this month.

Are you excited about .NET 10? Hit reply and let me know.

Hope you find this newsletter useful. See you next time.