In a recent post I looked at a new API,
Task.WaitAsync(), introduced in .NET 6. This new API was pointed out to me by Andreas Gehrke on Twitter, but it raises an interesting point: how can you keep track of all the new APIs introduced in new versions of .NET? I received this question recently, so I thought I would quickly document some of the sources I use to stay up to date when a new version of .NET is released.
Read the blog posts
Every new release of .NET includes a bevy of blog posts. For example, this is the post for the .NET 6 release, which contains links to similar posts specific to ASP.NET Core, Entity Framework, .NET MAUI and more! These posts are often the best place to start, as they give you both a high-level overview and detailed instructions on many new features.
Watch the .NET Conf videos
I'm a big fan of blog posts, but if you prefer to learn from videos, all the recent .NET releases have been announced at the online-only .NET Conf. This consists of hours of content from presenters covering everything from what's new in the latest version of .NET, to getting started with your first application. There's a lot of community contributions too, so you can find a wide variety of speakers and content.
Check the documentation
In addition to the announcement blog posts, Microsoft provide upgrade guides and breaking change lists for each version of .NET on https://docs.microsoft.com. For example, this link shows the breaking changes between .NET 5 and .NET 6.
Each breaking change has its own link describing what changed, why, when it was introduced, and the recommend action. This list is invaluable when you're upgrading a new project. The majority of changes won't affect you, but I strongly recommend reading through the list and doing your due diligence!
Listen to the community
The official channels (blog posts/documentation/.NET Conf) are a great way to find out about most of the features released in a new version of .NET, but you can always find additional content created by the community. This often has a different focus than the official Microsoft channels, so I strongly recommend keeping an eye out. Personally, I source most of my community content from Twitter, from RSS feeds, and from the .NET community standup.
I primarily consume written content, but there's plenty of .NET content available in other forms too. For example, Nick Chapsas has a huge following on YouTube while Jeff Fritz regularly streams on twitch. On the podcast side, I subscribe and listen to the following .NET-related podcasts (among others!)
- .NET Rocks
- Adventures in .NET
- Azure DevOps Podcast
- Herding Code
- Merge Conflict
- No Dogma Podcast
- The .NET Core Podcast
- The 6 Figure Developer
- The Unhandled Exception Podcast
- Weekly Dev Tips
Try out the previews
.NET is developed in the open on GitHub, and the first preview releases of the next version are shipped shortly after the previous stable version is released! The first previews of .NET 7 were shipped in February 2022, just 3 months after the release of .NET 6.
These releases always come with associated blog posts describing what's new, and can be a great way of staying on top of what's coming down the pipeline for the next version. Even if you don't actually install and use the preview versions, it can be handy to read these blog posts. Keeping on top of the changes in small chunks is often easier than trying to digest everything that's new in a stable release in one go. And if you do try out the preview builds, you can shape the final results by raising issues or comments on GitHub.
Following the GitHub repositories
As I already mentioned, .NET is developed in the open on GitHub, so you can see pretty much everything that happens by following the https://github.com/dotnet organisation. Depending on where your interests lie, you might want to watch one or more of the following:
- https://github.com/dotnet/runtime - The .NET runtime and libraries
- https://github.com/dotnet/aspnetcore - ASP.NET Core
- https://github.com/dotnet/efcore - Entity Framework Core
- https://github.com/dotnet/roslyn - The Roslyn compiler
- https://github.com/dotnet/fsharp - The F# compiler and core libraries
There are many more libraries, but be warned, these are very high traffic repositories, trying to keep up with everything as it happens can be very tricky. But for digging into a new feature in depth, learning to navigate these repositories is hugely rewarding.
Viewing the API diffs for the base class libraries
This last point is one of the lesser known options for learning about changes in new versions of .NET. In the https://github.com/dotnet/core repository, you can find release notes for every versions of .NET. These include the usual links to downloaders and documentation, but one option I find incredibly useful is the api-diff list.
The api-diff describes all of the API changes for the core .NET libraries (and for ASP.NET Core / Windows desktop) for a given version. For example, if you check the api-diff for System.Threading.Tasks for .NET 6, you'll see all the
WaitAsync() methods that were added to
Task<T> (as well as the new
It's certinaly not necessary to look through all of these API diffs when a new version of .NET comes out, but personally I find it very useful for turning up small quality-of-life improvements that aren't big enough to be mentioned elsewhere. For example, did you know that you can now control the behaviour of your app if a
BackgroundService throws an exception? There's a breaking change in the documentation about it, but you could also spot it by looking at the api-diff for Microsoft.Extensions.Hosting:
If you want to learn how to use the new APIs, and how they interact with other features, then you'll inevitably need to dig into the code in the repository (or read the docs), but I really like the diffs for showing a high-level overview of what's changed, without getting bogged down in implementation details.
.NET is big, so keeping up with all the changes in a new release can be a big ask. In this post I described some of the content and resources I use to understand the high level features introduced in a new version, as well as the implementation details. I typically get my primary overview from the announcement blog posts and documentation, while I dig into implementation details on GitHub, and get alternative descriptions from the community. I also showed the api-diff feature on GitHub which lists the API changes in easily-consumable interface-like diffs.