Summary: .NET Conf 2020 - What's New in .NET 5 and More

In this post, we'll take a look at a summary of the recent dotnetconf, which, due to COVID, was held online and gave us some very interesting details.

In this post, I won't go into detail about any particular section, as the idea is to create a general summary post; later on, I will probably write more detailed posts about much of what was covered.

The event lasted 3 days and featured hundreds of sessions. Here, I'm grouping them by what I feel are the most important (for example, there were 6 or 7 sessions about Blazor, but I'll include just one main point).

1 - What's New in .NET 5

The first thing we saw was .NET 5; Scott Hunter gave a presentation about the new improvements in this release. Interestingly, it turns out that Bing's browser and Microsoft's own .NET website have been built with .NET 5 for months, which means it's been thoroughly tested.

Aside from that fact, the following main improvements stood out:

General performance improvements for the language, with a particular focus on enhancements for ARM architecture, the JSON serializer, regular expressions, and HTTP.

As I just mentioned, ARM64 support is now included (it wasn't in previous versions), as well as support for WebAssembly.

ClickOnce is back for publishing client applications. It was removed with the arrival of netcore and people went crazy looking for it online. Not only is it back, but the experience has been improved.

And, in my opinion, the crown jewel.

New versions of the C# 9 and F# 5 languages; as we saw in another post, the big addition for me in this version is records. I am truly looking forward to seeing what can be achieved with them.

Before wrapping up this section, I'll mention that Microsoft decided to name this version .NET 5 instead of net core 5 (skipping version 4). This is to mark .NET Framework as legacy and assume that everyone is moving on to .NET 5.

2 - Blazor Improvements in .NET 5

There was a lot about Blazor at the conference, and I was glad because personally, it's a technology I really like. As you know, on this blog I'm creating a Blazor course.

Highlights included inviting several Blazor library creators to explain their products, as well as showcasing new features such as:

• When you change code in Visual Studio, Blazor automatically reloads with the changes, so you don't have to stop and restart the project. It may sound trivial, but once you use this feature, you'll miss it when it's not there.
• CSS isolation; another new feature where we can associate a CSS file to our Blazor components as long as the CSS file is named the same as the component. No need to manually add a reference, the compiler handles it for you.

3 - Xamarin.Forms 5 and WPF Enhancements

I have to say this session was a total surprise for me because I knew you could make mobile apps with Xamarin, but I'd never played around with it before.

We got to see a presentation of a mobile app, very simple, just to show off the new enhancements. For example, when a code change was made, you could instantly see it reflected in the app, just like what we saw with Blazor.

Interestingly, applications written with Xamarin.Forms work on all mobile operating systems, including iOS.

The same goes for WPF. We saw a session introducing its new features and an example of using Chromium in a desktop app, instead of the old approach of installing Internet Explorer and other hacks. This was where we first saw the return of ClickOnce.

Remember that both Xamarin.Forms and WPF use xaml, a language we should start taking seriously. It's worth noting that the plan is to directly include Xamarin in .NET 6. We'll see how that turns out, but it looks promising.

4 - gRPC Improvements

For those who don't know, gRPC is an RPC (Remote Procedure Call) framework, a technology that lets you make calls from one service to another, similar to a REST API. The difference is that REST APIs are designed for human-machine communication (sending JSON text), while RPC is purely machine-to-machine.

They demonstrated how to create both a client and a server, indicated it supports Blazor WebAssembly, and highlighted performance improvements.

Personally, I haven't used gRPC for microservices, but after Microsoft emphasized it across the three days, I might give it a shot soon. I’ll definitely dive deeper and include the technology in a project at some point.

5 - Project Tye

Special mention for one of the projects that I liked and found most surprising.

Basically, it's a tool that allows you to develop, test, and deploy microservices and distributed systems much more easily.

This is thanks to built-in microservices orchestration, and it also allows deploying on Kubernetes with very little additional configuration.

Personally, I think it's a great project since most companies are, intentionally or not, migrating towards distributed systems.

Note: Project Tye is a project under the .NET Foundation.

6 - Other Announcements

1. We also saw how the new visual studio update features improvements in the git integration.
2. At the same time, there were a couple of sessions on github actions and Azure; personally I prefer AWS so I only had those on in the background. By the way, .NET 5 is now available in Azure.
3. There were a couple of presentations on machine learning.
4. How to use .NET for home automation projects, with IoT.
5. Entity Framework 5 improvements.
6. One session I found pretty interesting was the one in which Scott Hanselman updated his blog live from .NetCore 3.1 to .NET 5.
7. We also saw a "presentation" about the ".NET Foundation", basically, it's an organization that supports open source projects, and over the three days we saw a couple of these projects featured.

Conclusion

The three days of the conference were packed with new technologies and truly exciting projects.

I'd personally love to experience a conference like this in person, but for now, that's clearly impossible.

Great news with the announcement of .NET 5 and its improvements; of course, I really enjoyed the various Blazor sessions since I believe it can outperform JavaScript, at least within the .NET enterprise environment.

A final note: I really like the improvements included in .NET, especially for C#, which is where I work most. But what I saw of xamarin.forms on mobile was fantastic, and if I get the chance, I'll definitely give it a try.