What’s new in .NET 8? Discover ALL .NET 8 Features

.NET 8: An Overview

A free, open-source, cross-platform programming framework called.NET 8 makes it possible to create a variety of web, mobile, and cloud computing applications. For many years, the software industry has been driven by this potent open-source development platform. The technocrats gain the ability to create more potent, effective, and secure programmes with each new version release.

The.NET framework has released seven versions since its launch, each bringing with it a fresh set of improvements. The replacement for.NET 7, known as.NET 8, was just made available. In addition to being a framework version,.NET 8 is much more. It reimagines the creation and implementation of software applications, empowering programmers to adapt to the changing needs of contemporary computing. Long-term support (LTS), greater cross-platform compatibility, higher performance, better diagnostic and observability, sophisticated tooling and integration, and much more are all provided.

We’ll talk about the most recent enhancements and changes to Microsoft.NET 8 in this ASP.NET lesson.

Upgrades and Enhancements in .NET 8

Let’s explore everything one by one:

1. Software Development Kit (SDK) Change

1. Terminal Build Output

A project and its dependencies are built into a set of binaries using the dotnet build command. This command provides a new way to generate a build output that is more modernised in.NET 8. This terminal logger output provides real-time build process updates and simplifies the grouping of errors according to their particular projects. It also makes different target frameworks in multi-targeted projects easier to distinguish.

2. Simplified Output Paths

The folder structure and output path for build outputs can now be streamlined. All of the construction outputs are collected in one place. Better predictability and interoperability with a wider range of development tools and utilities are made possible by this modification.

3. Dotnet Workload Clean Command

This is a new command that removes any residual workload packs that may build up from changes to the Visual Studio or.NET SDK.

4. Dotnet Publish and Dotnet Pack Assets

With.NET 8, the dotnet publish and dotnet pack commands now generate Release assets by default rather than Debug assets. You could create and package your code with these commands for various uses.

5. Template Engine

Now that security features from NuGet have been included, the template engine has been improved to offer a more secure experience. The following are these enhancements:

. stopping packages from unsecured http:// feeds from being downloaded. Therefore, an attempt to install the template package will fail if the source URL does not employ https.
. The template engine now looks for known vulnerabilities in the template package for commands like dotnet new, dotNET new install, and dotnet new update.
. The owner of the template package can now be found using the dotnet new command.
. You may find out whether a template is installed from a package that is deemed “trusted” by using the dotnet search and uninstall commands. A reserved prefix is used by trusted packages to denote their dependability.

2. Core .NET Libraries

1. Time Abstraction

Mock time is made possible in test scenarios via the new TimeProvider class and ITimer interface in.NET 8. It even has the ability to set timers, retrieve timestamps for performance assessment, and retrieve local and UTC data.

2. UTF8 Improvements

Writing string-like representations of your data type to UTF8 destinations is made possible with the addition of the IUtf8SpanFormattable interface in.NET 8. TryWrite methods for UTF8-based formatting are also provided, and formatting to UTF8 from a variety of primitive data types is supported.

Example

static bool FormatHexVersion(
short major,
short minor,
short build,
short revision,
Span utf8Bytes,
out int bytesWritten) =>
Utf8.TryWrite(
utf8Bytes,
CultureInfo.InvariantCulture,
$”{major:X4}.{minor:X4}.{build:X4}.{revision:X4}”,
out bytesWritten);

The implementation uses their implementations to write their UTF8 representations straight to the destination span after recognising IUtf8SpanFormattable on the format values.

3. Methods for Working with Randomness

The Framework.Both random and systematic.Cryptography and security.The.NET RandomNumberGenerator data types provide new ways to work with randomness. Among them are Shuffle() to lessen machine learning training bias and GetItems() to select items at random from an input set.

The usage of System.Random is demonstrated in the example below.GetItems() can be used to randomly insert 31 items into an array on the instance that the Random.Shared property provides.

Example of System.Random.GetItems()

private static ReadOnlySpan s_allButtons = new[]
{
Button.Red,
Button.Green,
Button.Blue,
Button.Yellow,
}; // … Button[] thisRound = Random.Shared.GetItems(s_allButtons, 31);
// Rest of game goes here … Example of Shuffle() YourType[] trainingData = LoadTrainingData();
Random.Shared.Shuffle(trainingData); IDataView sourceData = mlContext.Data.LoadFromEnumerable(trainingData); DataOperationsCatalog.TrainTestData split = mlContext.Data.TrainTestSplit(sourceData);
model = chain.Fit(split.TrainSet); IDataView predictions = model.Transform(split.TestSet);
// …

4. Performance-Focused Data Types

System.Collections is a new feature.The FrozenDictionary and FrozenSet data types, which enable read-only collections for quicker read operations, are introduced by the Frozen namespace in.NET 8. Furthermore, System.Buffers.IndexOfAnyValues maximises the process of finding any value in a collection’s first instance.

private static readonly FrozenDictionary s_configurationData =
LoadConfigurationData().ToFrozenDictionary(optimizeForReads: true);

// …
if (s_configurationData.TryGetValue(key, out bool setting) && setting)
{
Process();
}

5. System.Numerics and System.Runtime.Intrinsics

On.NET 8, hardware acceleration has been enhanced by Vector256, Matrix3x2, and Matrix4x4. With the ConstExpected feature added to the hardware intrinsics in.NET 8, you can be sure that you will always know wether the underlying hardware expects a constant or a non-constant. Additionally, linear interpolation between the two values may be carried out effectively and precisely thanks to the newly added Lerp(TSelf, TSelf, TSelf) API.

6. Data Validation

The Framework.PartitionModel.New properties for data validation in cloud-native applications are included in the DataAnnotations namespace in.NET 8. These are made especially to verify data that isn’t entered by users, like setup settings.

3. Extension of .NET Libraries

1. ValidateOptionsResultBuilder Type

It makes the process of creating ValidateOptionsResult objects easier and permits the aggregation of several errors when validating. This is very helpful when using IValidateOptions.Use the validate method in order to improve the handling of validation errors.

2. Garbage Collection Memory Limit Adjustment

The garbage collection memory limit can now be dynamically changed. Additionally, to ensure effective resource utilisation, the garbage collector can be updated with the new memory limit via the _RefreshMemoryLimit API.

3. Source Generator for Configuration Binding

For app setup, ASP.NET Core reads key-value pair data from several sources via configuration providers. You can choose to produce binding implementations for configuration mapping with the help of the source generator included in.NET 8. This enhances compatibility and performance by doing away with the dependency on reflection, which leads to problems with trimming and Native AOT.

4. Reflection Improvements

You may have noticed that when working with function pointers and utilising reflection operations such as typeof or FieldInfo in earlier.NET versions, an IntPtr was returned rather than a System.Type object.FieldType. This restricted access to function pointers’ metadata, including parameters, return types, and calling conventions.

Nevertheless, reflection has been improved in.NET 8 to enable function pointers. Now, when utilising FieldInfo or typeof.A System.Type object is returned when FieldType is applied to a function pointer. This allows you to perform more thorough reflection operations on these data types by giving you access to and use of the metadata related to function pointers.

5. Native Ahead-of-Time (AOT) Compilation

Native AOT compiles managed code straight into native machine code during the build process, as contrast to standard just-in-time (JIT) compilation, which converts code to machine code at runtime. By combining everything into a single file, Native AOT makes it possible to create a self-contained version of the application that does not require a separate runtime.

Let’s examine its main facets to comprehend the importance of Native AOT:

. Enhanced Startup Time: In traditional JIT compilation, methods have a compilation delay during their initial execution, which affects how quickly an application launches. With Native AOT, on the other hand, compilation takes place during the construction stage. As a result,.NET 8 programmes have very little warm-up time and react instantly to user input.
. Diminished Memory Footprint: Native AOT minimises the memory footprint of.NET applications by compiling directly to native code.

6. Performance Improvements

. Arm64 performance enhancements
. Single Instruction, Multiple Data (SIMD) improvements
. Support for AVX-512 (Advanced Vector Extensions) ISA extensions
. Cloud-native improvements
. Profile-Guided Optimization (PGO) improvements
. Just-in-Time (JIT) throughput improvements
. Loop and general optimizations
. Optimized access for fields marked with ThreadStaticAttribute
. Consecutive register allocation
. JIT/NativeAOT memory operations

Summary:

We have seen some of the most significant.NET 8 updates in this blog post. The developers’ development process will go more smoothly thanks to these enhancements. The release of Microsoft.NET 8 represents a significant advancement in the creation of scalable, secure, reliable, and efficient applications. The release of.NET 8 also brought with it the availability of C# 12.