What is new in .NET 6.0 preview?

Today we are pleased to provide you with the first look of .NET 6 and tell you what to expect from the new release. We have defined the general form of the version over the last several months, including a large set of new experiences and capabilities. The core of .NET 6 is to deliver the last portions of the .NET unification plan that began with .NET 5. This release will also include significant improvements in all parts of .NET, including cloud, desktop, and mobile applications. It will take several overviews to make the biggest reach of the version fully available in .NET 6 builds. 

Table of Content

See ASP.NET Core and EF Core publications for details of what is new for web and data access scenarios.

.NET 6 has been tested with Visual Studio 16.9 Preview 4 as well as Visual Studio for Mac 8.9. We recommend you use these builds if you want to try. NET 6.

Other sections are divided into two parts: an initial look into what we deliver for .NET 6 in general (what you will receive in November), and what is new in Preview in particular.

Unified and Extended

.NET 6 will allow you to create the apps you want to create, for which platforms you want to target, and which operating systems you want to use for development.

We extend what you can do with .NET and where you can do it by providing the remaining .NET unification vision.

We integrate Android, iOS, and macOS features which are part of Xamarin into .NET 6. We also extend what you can do with Blazor in a new type of hybrid client application a combination of web and native user interface – which can be used for desktop and mobile scenarios.

These new features will be described below in this post and the following previews. Our unification efforts deliver something for all .NET developers. If you are a desktop application developer, there are new options for you to reach new users.

If you are a mobile application developer, you can use the mainline .NET tools and APIs, while targeting both iOS and Android platforms.

If you are a web or cloud developer, it will be easier to expose the services to .NET mobile applications and share code with them.

We take advantage of the opportunity surrounding unification to simplify and extend the experience of building Xamarin Forms applications.

We call this project .NET Multi-platform App UI. This project will offer many enhancements and capabilities that will extend the scope of the desktop and mobile developer platform.

Open Planning

We have adopted a more inclusive planning process with .NET 6. We are preparing .NET broadcasts with a hierarchical style of themes, epics, and user stories, with priorities and categories.

This model allows you to see the version at a broader scope, provides an overview of the most important features, and makes it easier to find opportunities to engage and contribute.

The plan you see on GitHub is now an integral component of our engineering process. We will do our best to update these issues and link them to relevant activities and documents to help you better understand the depth and scope of the project.

We encourage you to get involved, ask questions and provide feedback.

Platform Supports

.NET 6 to be launched in November 2021, it will be supported for three years, it is a Long-Term Support (LTS) release. The platform matrix has been considerably expanded .NET 5.

The additional supports are Android, iOS, Mac and Mac Catalyst, Apple Silicon “M1”, Windows Arm64.

Fast Inner Loop

Quick iterative development is the trademark of any delightful and productive development platform. We initiated a new project called Fast Inner Loop. The first part of the project makes it possible to make the builds run faster with a set of performance projects.

We have seen the Xamarin team innovate with the XAML Hot Reload experience in the last few years and began to envision the activation of hot-reloading as a general .NET capability, and not only for XAML, but C#/IL. We are defining a new hot code reload model that we can offer for all types of apps.

Targeting .NET 6

The TFM target repositories for .NET 6 follow the approach we have adopted with .NET 5. New TFMs have been added following additional support for new platforms.

If you target .NET 6, you can use a .NET 6 TFM (target framework monikers).

Example

net6.0  

The compatibility relationships for each of these TFMs, both between this set and existing TFMs, are discussed .NET 6.0 Target Frameworks(s).

We expect that upgrading from .NET 5 to .NET 6 would be straightforward. Please report any breakage changes you discover while testing existing applications with .NET 6.

Response Files

A response file is a file that holds a set of command-line arguments for a tool. The response files are based on two primary use cases: allows a command-line call to exceed the terminal character limit, and it is convenient to type the same commands over and over again.

Response file support has been added to the .NET CLI.  The format of the response file is one line of text, just as it would be structured within a terminal.

The following animation demonstrates the use of an answer file with dotnet build, you can type this command dotnet build @example.rsp.

Libraries

The following APIs have been introduced to the .NET libraries.

New Math APIs

The following performance-based mathematics APIs have been added to System.Math. Their implementation will be accelerated if supported by the underlying equipment.

There are New APIs which are following

1. We can compute the Sin and Cos.
2. We can compute the ReciprocalEstimate for the approximate of 1 / x.
3. We can compute the ReciprocalSqrtEstimate for the approximate of 1 / Sqrt(x).

There are some new overloads are following

1. nint and nunit is supported by the Clamp, DivRem, Min, and Max.
2. nint is also supported by Abs and Sign.
3. DivRem returns a tuple value.

Improve Support for Windows ACLs

System.Threading.AccessControl now includes enhanced support to interact with Windows Access control lists (ACLs). Some New overloads have been added into the OpenExisting and TryOpenExisting methods for EventWaitHandle, Mutex, and Semaphore.

Example

namespace System.Threading{
    public static partial class EventWaitHandleAcl
    {
        public static EventWaitHandle OpenExisting(string Aclname, EventWaitHandleRights Aclrights);
        public static bool TryOpenExisting(string Aclname, EventWaitHandleRights Aclrights, out EventWaitHandle Aclresult);
    }
    public static partial class AclMutex
    {
        public static Mutex OpenExisting(string Mutexname, MutexRights Mutexrights);
        public static bool TryOpenExisting(string Mutexname, MutexRights Mutexrights, out Mutex Mutexresult);
    }
    public static partial class AclSemaphore
    {
        public static Semaphore OpenExisting(string Se_name, SemaphoreRights Se_rights);
        public static bool TryOpenExisting(string Se_name, SemaphoreRights Se_rights, out Semaphore Se_result);
    }}

Conclusion

In this blog, we have discussed some new features in .NET 6. These features are used by the developers. If the developer performs math operation so .NET 6 provide the new Math APIs.