The perfect new options in ASP.NET Core 6

Microsoft .NET 6 arrived in November 2021 with all types of nice new options for .NET builders. The most important spotlight of .NET 6, although, is ASP.NET Core 6, a serious improve of Microsoft’s open supply framework for constructing trendy net functions.

ASP.NET Core 6 is constructed on prime of the .NET Core runtime and permits you to construct and run functions on Home windows, Linux, and macOS. ASP.NET Core 6 combines the options of Net API and MVC. This text discusses what’s new in ASP.NET 6, with some code examples.

To work with the code examples offered on this article, it’s best to have Visible Studio 2022 put in in your pc. You’ll be able to obtain Visible Studio 2022 right here.

Now let’s dive into the brand new options in ASP.NET Core 6.

Sizzling Reload

Sizzling Reload is without doubt one of the most placing new options added in .NET 6. You’ll be able to make the most of this function to switch the person interface when your ASP.NET Core 6 utility is in execution. You’ll be able to see the modifications mirrored when you save them — you don’t have to rebuild and restart the appliance. This function boosts developer productiveness significantly.

Minimal APIs

ASP.NET Core 6 helps you to construct light-weight providers (additionally known as minimal APIs) that don’t require a template or controller class. As well as, you should use the extension strategies of the IEndpointConventionBuilder interface to construct light-weight providers that don’t have any template or controller. You’ll be able to create light-weight providers or APIs within the Startup class or the Program class.

You’ll be able to make the most of a few of the extension strategies of the IEndpointConventionBuilder interface to map requests. Right here is the record of those extension strategies:

• MapControllers
• MapGet
• MapPut
• MapPost
• MapDelete
• MapRazorPages
• MapGrpcService
• MapHub

The MapGet, MapPut, MapPost, and MapDelete strategies are used to attach the request delegate to the routing system. The MapControllers technique is used for controllers, MapRazorPages for Razor Pages, MapHub for SignalR, and MapGrpcService for gRPC.

For an instance, the next code snippet illustrates how you should use a light-weight service to jot down a “Howdy World” response within the Program.cs file.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Construct();
app.MapGet("https://www.infoworld.com/", (Func<string>)(() => "Howdy World!"));

Merger of the Program and Startup lessons

In ASP.NET Core 5 and earlier, we’ve needed to work with two lessons to construct and configure the appliance. These lessons are the Program and Startup lessons, that are situated within the Program.cs and Startup.cs recordsdata.

Right here is an instance of a typical Startup class in ASP.NET Core 5:

public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
         public IConfiguration Configuration { get; }
         public void ConfigureServices(IServiceCollection providers)
        {
            providers.AddControllers();
            providers.AddSingleton<IDataService, DataService>();
        }
        public void Configure(IApplicationBuilder app,
        IWebHostEnvironment env)
        {
             if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/House/Error");
                app.UseHsts();
            }
            app.UseHttpsRedirection();
            app.UseRouting();
            app.UseAuthorization();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    title: "default",
                    sample: "{controller=House}/{motion=Index}/{id?}");
            });
        }
    }

With ASP.NET 6, the Program and Startup lessons have been merged into the Program class. Right here is an instance of the Program class in ASP.NET Core 6:

var builder = WebApplication.CreateBuilder(args);
builder.Companies.AddControllers();
builder.Companies.AddSingleton<IDataService, DataService>();
var app = builder.Construct();
if (app.Atmosphere.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}
else
{
    app.UseExceptionHandler("/House/Error");
    app.UseHsts();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.MapControllers();
app.Run();

Program.cs file modifications

The brand new console template dramatically simplifies the code it’s good to write for a program. The console template not incorporates a Program class. In essence, you solely want to jot down the Fundamental technique now.

In earlier .NET variations, if you created a brand new ASP.NET Core challenge, a category named Program could be created routinely inside a file named Program.cs. The Program class would come with the Fundamental technique, which is the place the execution of an ASP.NET Core utility begins. Fundamental is the tactic the place an internet utility is constructed, configured, and executed.

If you create a brand new console utility challenge in .NET 6, Visible Studio creates a default Program.cs file that incorporates this code:

// See https://aka.ms/new-console-template for extra data
Console.WriteLine("Howdy, World!");

If you create a brand new console utility challenge in .NET 5, the default Program.cs file incorporates this code:

utilizing System;
namespace IDGNet6Demo
{
    inner class Program
    {
        static void Fundamental(string[] args)
        {
            Console.WriteLine("Howdy World!");
        }
    }
}

In ASP.NET Core 5 and earlier, the everyday Program.cs file will comprise this code:

public class Program {
   public static void Fundamental(string[] args) {
      CreateHostBuilder(args).Construct().Run();
   }
   public static IHostBuilder CreateHostBuilder(string[] args) =>
      Host.CreateDefaultBuilder(args)
      .ConfigureWebHostDefaults(webBuilder => {
         webBuilder.UseStartup <Startup> ();
      });
}

And in ASP.NET Core 6, the everyday Program.cs file will comprise this code:

utilizing NET6Demo;
Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup<Startup>();
    }).Construct().Run();

Observe that you’ll not discover a Startup.cs file by default in ASP.NET Core 6. Nonetheless, if you would like backward compatibility with earlier variations of ASP.NET Core, otherwise you’re merely extra comfy with the previous type, you’ll be able to create a Startup class within the challenge manually.

Then name the UseStartup technique to specify the Startup class as proven within the previous code snippet.

HTTP Logging middleware

Help for the HTTP Logging middleware has been launched in ASP.NET Core 6. You’ll be able to make the most of this middleware in ASP.NET Core 6 to log details about HTTP requests and responses that embrace a number of of the next:

• Request data
• Response data
• Request and response headers
• Physique of the request
• Properties

Blazor enhancements

There are a number of enhancements in Blazor in ASP.NET Core 6. Among the most vital embrace:

• Means to render parts from JavaScript.
• Help for preserving prerendered state.
• Help for customized occasion args.
• Help for JavaScript initializers.
• Means to render parts dynamically utilizing the DynamicComponent class.
• Means to outline error boundaries utilizing the ErrorBoundary class.

Improved assist for IAsyncDisposable

You even have enhanced assist for IAsyncDisposable in your controllers, lessons, web page fashions, and consider parts to launch async assets.

Failure to get rid of an asynchronous disposable useful resource could lead to deadlocks. The IAsyncDisposable interface solves this drawback by liberating up assets asynchronously. The IAsyncDisposable interface is part of the System namespace that was launched in C# 8.0.

Simply as you implement the Dispose() technique of the IDisposable interface for synchronous calls, it’s best to implement the DisposeAsync() technique of the IAsyncDisposable interface to carry out clean-up operations and launch assets asynchronously.

The .NET 6 ecosystem offers a simplified improvement mannequin, improved efficiency, and enhanced productiveness. Many enhancements have been launched in ASP.NET Core 6 to enhance utility efficiency and cut back allocations. By the identical token, builders profit from many enhancements that make creating performant, trendy net apps each sooner and simpler.