What are the new .NET 6 features? This article will tell you about the new features in the latest version of .NET. It will also tell you about the tools and improvements coming up in the new version, continue to know more.
.NET is a software development platform for building and running web applications, mobile apps, desktop apps, and other services. This open-source and free framework works well as a backend language platform on cross-platforms like Linux, Windows, macOS, iOS, Android, etc.
.NET supports more than 60 languages, some of which include F#, C#, and Visual Basic. The major components of .NET 6 include CLR, JIT Compiler, Garbage Collector, and base class library.
Microsoft released the first version .NET Core 1.0, in the year 2016. The recent version is .NET 6.0, released in November 2021. Compared to the .NET 5 version, the present version is simple to code and supports Apple Silicon (Arm64). Also, one can see an improvement in cloud diagnostics with OpenTelemetry and .Net monitor.
Let’s decode the top features of .NET 6 in detail.
Top 15 .NET 6 FEATURES that You Shouldn’t Miss
The significant features of the new .NET version include FileStream, Arm64 Support, Windows Forms, Cryptography, improved security and cloud diagnostics, and more.
Hot Reload
Hot reload is a very significant feature addition to .NET 6. Imagine having to restart your app every time you edit its source code. Time-consuming and distracting, isn’t it? However, with hot reload, the changes made to the source code are immediately visible in the running app. You need not waste your time restarting the app. In the present .NET version, hot reload is compatible with almost all types of .NET apps.
Profile-Guided Optimization
Profile guided optimization is a handy JIT compiler optimization feature of .NET 6. Using this feature, you can optimize the most frequently used code paths and types for better functionality. However, this feature remains disabled by default. To enable it, you need to use the DOTNET_TieredPGO environment variable. With profile-guided optimization, you can improve the performance of your applications based on how exactly it executes and not just how the code is written. In this way, the compiler can consider different program behaviors that can occur during runtime.
FileStream
In .NET 6, the entire Filestream is rewritten to make it more reliable and faster, thereby improving the asynchronous File I/O performance. As a result, in the case of the Windows OS, FileStream no more uses the blocking APIs. Also, you can better utilize your system memory on different platforms. For instance, after completing the first async operation, subsequent async operations are made allocation-free.
Another FileStream improvement includes the better performance of the preallocation size feature. As a result, you better write operations’ reliability with enough memory space. Further, you can reduce the number of syscalls to write data using the Scatter/Gather IO API.
Crossgen2
With Crossgen2, you can optimize and generate code uniquely. This process ensures a fast startup. Crossgen2 allows you to compile your code ahead of time (AOT) to ensure that runtime JITing is reduced. The JITed code is stored at a different section that can be easily fetched during runtime. Since Crossgen2 is written in C# language, you don’t have to use fancy APIs like a Roslyn compiler. Also, Crossgen2 can be used to analyze and compile multiple assemblies as an individual unit. You can choose to have extra optimizations inside the compiled set.
.NET 6 reduces your computational costs and enhances performance if you operate on the cloud. Features like OpenTelemetry and dotnet monitor bring about this functionality.
Arm64 Support
.NET 6 is the first-ever release with native support for Apple Silicon (Arm64). Also, this version gives an enhanced performance with Windows Arm64. This support covers both the emulation as well as the execution phase.
Some pointers that you need to consider while using Arm64 support are:
- SDKs for both x64 and Arm64 are recommended and supported
- Complete runtime support of Arm64 and x64
- .NET 5 SDKs and .NET Core 3.1 SDKs work on the present version but are less capable and not fully supported
- .Net test is yet to work with x64 emulation fully.
C# 10 Offerings
Some of the features of C# 10 have been improved for faster coding and better performance. Some of these innovations include file-scoped namespace declarations, global using directives, and record structs.
Let’s understand some of these offerings in detail:
- Using the file-scoped namespace feature, you can declare a namespace for the entire file without having to nest the remaining contents inside {….}. However, you must use this feature before any types are declared.
Old syntax:
namespace MyNamespace
{
class MyClass { … } // Everything is indented
}
New syntax:
namespace MyNamespace;
class MyClass { … } // Not indented
- With the global using directives feature, you need to specify the ‘using’ directive once, and it will easily be reflected across all the files you compile. Global using directives can be part of any .cs file like the Program .cs.
Some examples of global using directive syntax are:
global using System;
global using Env = System.Environment;
- Using the record struct feature, you can declare the records of C#10 as structs. With record structs, you can add == operator and implement IEquatable<T> as well as a value-based ToString.
Cloud Diagnostics
.NET 6 reduces your computational costs and enhances performance if you operate on the cloud. Features like OpenTelemetry and .Net monitor bring about this functionality.
OpenTelemetry is a collection of APIs, tools, and SDKs to better analyze your software behavior and performance. This analysis is possible by collecting and exporting telemetry data like logs, metrics, and traces. Also, OpenTelemetry is 100% free and open-source, and it easily integrates with famous frameworks and libraries like Express, ASP.NET Core, Spring, and Quarks.
Similarly, .Net monitor makes it easy to collect diagnostic data from a .Net process. Usually, when you run a .Net application, collecting diagnostic data like traces, logs, and process pumps can be challenging. This is due to the differences in the production environment and diverse local environment. Hence .Net monitor can simplify your process regardless of the environment in which the application is run, using consistent HTTP API.
Improved Security
.NET 6 comes with enhanced security features like “write exclusive execute” (W^X) and Control-flow Enforcement Technology (CET). CET technology is available with the newer versions of AMD and Intel processors. It can protect your computer hardware against control-flow hijacking attacks. Though .NET 6 supports CET on Windows x64 apps, you must explicitly enable this feature.
Similarly, the W^X feature safeguards your attack path by ensuring that memory pages are not executable and writable at the same time. However, the W^X feature is not enabled on Windows systems and is available by default on Apple systems.
Introduction of New APIs
.NET 6 has seen new API additions for processing JSON, HTTP/3, and mathematics.
Let’s understand these APIs in detail.
Maths APIs:
System.Math has seen the addition of many performance-oriented math APIs. Some of these are:
- Simultaneously compute cos and sin using the SinCos API
- Compute an approximate value of 1/x and 1/Sqrt (x) using the ReciprocalEstimate API
JSON APIs:
.NET has improved the performance of JSON APIs and made them more capable. System.Text.Json has a new code generator that works in collaboration with JsonSerializer. You can configure it in numerous ways, thereby facilitating assembly trimming and reducing memory usage.
Some of the JSON APIs are:
New types for writeable DOM:
- JsonNode, JsonObject, JsonArray, JsonValue
Serialization interfaces for defaulting and validation values:
- IJsonOnSerialized, IJsonOnDeSerialized, IJsonOnSerializing, IJsonOnDeSerializing
C# 10 Improvements
.NET SDK has seen a modernization of the C# project templates. The modernized language features are:
- Top-level statements
- Implicit global using directives
- Async Main method
- Target-typed new expressions
- Nullable reference types
- File-scoped namespaces
With these features enabled, you can increase the signal and reduce noise while looking at your code in the code editor. You can experience better specificity and ensure that you can code productively. For example, you can easily copy/paste your code from one file to another without using CTRL-. Types for creating the namespaces.
SDK Workloads
The new and optional SDK workloads ensure that the size occupied by the present .NET SDK remains smaller. To test various scenarios, you can easily install these SDKs over the .NET SDKs. These components are Blazer WebAssembly AOT and .NET MAUI. SDK Workloads are automatically installed in a Visual Studio. The new .Net workload commands help you manage your workloads in the .NET CLI.
Some of the new .Net commands for handling the SDK workloads are:
- Dotnet workload install: This command helps you install a named workload
- Dotnet workload restore: Installs a workload based on the requirements of different projects
- Dotnet workload update: Using this command, you can easily install your workload to the latest version available
- Dotnet workload list: This command lists out the workloads that you install
- Dotnet workload uninstall: This command helps you remove a specific workload
- Dotnet workload search: Search for your favorite workload using this command
- Dotnet workload repair: You can easily use this command to reinstall the workload if you have a broken installation.
Source Build
With a source build feature, organizations like Red Hat can build .NET projects from the source and readily offer their builds to different users.
Windows Forms
.NET 6 has improvised on the windows forms with features like better accessibility for controls, template updates, the ability to create an application-wide default font, etc.
Some other Windows Forms innovations are:
- Enhanced Narrator announcements in ErrorProvider, DataGridView, and ListView column header controls.
- DateTimePicker control has the support of ExpandCollapseControlPattern.
- Text Control Patterns have better support from corrected control types.
- Color contrast has been improved for controls like Label, PropertyGridView, DataGridView, ToolStripButton, CheckedListBox.
- UpDownButtons component of NumericUpDown and DomainUpDown controls support Invoke Control Pattern.
HTTP/3
.NET 6 supports the new version of HTTP, i.e., HTTP/3. A new connection protocol called QUIC solves the existing performance and operational challenges of HTTP/3. QUIC is efficient in establishing faster connections that are independent of the IP address. This feature ensures that mobile clients can easily switch between cellular and Wi-fi networks.
Validation of the NuGet Package
.NET 6 has the NuGet package validation tools that allow you to validate your packages to check if they are well-formed and consistent. These tools help you to:
- See if the NuGet package versions have any breaking changes
- If all the runtime specific implementations use the same set of public APIs
- See if there are any gaps for runtime applicability or target framework.
Wrapping Up
Overall, .NET 6 is a promising advancement over the previous .NET versions. There are enhanced security features with the addition of “write exclusive execute” (W^X) and Control-flow Enforcement Technology (CET). Code changes are easily reflected across your applications without restarting the app. Also, the entire filestream in .NET 6 is rewritten to facilitate asynchronous file read/write operations. With enhanced features, .NET 6 is beneficial for developers to create any website or mobile app from scratch. Many enhanced APIs have been added for Maths, JSON, and HTTP/3 that aim to improve your applications’ speed and performance.
