Hey, I'm Steven a .NET Developer and Freelancer in Zurich, Switzerland. I am a Microsoft MVP. Also, this blog is open source on GitHub.
Blazor comes with the option to prerender your webpage on the server. This works for the client-side version as well as the server side version of Blazor.
Let's have a look how does it work and what might be some pitfalls and how can we come around those.
Did you know that you can spend 100x times longer depending how you compare your enums?
Of course we are speaking here in terms of nanoseconds but this story is much more then just numbers. We'll also talk about boxing and unboxing. So let's dive right into it.
Since .NET5 we have the ability to "virtualize" a component.
But what exactly is that and how do we use it?
This blog post will show you a lot of details about the <Virtualize> tag.
Since the introduction of C# 2.0 we have the yield keyword with in combination with the IEnumerable<T> type works as a generator function. We can return elements one by one.
But how does that thing work internally? And what does it have to do with async / await?
Since .NET Core 2.0 the Type ValueTask. It seems that there is a lot of overlap between Task and ValueTask.
So let's have a deeper look into ValueTask. Where should we use it and how should we use it properly? And also: where we should not use is.
You probably are well aware of the Lifetime Scope for ASP.NET Core website.
There are basically 3 scopes: Transient, Scoped and Singleton. Let's have a look how they differ in Blazor Client and Server.
In the blog post we will look a bit into branch prediction. What is it and how can it impact our code?
To explore this we will be Thomas the Signalman, which works at a very busy railroad.
If you ever needed a massive amount of data processed in parallel you might had a look at OpenCL or CUDA. Both are based on a subset of C to describe the program your GPU has to execute.
So let's have a look how we can achieve this in the .NET way. Furthermore I'll give you some insights about GPGPU (General-purpose computing on graphics processing units) in general. Also some limitations and big differences to conventional "CPU"-Programming.
Besides the big announcements of .NET 6 there are also some smaller features. I want to show case a special one: static abstract interfaces. With this you have ability to extend the contract in that sense, that an implementing class has to provide also static methods. This feature is right now flagged as preview, but you can use it if you want.
This also enables generic math operations on an interface level.
Enumerations are one of the fundamental value types in C#. enum's are handy if you have a constrained set of allowed values.
But the enum type also has a lot of drawbacks. Personally, one major issue for me is that you can't define methods inside the enum. Plus, you can just pass them invalid values and it just works (Todd Howard I'm looking at you).
So why not make a lightweight alternative which removes a lot of the shortcomings of an enum?