The .NET Stacks #26: .NET 5 has arrived, let's party

This week, we look at the .NET Conf content and also discuss the buzz around dependency injection.

20 Nov 2020

Note: This is the published version of my free, weekly newsletter: The .NET Stacks—originally sent to subscribers on November 16, 2020. Subscribe at the bottom of this post to get the content right away!

Happy Monday, everybody! I hope you have a wonderful week. We’ll be covering a few things this morning:

.NET 5 has arrived
Dependency injection gets a community review
Last week in .NET world

🥳.NET 5 has arrived

Well, we made it: .NET 5 is officially here. This week, Microsoft showed off their hard work during three busy days of .NET Conf—and with it, some swag including my new default Visual Studio Code theme. I’m starting to wonder if overhyping Blazor is possible—as great as it is, I wish Microsoft would dial it back a bit.

Anyway: we’ve spent the better part of six months discussing all the updates (like, my favorite things, Blazor’s readiness, the support model, what’s happening to .NET Standard, EF Core 5, app trimming, System.Text.Json vs. Newtonsoft, and so much more).

I know you’re here for the .NET Conf links—so let me be of service. You can see all the talks from this YouTube playlist, but the highlights are below.

From the Microsoft perspective, we had the following sessions:

The Scotts welcome you to .NET 5.
Mads Torgersen and Dustin Campbell talk about C# 9, and Phillip Carter introduces F# 5.
Immo Landwerth and Phillip Carter port projects to .NET 5.
Jeremy Likness and Shay Rojansky talk about Entity Framework Core 5.
James Newton-King discusses high performance with gRPC.
Steve Sanderson and Safia Abdalla talk about Blazor in .NET 5, and Daniel Roth and Javier Calvarro talk about integrating it with ASP.NET Core.
Rich Lander, Jan Kotas, and Stephen Toub dive deep on the .NET 5 runtime.
Scott Hanselman updates his site to .NET 5, live.
Chris Sfanos and Dmitry Lyalin provide a .NET desktop development update.
Claire Novotny and Layla Porter provide a .NET Foundation update.
Maddy Leger and David Ortinau roll out Xamarin.Forms 5.
Glenn Condrong and David Fowler talk about microservices with Project Tye.
Kathleen Dollard and Rainer Sigwald get to know the .NET 5 SDK.
Leslie Richardson talks about debugging in Visual Studio with Mark Downie.
Robert Green and Brady Gaster talk about HTTP API development with .NET, Azure, and OpenAPI.
Jon Galloway talks with David Wengier about C# source generators.
Eilon Lipton shows off Blazor Mobile Bindings.

From the community:

Carl Franklin talks about application state in Blazor apps.
Ed Charbeneau talks about Blazor stability testing tools.
Vaibhav Gujral talks about Azure Static Web Apps.
Veronika Kolesnikova talks about ML.NET, Azure, and Xamarin.
Menaka Basker architects cloud native apps in Azure with .NET Core.
Bryan Hogan discusses Polly.
Lizzy Gallagher discusses .NET Core migration at enterprise scale.
Nico Paez talks about testing with extension methods and fluent interfaces.
Zaid Ajaj builds React applications with F#.
Eduard Keilholz gets real-time insights from serverless solutions.
Luis Beltran discusses AI enrichment with Azure Cognitive Search.
Florian Rappl talks about microfrontends with Blazor.

💉 Dependency injection gets a community review

During the day job, I’ve been teaching infrastructure engineers how to code in C#. With plenty of experience with scripting languages like PowerShell, explaining variables, functions, and loops isn’t really a big deal. Next week, however, I’ll have to discuss dependency injection and I’m not looking forward to it. That’s not because they won’t understand it, because they’re very smart and they definitely will (eventually). It’s because it’s a head-spinning topic to beginners but is essential to learn because ASP.NET Core is centered around it.

If you aren’t familiar with dependency injection, it’s a software design pattern that helps manage dependencies towards abstractions and not lower-level implementation details. New is glue, after all. In ASP.NET Core, we use interfaces (or base classes) to abstract dependencies away, and “register” dependencies in a service container (most commonly IServiceProvider in the ConfigureServices method in a project’s Startup class). This allows us to “inject” services (or groups of services) only when we need them.

Right on cue, this week’s edition of .NET Twitter Drama included the discussion of a Hacker News article criticizing the ASP.NET Core DI practice as overkill. The article mirrors a lot of HN: .NET rants with some valuable feedback nested inside.

In my experience, DI in general is a difficult concept to learn initially but sets you up for success for maintaining loose coupling and testability as your project matures. However, the initial ceremony can drive people away from ASP.NET Core as developers can view it as overkill if they think their project will never need it.

I do think the conversation this week helped folks understand that working with settings is very ceremonial and can lead to confusion (just look at the options pattern). This might foster .NET team discussions about doc updates and how to provide a better experience when working with configuration. A boy can dream, anyway.