Archive for the .NET Core category
Vaughan
July 7, 2020
Performance with ref readonly returns
When looking at performance of an application, there is a trade off between when you should be using value types and when you should be using reference types. People often talk about minimizing allocations to the heap for reference types but allocations themselves are actually very quick. The reason why its an issue is that […]
Read more
Vaughan
June 30, 2020
Understanding default interface members in .NET Core
A new feature in C# 8.0 and .NET Core 3.0 is that of default interface members. The motivation for it is where authors of a public interface would like to add functionality to an existing interface but don’t want to force all the consuming code to implement it. You are able to add a default […]
Read more
Vaughan
June 23, 2020
Using the new Index and range operators
A great C# feature that was recently released is the new Index and Range operators. Two new system objects were created to make accessing elements or range of elements in arrays shorter and more convenient. Index You can now index an array from the end of the array instead of using Array.Length. To be honest, […]
Read more
Vaughan
June 17, 2020
A case for pattern matching
Over the years developers using more functional languages like F# have boasted about how much easier their code is to read and how imperative C# can be. NO LONGER! Well maybe not much longer. We are starting to move in the right direction with pattern matching as a good replacement for switch statements. switch statements […]
Read more
Vaughan
June 16, 2020
Why is async void return bad?
When writing async code, your method is allowed to return either void, Task, Task, or ValueTask). Since early on with async code, the advice has been to not use void return methods. But in real life there are times when you don’t really have a choice. Since we can’t always get away from using them, […]
Read more
Vaughan
June 11, 2020
Running a .NET Core HostedService as a Windows service
If you need to run your long running .NET Core worker application on a windows server, you can easily install it as a windows service with minimal changes. Just add the following package. Microsoft.Extensions.Hosting.WindowsServices Then all you have to do is add UseWindowsService() to your host builder and its ready to use. public static IHostBuilder […]
Read more
Vaughan
June 9, 2020
When to consider using ValueTask over Task with async code
As of .NET Core 2.0, you can use ValueTask and ValueTask as return types for your async methods. Its important to understand when and if you should use these instead of a Task and what the trade-offs are if you decide to use it. I would say that if you aren’t measuring the performance of […]
Read more
Vaughan
June 3, 2020
Counting sheep with BenchmarkDotNet
When trying to improve the performance of your code, the first thing you need to do is measure. If you don’t measure then you won’t know if your changes are actually improving performance. In most cases, there is a trade-off between readability and performance. Often better performing code is more complex and harder to maintain. […]
Read more
Vaughan
June 1, 2020
Using a custom action constraint to version an endpoint in ASP.NET Core
There are times where you want to add a new action with the same route but you don’t want to break backwards compatibility. One option that could help with this is to use a custom action constraint. I’ve created a controller with two endpoints that have the same route. The Get action could be the […]
Read more
Vaughan
May 28, 2020
Why concurrency with async beats parallelism for scalability
Two terms that are often used interchangeably are concurrency and parallelism. It doesn’t help that in English, doing something concurrently means that you are doing more than one thing at a time. In software its a little more complicated. A good explanation on the difference that I have read before is as follows: Concurrency You […]
Read more