ASP.NET Core updates in .NET 8 Preview 1

Table of Contents

Full stack web UI using Blazor

Improved authentication and authorization experience

Native AOT

ASP.NET Core Roadmap for .NET 8

What’s new in .NET 8 Preview 1?

start

Upgrade an existing project

routing tools

Routing constraint performance improvements

New analyzer for API development

It is recommended to set or append to the title dictionary instead of adding

Warn if the parameter type passed to a route handler does not implement the correct interface

Detect if RequestDelegate is not implemented correctly

Send exception to Blazor’s SynchronizationContext

Hot reload supports .NET instance fields, properties and events on WebAssembly

Support symbol servers when debugging .NET on WebAssembly

Blazor WebAssembly debugging in Firefox

Experimental Webcil format for .NET assemblies

Specify the initial URL of the BlazorWebView to load

New option to keep SPA development server running

Support named pipes in Kestrel

HTTP/3 enabled by default

HTTP/2 over TLS (HTTPS) support on macOS

gRPC JSON transcoding no longer requires http.proto and annotations.proto

Specify server timeout and keep-alive interval settings using HubConnectionBuilder

IPNetwork.Parse and TryParse

IPv4

IPv6

HTTP_PORTS and HTTPS_PORTS configuration support

Warning when the specified HTTP protocol is not used

Provide feedback

.NET 8 Preview 1 is now available! This is the first preview of the next major version of .NET, which will include the next wave of innovations in web development with ASP.NET Core.

In .NET 8, we plan to make broad investments across ASP.NET Core. Here are some areas we plan to focus on:

UsingBlazor Full StackWeb UI

Note: This section was previously titled “Blazor United,” but to avoid confusion we no longer use that name. Instead, we’ll focus on the new features and enhancements added to Blazor in .NET 8 for full-stack web UI development.

In ASP.NET Core today, we have a few different ways to build web UIs:

• MVC & Razor Pages: The framework uses server-side rendering (SSR) to dynamically generate HTML from the server in response to requests. Rendering from the server helps your application load quickly because all the hard work of getting the data and deciding how to display it is already done on the server – the client only needs to display the HTML that has been rendered. They can leverage powerful server hardware to directly access back-end data and services.
• Blazor: Blazor’s component model focuses on handling UI interaction. Server-side rendering requires every UI interaction to be sent to the server, so it is not suitable for rich interactive UIs. For rich interactivity you need to use client-side rendering (CSR), which has much lower latency and allows easy access to client-side functionality.

Many modern web applications require a combination of these methods, including server-side rendering and client-side rendering. Perhaps your homepage or blog is best handled using server-side rendering so that it loads quickly and is easily indexed, while the app’s more complex features require the responsiveness of running from the client side. Currently, for .NET, this requires using several different frameworks simultaneously: MVC, Razor Pages, and Blazor.

In .NET 8, we’re working to merge the benefits of server-side and client-side rendering into a single full-stack programming model based on Blazor. With Blazor in .NET 8, you can use a single Blazor-based architecture for server-side rendering and full client-side interaction with Blazor Server or WebAssembly. All in one project, with the ability to easily switch between different rendering modes or even mix them within the same page. Blazor in .NET 8 will also enable new rendering features such as streaming rendering and progressive enhancements for navigation and form posts.

Check out the following early prototype video, which demonstrates many of these new features in action:

Related GitHub issue: dotnet/aspnetcore#46636

Improved authentication and authorization experience

In some cases, authentication and authorization can be difficult to implement in ASP.NET Core applications. In .NET 8, our goals are:

• Create a simple, intuitive, and well-documented experience for authentication and authorization using the web that is easy to develop and test.
• Provides a clear set of steps and tools to support deployment to production.
• Provide meaningful diagnostics to help resolve security issues quickly and effectively.

NativeAOT

.NET 7 introduces support for publishing .NET console projects as native AOT, resulting in a standalone, platform-specific executable without any runtime JIT. Native AOT apps launch very quickly and use less memory. Applications can be deployed to machines or containers that do not have any .NET runtime installed. In .NET 8, we will extend support for native AOT to ASP.NET Core, starting with cloud-centric API apps built with minimal APIs that meet concerns about published file size, startup time, job set and throughput performance expectations.

Related GitHub issue: dotnet/aspnetcore#45910

.NET 8ASP.NET CoreRoadmap

In addition to the above topics, we have many additional improvements planned in ASP.NET Core. You can find a complete list of ASP.NET Core work planned for .NET 8 in the .NET 8 ASP.NET Core roadmap on GitHub.

.NET 8Preview What’s new in version1?

.NET 8 Preview 1 is the first of many .NET 8 previews in preparation for the August 2023 release of .NET.

Here is a summary of what’s new in ASP.NET Core in this preview:

• Routing tools
• Routing constraint performance improvements
• New analyzer for API development
• Send exceptions to Blazor’s SynchronizationContext
• Hot reload supports .NET instance fields, properties and events on WebAssembly
• Support symbol server when debugging .NET on WebAssembly
• Blazor WebAssembly debugging in Firefox
• Experimental Webcil format for .NET assemblies
• Specify the initial URL of BlazorWebView to load
• New option to keep SPA development server running
• Support named pipes in Kestrel
• HTTP/3 is enabled by default
• HTTP/2 over TLS (HTTPS) support on macOS
• gRPC JSON transcoding no longer requires http.proto and annotations.proto
• Specify server timeout and use HubConnectionBuilder to keep alive interval settings
• IPNetwork.Parse and TryParse
• HTTP_PORTS and HTTPS_PORTS configuration support
• Warning when the specified HTTP protocol is not used

Start

To start using ASP.NET Core in .NET 8 Preview 1, install the .NET 8 SDK.

If you are using Visual Studio, we recommend installing the latest Visual Studio 2022 preview. Visual Studio for Mac support for .NET 8 preview is not available yet, but is coming soon.

Upgrade existing project

To upgrade an existing ASP.NET Core app from .NET 7 to .NET 8 Preview 1, do the following:

• Update the application’s target framework to net8.0.
• Update all Microsoft.AspNetCore.* package references to 8.0.0-preview.1.*.
• Update all Microsoft.Extensions.* package references to 8.0.0-preview.1.*.

Also see the complete list of breaking changes in ASP.NET Core for .NET 8.

Routing Tool

ASP.NET Core is built on routing. Minimal API, Web API, Razor Pages, and Blazor all use routing to customize how HTTP requests are mapped to code.

In .NET 8, we’ve invested in a new set of features to make routing easier to learn and use. These include:

• Route syntax highlighting
• Autocomplete parameters and route names
• Automatically complete routing constraints
• Route analyzer and fixes
• Supports minimal API, Web API and Blazor

Grouped together, we call these new features Path Tools. The routing tool is built on Roslyn and has features that light up automatically depending on the IDE you are using. Please try it out in Preview 1 and give us feedback. A blog post introducing the cool new features of the Directions tool is coming soon.

?

Routing constraint performance improvement

ASP.NET Core routing is a powerful, high-performance technology used by almost all ASP.NET Core applications. A common feature of routing is routing constraints. The app uses routing constraints to match requests to the correct endpoint:

// Endpoint only matches requests with a URL slug. For example: article/my-article-name
app.MapGet("article/{name:regex(^[a-z0-9] + (?:-[a-z0-9] + )*$)}", (string name) => { /* . .. */ });

In .NET 8, we’ve made several performance improvements to constraints:

• Regular expression constraints are now compiled. Creating compiled regular expressions has a one-time cost at startup, but they maximize runtime performance.
• Duplicate constraints are now shared between routes. Shared cache constraints reduce startup time and memory usage, especially for applications with many routing and regular expression constraints.
• Alpha constraints now use source-generated regular expressions.

forAPINew analyzer developed

High-quality code is easier to debug, test, and repair. In .NET 8, we’re investing in a set of profilers that will help you leverage ASP.NET Core’s APIs more efficiently. Starting with Preview 1, you can take advantage of new analyzers:

It is recommended to set or append to the title dictionary instead of adding

var context = new DefaultHttpContext();

context.Request.Headers.Add("Accept", "text/html"); // ASP0019 warning
context.Request.Headers["Accept"] = "text/html"; // Apply codefix using indexer
context.Request.Headers.Append("Accept", "text/html"); // Apply codefix using IHeaderDictionary.Append

var app = WebApplication.Create();

app.MapGet("/customers/{customer}", (Customer customer) => {}); // ASP0021 warning

public classCustomer
{
    public async static Task<Customer> BindAsync(HttpContext context) => new Customer();
}

var app = WebApplication.Create();

Task<string> HelloWorld(HttpContext c)
  => Task.FromResult("Hello " + c.Request.RouteValues["name"]); // ASP0016 warning

app.MapGet("/", HelloWorld);

var app = WebApplication.Create();

Task HelloWorld(HttpContext c) => c.Response.WriteAsync("Hello " + c.Request.RouteValues["name"]);
app.MapGet("/", HelloWorld);

var app = WebApplication.Create();

app.MapGet("/{name}", (string name) => $"Hello {name}");

Send exceptions toBlazor< strong>SynchronizationContext

Exceptions can now be dispatched to Blazor’s SynchronizationContext using the new DispatchExceptionAsync method on ComponentBase and RenderHandle. This allows you to handle these exceptions using Blazor’s error handling features (such as error boundaries).

Hot reload support< Instance fields, properties and events on strong>WebAssemblyon.NET

.NET on WebAssembly now supports adding instance fields, properties, and events to existing classes when using hot reloading. This also enables other C# and Razor language features that use instance fields under the hood, such as certain types of C# lambdas and certain uses of the Razor @bind directive.

onWebAssembly< strong>Support symbol server

when debugging on.NET

<PropertyGroup>
    <WasmEnableWebcil>true</WasmEnableWebcil>
</PropertyGroup>

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenNamedPipe("MyPipeName");
});

Blazor.start({
    configureSignalR: function (builder) {
        builder
          .withServerTimeout(60000)
          .withKeepAliveInterval(30000);
    };
});

// Using Parse
var network = IPNetwork.Parse("192.168.0.1/32");

// Using TryParse
bool success = IPNetwork.TryParse("192.168.0.1/32", out var network);

//Ctor equivalent
var network = new IPNetwork(IPAddress.Parse("192.168.0.1"), 32);

// Using Parse
var network = IPNetwork.Parse("2001:db8:3c4d::1/128");

// Using TryParse
bool success = IPNetwork.TryParse("2001:db8:3c4d::1/128", out var network);

//Ctor equivalent
var network = new IPNetwork(IPAddress.Parse("2001:db8:3c4d::1"), 128);

ASPNETCORE_HTTP_PORTS=80;8080
ASPNETCORE_HTTPS_PORTS=443;8081

ASPNETCORE_URLS=http://*:80/;http://*:8080/;https://*:443/;https://*:8081/