Expectation of .Net Core 3.0

Expectation of .Net Core 3.0


.NET Core 3.0 brings us a slew of new features, notably support for Windows desktop apps (WinForms, WPF) on .NET Core. This will allow “side by side” versions of .NET Core for your desktop apps as opposed to “in-place” framework installations.

Well, how about ASP .NET Core 3.0? Well, during Connect(); 2018, Scott Hunter pointed out that ASP .NET Core 2.2 was also released at the same time as .NET Core 3.0 preview 1. He added that ASP .NET Core 3.0 (preview) within  .NET Core 3.0 (preview) currently has “the exact same ASP .NET Core 2.2 bits” and “so, there’s no benefit to move to 3 yet… won’t be till…. sometime next year [2020]”.

Here are a few things you can expect in ASP .NET Core 3.0, whenever it comes out next year:

  • Newtonsoft’s Json.NET will be removed from the shared framework
  • EF Core will be shipped separately as pure NuGet packages
  • ASP .NET Core 3.0 will only run on the cross-platform .NET Core 3.0
  • ASP .NET Core 3.0 will NOT run on the Windows-only .NET Framework
  • Note that some new C# 8.0 features will only be coming to .NET Core 3.0

New Asp.Net 3.0 Features

C# 8:

The .NET Core 3.0 supports C# 8, and the new features in C# 8.0 include Nullable reference types, Async streams, Ranges and indices and Switch expressions.

Ranges and indices:

For indexing, the new index type can be used. Even user can create one from an int that counts from the start. It can count from the end as well but with a prefix ^ operator (C#).
Even the range type consists of two index value, one is for a start, and another one is for the end. It can be written as “x..y” range expression (C#). To produce a slice, one can then use the index with a range.

Async streams:

A new asynchronous version of IEnumerable<T> is the IAsyncEnumerable<T>. If you want to consume the elements of IAsyncEnumerable<T>, then it lets you wait for each over it and use yield return that produces elements. With the ability to wait for each, one can also create async iterators.

Using Declarations:

It is a new way to make sure that your object is properly disposed of, as it keeps the object alive even when it is still in scope. It automatically disposes of the object once it becomes out of scope. It will make your code cleaner and reduce nested using statements.

Switch Expressions:

It is the best way to switch statement but, yes, it is an expression that returns a value. They are fully integrated with pattern matching and represent the default value by using the discard pattern.

Patterns allow you to write declarative code that captures your intent. The compiler is responsible for implying procedural code correctly.

EEE Floating-point improvements:

With the IEEE 754-2008 revision, floating point APIs are in the process of being updated to comply. It aims to expose all needed operations and make sure that they are behaviorally compliant with the IEEE spec.

Parsing and formatting fixes:

  • Correctly parse and format negative zero.
  • Correctly round inputs of any length and parse.
  • Correctly NaN by performing a case-insensitive check and parse Infinity and supporting an optional preceding + where applicable.

New Math APIs have:

  • BitIncrement/BitDecrement
  • MaxMagnitude/MinMagnitude
  • ILogB
  • ScaleB
  • Log2
  • FusedMultiplyAdd
  • CopySign

.NET Platform Dependent Intrinsics:

To allow access to certain perf-orientated CPU instruction, APIs has been added such as the Bit Manipulation or SIMD instruction sets. These instructions achieve big performance improvements in processing data efficiently and some other. The .NET libraries have begun using the instructions to improve performance by exposing the APIs for your programs to use.

Default executables:

.NET Core come up with default executable to build framework-dependent executables. It uses a globally installed version of .NET Core which is new for application users.

You can expect the following thing with these executables: From a command prompt, you can launch the application like ./myapp on macOS and Linux or myapp.exe on Windows.

Build copies dependencies:

From the NuGet cache, dot net build now copies NuGet dependencies for your application to the build output folder.

Windows desktop:

One can build Windows desktop apps using Windows Forms and WPF. with the .NET Core 3.0. It supports using modern controls and fluent styling from the Windows UI XAML Library (WinUI). It is a part of the Windows .NET Core 3.0 SDK.

MSIX Deployment for Windows Desktop:

MSIX can be used to deploy .NET Core 3.0 desktop applications to Windows 10. The Windows Application Packaging Project allows you to create MSIX packages with self-contained .NET Core applications.

Fast built-in JSON support:

The new built-in JSON support is low allocation, high-performance, and based on Span<byte>. To .NET Core 3.0, three new main JSON-related types have been added.

Assembly Unloadability:

It is a new ability of AssemblyLoadContext which is transparent from an API perspective and exposed with just a few new APIs. It allows releasing all memory for instantiated types, a loader context to be unloaded, the assembly itself and static fields. With it, an app can load and unload assemblies without any memory leak.

Windows Native Interop:

In the form of flat C APIs, WinRT, and COM, Windows offers a rich native API. With .NET Core 3.0, it supports the Activate WinRT APIs and ability to CoCreate COM APIs.


New support has been added for AES-CCM and AES-GCM ciphers, implemented via System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm.

These algorithms are both Association Data (AEAD) algorithms and Authenticated Encryption, and the first Authenticated Encryption (AE) algorithms added to .NET Core.

Cryptographic Key Import/Export:

.NET Core 3.0 P supports the import as well as the export of asymmetric private and public keys from standard formats, without any use of X.509 certificate. For public keys, RSA, ECDsa, DSA, ECDiffieHellman, etc. keys support the X.509 SubjectPublicKeyInfo format, and for private keys the PKCS#8 PrivateKeyInfo and PKCS#8 EncryptedPrivateKeyInfo formats. PKCS#1 RSAPublicKey and PKCS#1 RSAPrivateKey additionally supported by RSA.

More BCL Improvements:

Those types like Span<T>, Memory <T>, and others that introduced in .NET Core 2.1 will optimize in .NET Core 3.0. With it, some common operations like slicing, span construction, formatting, and parsing now perform better.

Even Strings like types showed improvement when they used with Dictionary <TKey, TValue> and other collections. Here are the improvements:

  • ThreadPool.UnsafeQueueWorkItem
  • Brotli support built into HttpClient
  • Unsafe.Unbox
  • Complex Arithmetic Operators
  • CancellationToken.Unregister
  • StringBuilder.GetChunks
  • Socket APIs for TCP keep alive
  • RandomNumberGenerator.GetInt32
  • IPEndPoint parsing

Tiered compilation:

It is on the .NET Core 3.0 as a by default that enables the runtime to more adaptively using the Just-In-Time (JIT) compiler to perform better.

Platform Support:

.NET Core 3 support an extensive range of OS as given below:

  • Windows Server: 2012 R2 SP1+
  • Windows Client: 7, 8.1, 10 (1607+)
  • RHEL: 6+
  • macOS: 10.12+
  • Ubuntu: 16.04+
  • Fedora: 26+
  • SLES: 12+
  • Debian: 9+
  • Alpine: 3.8+
  • openSUSE: 42.3+

Chip support follows:

  • x86 on Windows
  • x64 on Windows, macOS, and Linux
  • ARM64 on Linux
  • ARM32 on Windows and Linux (on Debian 9+ and Ubuntu 16.04+.)


So it is all what I explored on .NET Core 3.0. and its features.

eSoft Technologies is an expert .NET web application development company in India, who has in-depth knowledge with rich experience in development of ASP.Net Web Development. Connect with us today to Hire .NET Programmers and design/develop your web application.

Leave a comment