Item — HN Reader

I haven't used C#/.NET since .NET 4 - I remember it was great, yet heavily tied into Visual Studio, and forget about using CLI for things like most other languages. It was all GUI or nothing. Insurmountable XML files.

How are things these days with .NET 10! Jesus, 10!

Dudes who use it daily, what is your favorite feature you think?

9 comments

Favorite recent language feature is a big investment in C# pattern matching. It's a big feature from the functional programming world rare to see in "Enterprise" languages.

Favorite recent runtime feature is all the cool low level stuff opened up by Span<T> (and Memory<T>). It has a similarity to Rust borrowing, but well integrated into the CLR's existing type system. It has opened all sorts of performance code possibilities that is still memory-safe/type-safe with fewer needs for falling back to "unsafe" operations. This is not just exciting because it is an interesting playground if you like low-level programming, but also because it has been a performance flood lifting all boats in the .NET ecosystem. A lot of code over the last few years has gotten easy performance boosts by just recompiling (because the compilers were taught to prefer Span/Memory overloads when they get added; no change to C# or F# code, just the compiler picking a new performance path).

Definitely change for F# code, some of those Span overloads broke type inference. Also, certain APIs even removed their non-Span overloads between .NET versions, which was a straight up breaking change for every language other than C#.

The biggest change for me has been the ability to deploy my web sites to a Linux box instead of having to deal with IIS.

WinForms app development hasn't changed one bit in 25 years.

If you code in C# then they've added some nice new language features every year to make your code a little tidier.

And the whole framework is totally open source now, which is a bonus.

There's nothing I'm really asking for. It does pretty much everything I need these days.

Very different. That was the .NET I knew in college, .NET Core really changed the game. I personally use CLI just for EF Core (ORM) but Rider support is there so you're not tied to VS.

My fav feature is honestly how little boilerplate I need compared to Spring Boot and the syntax sugar is honestly really nice.

My favorite feature, especially considering the past of "heavily tied into Visual Studio" is the platform independent nature of (most of) "modern" dotnet. That is to say, I run Fedora on my laptop, and I do not want Windows, yet I don't feel like a second class citizen and dotnet runs well and is available from repositories that Microsoft provides for various Linux distributions (it just hit me how strange this is, for _Microsoft_ to offer official repositories for Linux operating systems...).

I also really like that its development is fairly open (it's on github). From a more technical point of view, I think C# is a slightly better Java. A pretty nice language overall. It's not gui-or-nothing with dotnet core so it's not too difficult to create workflows for ci/cd pipelines, although the .net framework solutions we still have aren't too much harder to script: msbuild is pretty capable.

The version numbers used to increase much more slowly. Since the .NET (modernized / cross platform) core "track" the version number increments every year.

The version increments roughly every 6 months. It's almost the exact same update cadence as NodeJS: LTS versions are even numbers released in the Fall and STS versions are odd numbers released in the Spring. STS often focuses on "bleeding edge features" and LTS often on performance and stability. (Though both are year round projects and there are bleeding edge features in an LTS and perf/stability fixes in an STS.)

https://learn.microsoft.com/en-us/lifecycle/products/microso...

The last 5 version have been released a year apart, in Novembers.

It's still stuck in weird formats and monoliths. A lot of GUI-only stuff has been ported to the mega CLI, but it's still the weird Visual Studio format plus XML files that you cannot replace with a simple Makefile. You still can't just compile a bit of C# as-is, it must have the Solution, Project, Assembly etc. chain, the run-as-script feature is nice (lots of cheers when that was presented! even on the live stream), but it's specifically not designed to allow you to assemble a toolchain that works for what you need. There is only one and it has everything, no options.

The question, of course, becomes: when does that matter? For a lot of people who are in to .NET, they see that as a benefit. Look at Go through this lens, and it's similar; the go CLI is the compiler, linker, package manager etc. I suppose the biggest difference is that it doesn't prescribe solutions and projects and file formats to go with them, which enables you to put this in any existing CI, make or other system.

> it's still the weird Visual Studio format

.NET 9 (and VS2022) added support for the SLNX replacement format to replace the old weird solution format:

https://devblogs.microsoft.com/visualstudio/new-simpler-solu...

Yep, but you still can't say "compile and link everything in this tree". Technically, the language can, but the framework assumes specific compiler, linker and layouts on the filesystem so at that point you can't. It really wants that editor-related stuff to be part of the framework, and everything else has to bend for it.

A Project file today can just be a full tree glob. New projects start out in that form. The `dotnet` CLI is still going to assume some default output paths as it builds object files and executable assets, but those are all easily flag configurable today. (I've done some wild CI things.)

You don't have to use a Solution at all with the CLI, you can do everything in a single Project and one full tree glob. (Technically you haven't need a Solution with Visual Studio for a long while either, if you don't mind it sometimes auto-creating them at compile time, and even then you can just .gitignore .sln and not care. But even that random auto-.sln file thing has disappeared in recent years and Visual Studio has learned more auto-workspace tricks from VS Code.)

I have started projects that just did that, started with a simple glob-only project and no prescribed file layout.

Yeah, dotnet doesn't let you micro-manage the linker specifically, but few languages since C++ do and arguably the C/C++ linker sometimes seems as much a bug of C/C++ as a feature in modern times.

Everyone here missing some the main features of modern dotnet: cross-platform by default with the new runtime, CoreCLR (no more Mono).

Additionally, blazingly fast, especially as they continue to use stronger memory-aware primitives like Span<T> under the hood, and back that work with code in System.Numerics that continues to lean into hardware intrinsics.

C# itself is also an incredible language, much maturing since .NET 4. Things like Source Generators, record types, collection expressions... you can be _nearly_ as terse as something like python but with all the added benefit of C#'s type system (AND you get LINQ!).

People act like C# is some weird hanger-on dinosaur of a previous age of "tech" that people hang on to out of stubbornness, but IMO it's one of the most forward thinking languages today with an incredibly powerful runtime to boot.

.NET 4 doesn't exist and was avoided on purpose. There was a .NET Framework 4, but after Framework was abandonned in favour of Core they dropped the core suffix and skipped to 5.

> NET 10! Jesus, 10!

Well, spiritually this is the 13th(?) major version of .NET (possibly more if we count Silverlight's runtime). You missed the part when there was .NET Core 1-3 alongside the old .NET Framework 4.8., and then they skipped Core 4 and stopped supporting Framework so they could finally fix their naming scheme.