Exploring .NET 9.0 Features and Latest Blazor Updates: A Deep Dive

As a .NET developer, staying up-to-date with the latest features and improvements is crucial. In this blog post, we'll explore the exciting new features in .NET 9.0 and the latest updates to Blazor. We'll cover everything from performance enhancements to new language features, complete with code samples and detailed walkthroughs.

Table of Contents

1. .NET 9.0 Features
   • Performance Improvements
   • C# 12 Language Features
   • Native AOT Enhancements
2. Blazor Updates
   • Blazor United
   • Enhanced JavaScript Interop
   • Improved Component Model
3. Conclusion

.NET 9.0 Features

Performance Improvements

.NET 9.0 continues the trend of focusing on performance improvements. One of the most significant enhancements is the introduction of profile-guided optimization (PGO) for native AOT compilation.

Profile-Guided Optimization (PGO)

PGO allows the compiler to make more informed decisions about code optimization based on actual runtime behavior. Here's how you can enable PGO for your .NET 9.0 project:

1. First, add the following to your project file:

xml
<PropertyGroup>
  <PublishAot>true</PublishAot>
  <OptimizationPreference>PGO</OptimizationPreference>
</PropertyGroup>

2. Build and run your application with instrumentation:

bash
dotnet publish -c Release
./bin/Release/net9.0/<YourApp> --collect-profile

3. This will generate a profile file. Now, rebuild your application using this profile:

bash
dotnet publish -c Release

The resulting executable will be optimized based on the collected profile data, potentially offering significant performance improvements for your specific use case.

C# 12 Language Features

C# 12, which comes with .NET 9.0, introduces several new language features to improve developer productivity and code readability.

Primary Constructors for Non-Record Classes

C# 12 extends the primary constructor syntax to non-record classes. This feature allows for more concise class definitions:

csharp
public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;

    public void Introduce() => Console.WriteLine($"Hi, I'm {Name} and I'm {Age} years old.");
}

// Usage
var person = new Person("Alice", 30);
person.Introduce();

Collection Expressions

Collection expressions provide a more concise way to initialize collections:

csharp
int[] numbers = [1, 2, 3, 4, 5];
List<string> names = ["Alice", "Bob", "Charlie"];
Dictionary<string, int> ages = ["Alice": 30, "Bob": 25, "Charlie": 35];

Native AOT Enhancements

.NET 9.0 further improves Native AOT (Ahead-of-Time) compilation, making it more viable for a wider range of applications.

Improved Reflection Support

Native AOT now has better support for reflection, allowing more libraries and frameworks to work seamlessly with AOT compilation. Here's an example of using reflection with Native AOT:

csharp
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods)]
public class ReflectionExample
{
    public void DynamicMethod(string methodName)
    {
        var method = GetType().GetMethod(methodName);
        method?.Invoke(this, null);
    }

    public void SayHello() => Console.WriteLine("Hello from reflection!");
}

// Usage
var example = new ReflectionExample();
example.DynamicMethod("SayHello");

Blazor Updates

Blazor United

Blazor United is a new model that combines the best of server-side and client-side rendering. It allows for seamless transitions between server and client rendering modes.

Streaming Rendering

Blazor United introduces streaming rendering, which allows parts of the page to be rendered and sent to the client incrementally. Here's an example of how to use streaming rendering:

csharp
@page "/"
@attribute [StreamRendering]

<h1>Welcome to My Blazor App</h1>

<QuickLoadingComponent />

<SlowLoadingComponent />

@code {
    private async Task<RenderFragment> SlowLoadingComponent() => builder =>
    {
        <div>
            @foreach (var item in await GetSlowDataAsync())
            {
                <p>@item</p>
            }
        </div>
    };

    private async Task<IEnumerable<string>> GetSlowDataAsync()
    {
        await Task.Delay(3000); // Simulate slow data fetch
        return new[] { "Data 1", "Data 2", "Data 3" };
    }
}

In this example, the QuickLoadingComponent will render immediately, while the SlowLoadingComponent will stream its content as it becomes available.

Enhanced JavaScript Interop

Blazor in .NET 9.0 provides improved JavaScript interop capabilities, making it easier to integrate with existing JavaScript libraries and frameworks.

Module-based JavaScript Interop

You can now use ECMAScript modules for cleaner JavaScript interop:

csharp
@inject IJSRuntime JS

@code {
    private IJSObjectReference? module;

    protected override async Task OnInitializedAsync()
    {
        module = await JS.InvokeAsync<IJSObjectReference>("import", "./scripts/myModule.js");
    }

    private async Task CallJsMethod()
    {
        await module!.InvokeVoidAsync("myJsMethod", "Hello from Blazor!");
    }
}

Improved Component Model

The Blazor component model has been enhanced to provide better performance and more flexibility.

Stateful Prerendering

Stateful prerendering allows components to maintain their state between prerendering and interactive rendering:

csharp
@page "/"
@attribute [PreserveState]

<h1>Counter: @count</h1>
<button @onclick="IncrementCount">Increment</button>

@code {
    private int count = 0;

    private void IncrementCount()
    {
        count++;
    }
}

With the [PreserveState] attribute, the component's state will be preserved when the page becomes interactive, providing a seamless user experience.

Conclusion

.NET 9.0 and the latest Blazor updates bring a wealth of new features and improvements to the .NET ecosystem. From performance enhancements like profile-guided optimization and improved Native AOT support to new C# language features and Blazor's unified model, developers have powerful new tools at their disposal.

As you explore these new features, remember to benchmark your applications and carefully consider which improvements make the most sense for your specific use cases. The .NET team continues to push the boundaries of what's possible with the framework, and it's an exciting time to be a .NET developer.

Happy coding, and may your .NET 9.0 and Blazor projects be faster, more efficient, and more enjoyable to develop than ever before