What's New in ASP.NET Core 9?

ASP.NET Core in .NET 9 introduces several significant enhancements to improve performance, usability, and developer experience. Here are the key features:

ASP.NET 9 New updated

Performance Improvements in .NET 9

.NET 9 introduces several performance enhancements in ASP.NET Core, focusing on optimizing runtime efficiency and improving application responsiveness. Here are the key improvements:

.NET 9 implements Dynamic PGO in the Just-In-Time (JIT) compiler, which optimizes code execution based on actual runtime behavior. This results in startup times being approximately 15% faster, as the compiler can make better-informed decisions about which code paths to optimize during execution.
The JIT compiler has been enhanced through tiered compilation and inlining techniques, leading to lower CPU usage during execution. These optimizations contribute to a smoother deployment experience and reduced warm-up times for applications, which is particularly beneficial for microservices and high-throughput environments.
The Kestrel web server has undergone significant improvements, allowing it to handle HTTP/2 and HTTP/3 requests up to 20% faster, with a 25% reduction in average latency. This enhancement leads to quicker response times for web applications and more efficient resource usage under high-traffic conditions.
Garbage collection (GC) has been optimized for better performance, especially in applications with high allocation rates. This results in smoother GC cycles with 8–12% less memory overhead, which helps reduce latency and improves overall application reliability.
JSON serialization performance has improved by about 35%, making it more efficient for applications that handle extensive data parsing and API requests. This enhancement is particularly useful for applications that rely heavily on JSON data manipulation.
ASP.NET Core has been optimized to use less memory, which is crucial for applications that need to scale efficiently in cloud environments.

Native Ahead-of-Time (AOT) compilation

Native Ahead-of-Time (AOT) compilation has been enhanced, resulting in smaller binaries and reduced cold-start times. Applications using Native AOT now consume 30–40% less memory, which is advantageous for cloud-native applications running in containerized environments.

To enable Native AOT we need to add PublishAot property in .csproj file as shown in below snapshot.

Native AOT

using System;
using System.Net;

class Program
{
    static void Main(string[] args)
    {
        // Minimal HTTP server
        HttpListener listener = new HttpListener();
        listener.Prefixes.Add("http://localhost:8080/");
        listener.Start();

        Console.WriteLine("Listening on http://localhost:8080...");
        
        while (true)
        {
            var context = listener.GetContext();
            var response = context.Response;

            string responseString = "Hello, Native AOT!";
            byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);

            response.ContentLength64 = buffer.Length;
            response.OutputStream.Write(buffer, 0, buffer.Length);
            response.OutputStream.Close();
        }
    }
}

Console Output

Browser Output

These improvements in .NET 9 significantly enhance the performance of ASP.NET Core applications, making them faster, more responsive, and better suited for modern cloud-native architectures. Developers can expect smoother deployments, reduced latency, and overall improved application efficiency simply by upgrading to .NET 9.

Built-in OpenAPI Support

.NET 9 introduces robust OpenAPI support in ASP.NET Core, reducing dependency on external libraries and streamlining API documentation. The new Microsoft.AspNetCore.OpenApi package replaces Swashbuckle, offering better-maintained, built-in capabilities.

Automatic Schema Generation: Keeps OpenAPI documentation synchronized with API code, minimizing manual errors.
Custom Metadata: Developers can add endpoint descriptions, parameters, and responses for clearer API specifications.
Minimal Configuration: OpenAPI support can be enabled with a few lines of code, making it accessible for beginners.
Performance Optimization: Source generators reduce runtime overhead compared to traditional methods.
Enhanced Compatibility: Generated OpenAPI documents integrate seamlessly with tools like Swagger UI and NSwag.

Blazor Enhancements

Blazor Server in .NET 9 introduces significant updates aimed at improving performance, usability, and the developer experience. These enhancements make Blazor Server applications more responsive and adaptable to diverse use cases.

Improved Reconnection Strategy: An exponential backoff mechanism ensures seamless reconnections after network interruptions. If a user revisits a disconnected app, it attempts immediate reconnection and refreshes automatically upon success.
WebSocket Compression: Enabled by default, this feature accelerates data transfer between server and client, delivering smoother interactions for Blazor Server applications.
Flexible Rendering Modes: Developers can now mix static server-side rendering (SSR) with interactive pages within the same application, optimizing both performance and SEO.
Authentication Simplification: New APIs, such as AddAuthenticationStateSerialization and AddAuthenticationStateDeserialization, streamline authentication management, reducing boilerplate code.
Optimized Static Asset Delivery: The MapStaticAssets middleware compresses assets with Gzip and fingerprints them at build time, ensuring faster load times.
Dependency Injection in Components: Blazor components now support constructor injection, simplifying dependency management and improving code maintainability.
Enhanced Input Method Handling: The new KeyboardEventArgs.IsComposing property provides better support for complex input methods, benefiting international applications.
SignalR Improvements: Enhanced support for JSON polymorphic types strengthens real-time web capabilities.

Development Experience

Simplified Debugging: The debugging experience has been enhanced with better layouts for dictionaries and key-value collections in the debugger, making it easier to inspect data structures during development.

New LINQ Features

New LINQ expressions like CountBy and AggregateBy allow developers to perform more complex queries with less boilerplate code, improving code readability and maintainability. .NET 9 introduces several enhancements to LINQ, including new methods like TakeWhileLast() for improved data querying.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var sales = new[]
        {
            new { Product = "A", Amount = 100 },
            new { Product = "B", Amount = 200 },
            new { Product = "A", Amount = 150 },
            new { Product = "B", Amount = 250 },
            new { Product = "C", Amount = 300 },
            new { Product = "C", Amount = 100 },
        };

        // Count the occurrences of each product
        var productCounts = sales.CountBy(sale => sale.Product);

        Console.WriteLine("Product Counts:");
        foreach (var (product, count) in productCounts)
        {
            Console.WriteLine($"{product}: {count}");
        }

        // Aggregate total sales amount by product
        var totalSales = sales.AggregateBy(
            sale => sale.Product,
            0, // Initial seed value
            (total, sale) => total + sale.Amount
        );

        Console.WriteLine("\nTotal Sales by Product:");
        foreach (var (product, total) in totalSales)
        {
            Console.WriteLine($"{product}: {total}");
        }
    }
}

CountBy and AggregateBy output

String Literals

String handling gets a significant boost with native support for UTF-8 literals, making memory-efficient text processing easier.

using System.Text;

class Program
{
    static void Main()
    {
        ReadOnlySpan<byte> utf8Literal = "Hello, World!"u8;
        Console.WriteLine(Encoding.UTF8.GetString(utf8Literal));
    }
}

String Literals

Security Enhancements

ASP.NET Core 9 introduces several security improvements to safeguard applications and sensitive data, ensuring compliance with modern security standards.

Updated Authentication Mechanisms: Enhancements to OpenID Connect handling improve security practices for applications using OAuth protocols, ensuring safer authentication flows.
Automatic Key Rotation: Data protection is strengthened with automatic encryption key rotation, reducing the risk of key theft and eliminating the need for manual updates.
Advanced Cryptography: Updated cryptographic libraries now support stronger and more efficient encryption algorithms, including hardware-accelerated operations. This enhances both security and performance for sensitive data handling.
New Authentication and Authorization APIs: Simplified APIs improve the implementation of secure access controls, providing seamless integration with modern authentication protocols and standards.
Secure by Default: ASP.NET Core 9 incorporates best security practices into the framework by default, reducing the risk of vulnerabilities during development.
Simplified HTTPS Setup: Developers using Linux benefit from an easier process for setting up trusted development certificates, promoting secure communication practices from the start.
NuGet Security Audits: NuGet now performs automatic security audits on direct and transitive package references, helping developers identify and address vulnerabilities in third-party dependencies.

ASP.NET 6 vs ASP.NET 7 vs ASP.NET 8 vs ASP.NET 9

Feature/Aspect	ASP.NET Core 6	ASP.NET Core 7	ASP.NET Core 8	ASP.NET Core 9
Minimal APIs	Introduced Minimal APIs for lightweight applications.	Enhanced Minimal APIs with improved routing.	Further improvements to Minimal APIs, including better performance.	Continued enhancements with support for filters and more flexible routing.
Data Protection	Basic data protection features.	Improved key management options.	Enhanced data protection with new algorithms.	Automatic key rotation and custom key storage options were introduced.
Blazor Enhancements	Initial support for Blazor components.	Improved performance for Blazor components.	Enhanced integration with JavaScript libraries.	Faster component rendering and better JavaScript integration.
OpenAPI Support	Basic OpenAPI documentation support.	Improved OpenAPI generation capabilities.	Enhanced OpenAPI support for better customization.	Automatic schema generation and custom metadata for OpenAPI specifications.
Performance Improvements	General performance optimizations.	Further optimizations for speed and efficiency.	Enhanced performance metrics and diagnostics tools.	Significant improvements, including HTTP/3 support and enhanced logging capabilities.
Cryptography	Basic cryptographic features are available.	Improved encryption options were introduced.	Enhanced cryptographic capabilities with new algorithms.	Advanced encryption algorithms and improved key management processes.
AI Integration	Limited AI capabilities were introduced.	Basic support for AI services through extensions.	Expanded AI integrations with Microsoft.Extensions.AI packages.	Unified abstractions for AI services, including support for language models and tensor types.
Dependency Injection	A Standard DI container was available.	Simplified DI setup for easier use.	Improvements in DI usability and efficiency.	Further simplifications in dependency injection, reducing boilerplate code.
Hot Reload Support	Basic Hot Reload functionality introduced.	Improved Hot Reload capabilities.	Enhanced Hot Reload experience for faster development cycles.	Advanced Hot Reload features allow real-time updates without restarts.

Conclusion

Overall, ASP.NET Core in .NET 9 reflects a strong commitment to enhancing performance, simplifying development workflows, and providing robust tools for modern web application development. These updates are designed to help developers create high-performance applications that are easier to maintain and scale.

Explore the exciting new features introduced in C# 13: What's New in C# 13.