What's New in .NET 9: Key Features and Examples

.NET 9 brings several powerful features aimed at enhancing performance, security, and ease of development across various applications, from web and desktop to AI and mobile platforms. Let’s dive into some of the most exciting updates, along with examples to illustrate how they work.

1. Performance Enhancements

Dynamic Adaptation to Application Sizes (DATAS)

One of the new updates in .NET 9 is the ability for the garbage collector to adjust to application memory needs dynamically. This feature, called Dynamic Adaptation to Application Sizes (DATAS), helps improve memory management by resizing memory allocation automatically based on the app’s usage. For applications with varying workloads, like web applications, this feature can lead to better performance and lower memory consumption.

Arm64 Support

.NET 9 has improved support for Arm64 processors, which are increasingly common in mobile devices and some servers. This support includes better vectorization (making operations faster) and more efficient code generation. If you’re deploying applications on devices with Arm64 processors, this enhancement can help them run more smoothly.

2. Improved JSON Serialization with System.Text.Json

JSON Schema Generation

.NET 9 makes it easier to create JSON schemas directly from your .NET classes. JSON schemas are useful for validating JSON data structures or generating API documentation. This feature is particularly handy when you need to validate data from a JSON API or enforce consistent data structures across your application.

Example:

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Json.Schema;

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Generate a JSON schema based on the User class
JsonSchema schema = JsonSchema.FromType<User>();
Console.WriteLine(schema.ToJson());

In this example, a JSON schema is generated from the User class, allowing you to see or share the structure of the data that the User class represents.

Nullable Reference Type Annotations

Now, System.Text.Json supports nullable reference types, making JSON serialization more flexible. You can now annotate properties to specify whether they are nullable, which helps you write cleaner and more robust code.

3. New LINQ Methods for Easier Data Processing

.NET 9 adds new methods to LINQ, a popular library for handling collections of data. Two of these new methods are CountBy and AggregateBy, which help you quickly group and count data without additional steps.

Example with CountBy:

using System.Linq;

var users = new[] { "Alice", "Bob", "Alice", "Charlie", "Bob" };

// Count occurrences by name
var countByNames = users.CountBy(name => name);
foreach (var item in countByNames)
{
    Console.WriteLine($"{item.Key}: {item.Value}");
}
// Output:
// Alice: 2
// Bob: 2
// Charlie: 1

This example counts how many times each name appears in the list, making it easy to see user distribution without having to write a lot of code.

4. Enhanced .NET SDK

Workload Sets for Consistent Dependencies

.NET 9 introduces “workload sets” to help maintain consistency across project dependencies. Workload sets keep your workloads (like .NET MAUI or ASP.NET) at specific versions across different projects. This is especially helpful if you’re managing multiple projects and need consistent tool versions across them.

NuGet Security Audits

.NET 9 now includes automatic security checks for NuGet packages (packages of reusable code), including both direct and indirect dependencies. This change makes it easier to spot and avoid potential security issues in your application.

5. Integrated AI Capabilities

Unified AI Abstractions

.NET 9 has added new tools for integrating AI directly into your applications. The Microsoft.Extensions.AI library provides simplified abstractions, allowing you to connect your application to AI services, like text generation or image recognition.

Working with Tensors

A tensor is a mathematical concept used frequently in AI applications. .NET 9 introduces a Tensor type and tools to work with these data structures, making it easier to integrate AI and machine learning features.

Example:

using System.Numerics.Tensors;

var tensor = new DenseTensor<float>(new float[4] { 1, 2, 3, 4 }, new int[] { 2, 2 });
Console.WriteLine(tensor[0, 1]); // Outputs: 2

In this example, we create a 2x2 tensor (a 2D data structure) and access one of its values. This kind of structure is commonly used in AI and data processing.

6. ASP.NET Core Updates for Web Developers

Automatic Versioning for Static Files

.NET 9 can now automatically append a version tag to static files (like JavaScript and CSS) based on their contents. This feature helps browsers to cache these files efficiently, so users get the latest versions without manual updates.

Example: If you have a CSS file named site.css, .NET 9 might serve it as site.css?v=12345, where 12345 is a hash based on the file contents. This ensures the file will reload when updated, improving performance and reducing potential issues with outdated content.

Built-in OpenAPI Support

.NET 9 includes built-in OpenAPI support, which automatically generates API documentation. This is particularly useful for developers working on REST APIs who want to provide clear documentation to other developers.

7. .NET MAUI for Cross-Platform App Development

HybridWebView Control

.NET MAUI (Multi-platform App UI) has added a new control called HybridWebView, which allows you to embed web content directly in your applications. This control is useful for hybrid apps that use both native and web content.

Example:

<maui:HybridWebView Source="https://example.com" />

This code embeds a web page directly in your MAUI app, making it easy to integrate web-based content or interactive elements.

Enhanced App Lifecycle and Controls

.NET MAUI includes improvements to app lifecycle events and performance optimizations, making cross-platform applications faster and more efficient. New controls, like the customizable TitleBar for Windows, give developers more tools for building polished, native experiences.

Summary

.NET 9 is packed with features that make it faster, more secure, and easier to use for modern applications. From better memory management and enhanced web development tools to built-in AI integrations and cross-platform capabilities, .NET 9 is designed to support the latest application needs. These updates allow developers to work more efficiently and deliver high-quality, performant applications across a range of platforms.