- 12/2/2024
- 3 minute read
Having fun with ValueTuple
Just as a heads up: This blog post will probably bring you 0 value in your daily life - well, maybe a short smile. Let's put ValueTuple to its extreme!
All posts with Tag .NET
- 11/25/2024
- 5 minute read
"Always use early returns" - LinkedIn Edition
Ahhhh dear LinkedIn - a pool of gems where everyone is expert in everything. Over the time I collected some trophies from there and today I want to discuss one of them: "Always use early returns".
- 11/11/2024
- 6 minute read
An awaitable Blazor Modal Dialog
I already showcased a simple modal dialog in a previous post. However, the dialog was not awaitable. In this post, I'll show you how to create an awaitable modal dialog.
- 10/21/2024
- 19 minute read
Comparing the performance between the Minimal API and classic Controllers
Today, we are going to benchmark the performance of the Minimal API in ASP.NET 9 (and for reference against ASP.NET 8 as well) against the classic Controllers. We will test a few scenarios and check how the performance of the Minimal API compares to the classic Controllers. Let's get right into it!
- 9/30/2024
- 4 minute read
xUnit v3 and some stuff about TUnit
I know that there is a lot of fuse about TUnit and I am here writing about xUnit. I might cover TUnit in the future, but for now, the topic is the v3 prerelease of xUnit!
- 9/27/2024
- 2 minute read
Fullstack Web Applications with .NET, Nx and Angular Seminar
Join us for an exciting seminar with Fabian Gosebrink about .NET 8, Nx, and Angular! Learn the latest trends and best practices. More details: here
- 9/16/2024
- 3 minute read
Managing TaskCancellationTokens in a central service in ASP.NET
In async code it is very common to pass a CancellationToken to the method that is being awaited. This allows the caller to cancel the operation if it is no longer needed. But this will lead to some ceremonial code that is repeated in every method. In this article I will show you how to manage CancellationToken in a central service in ASP.NET.
- 9/9/2024
- 2 minute read
LINQ Joins on multiple columns in Entity Framework
I came across a very annoying "issue" with LINQ joins (left joins) in Entity Framework where the compiler drove me nuts!
- 9/2/2024
- 3 minute read
How to test HttpClient inside API Tests
I am a great fan of API tests. I do like to utilize the WebApplicationFactory for this. I even wrote some articles about this in the past "Introduction to WebApplicationFactory". But what if we need to "mock" HttpClient calls inside our tests?
- 8/19/2024
- 2 minute read
FormattableStringFactory - Creating dynamic FormattableString instances
I recently came across the FormattableStringFactory to create dynamic FormattableString instances. This is a very useful feature in combination with safe SQL queries and the SqlQuery method of Entity Framework Core.
- 8/12/2024
- 5 minute read
async2 - The .NET Runtime Async experiment concludes
The .NET team has been working on a new experiment called async2, which is a new implementation of the async/await pattern that is designed to be more efficient and more flexible than the current implementation. It started with green threads and ended with an experiment that moves async and await to the runtime. This post will cover the journey of async2 and the conclusion of the experiment.
- 8/5/2024
- 1 minute read
Organizing Parameters in Minimal API with the AsParametersAttribute
Even though it was introduced in .NET 7, I came across recently the AsParametersAttribute. Let's have a look what it is good for.
- 7/29/2024
- 4 minute read
How many API's does .NET have?
.NET is big, very big! So how many API's does it have? Let's find out!
- 7/22/2024
- 5 minute read
The state machine in C# with async/await
You often here that the async/await keywords leads to a state machine. But what does that mean? Let's discuss this with a simple example.
- 7/15/2024
- 6 minute read
How not to benchmark!
I came across a recent LinkedIn post about the let statement in LINQ and it's performance implication. And in typically influencer fashion it out right claimed that using let in LINQ is a bad idea and should be avoided. But is it a bad idea?
- 7/8/2024
- 1 minute read
UUID v7 in .NET 9
.NET natively knows UUID v4 aka Guid.NewGuid(). But with preview 7 we get Version 7 of UUID's natively.
- 7/2/2024
- 7 minute read
Codespaces for your open-source project
In this blog post, I will show you how to use GitHub Codespaces to make it easier for contributors to get started on your open-source project. We will set up a codespace for a .NET repository and configure it to install the required dependencies and tools.
- 6/26/2024
- 2 minute read
ReadOnlySet<T> in .NET 9
The next preview (preview 6) will bring a new type ReadOnlySet<T>. This is a read-only set that is similar to ReadOnlyCollection<T>. Let's see how it works and why it was introduced.
- 6/21/2024
- 6 minute read
NCronJob - June Edition
The last update of NCronJob was some time ago - and as always, there are some new features in the meantime. So here we are, let's go through to highlight them!
- 6/17/2024
- 3 minute read
Are my EF LINQ to SQL queries safe?
Have you ever asked yourself if your EF LINQ queries are susceptible to SQL injection attacks? Either because you are querying some user data from a text field or directly taking whatever your API hits against the database?
- 6/10/2024
- 2 minute read
Does an HttpClient await the Header and the body?
If you call HttpClient.GetAsync or HttpClient.PostAsync and then await the result, does the await wait only for the headers to be received or does it wait for the body to be received? Let's find out!
- 6/3/2024
- 8 minute read
StringBuilders magic for very large strings
The StringBuilder class is used to create mutable sequences of characters. Strings are immutable, so if you need to perform multiple operations on a string, it is better to use a StringBuilder instead of a string. This is especially useful when you need to concatenate a large number of strings. But there is more magic to it, especially when we go BIG!
- 5/28/2024
- 2 minute read
Cancel WhenAny - linked CancellationTokenSource
In today's short post, I will show you how to cancel a Task with multiple inputs (aka multiple CancellationTokens) using CancellationTokenSource and CancellationTokenSource.CreateLinkedTokenSource.
- 5/23/2024
- 2 minute read
Help my memory dump always shows me some exceptions!
I made a memory dump in my simplest console application and there are a bunch of exception instances around, what is going on? Let’s see in this blog post, why you see a few exception instances in your memory dump.
- 5/20/2024
- 5 minute read
MemoryCache, DistributedCache and HybridCache
The latest preview (.NET 9 preview 4) brought another caching structure to the .NET world - so let's order some things here.
- 5/16/2024
- 2 minute read
Generate http files from a swagger definition
Http files are nice and handy - but they are also a bit of a pain to update. So why not generate them from a swagger definition?
- 5/13/2024
- 4 minute read
NCronJob - Big Updates
Since the last blog post a lot has happened and many new features have been added to NCronJob. In this blog post I would like to introduce you to the new features and explain how you can use them.
- 5/6/2024
- 5 minute read
Boosting Productivity with Analyzers
I am a big fan of Analyzers, and in this blog post, I will showcase some of my favorite ones!
- 5/2/2024
- 4 minute read
Checking your solution for NuGet vulnerabilities or deprecated packages
While your software might be the best in the world, it's only as good as the libraries it uses. In this small blog post, we will discover how to check your solution for NuGet vulnerabilities or deprecated packages.
- 4/29/2024
- 6 minute read
How does a List know that you changed it while enumerating it?
Everyone falls for that and tries to change a list while enumerating it greeted by the System.InvalidOperationException: Collection was modified; enumeration operation may not execute. message. But how does the List know that you changed it? Let's find out.
- 4/23/2024
- 7 minute read
Does readonly make your code faster?
In this blog post we will discover whether or not the readonly modifier can make your code faster. So without further ado let's get started.
- 4/15/2024
- 3 minute read
Fluent API to await multiple calls and get their respective results
Sometimes, you have multiple async calls to make, and you want to do that asynchronously and get the results afterward. Let's build a fluent API to do that.
- 4/8/2024
- 2 minute read
Equip 3rd party types with a deconstructor
Deconstructor are a C# language feature that allows you to define a method that will be called when an object is being split up into its components. While this is straightforward to implement for your own types, it is not possible to add a deconstructor to a 3rd party type - or is it?
- 4/1/2024
- 4 minute read
Pattern matching and the compiler can be surprising
Pattern matching is a powerful feature in C#. It allows you to match a value against a pattern and extract information from the value. The compiler does the magic for you - and sometimes it struckles with that.
- 3/25/2024
- 1 minute read
C# 13: Allow ref and unsafe in iterators and async
C# 13 might get a new feature soon that allows ref and unsafe in iterators and async methods.
- 3/18/2024
- 3 minute read
NCronJob - Scheduling made easy
Hangfire/Quartz or BackgroundService? Why not something in the middle? Did you ask yourself this question from time to time? Do you want to have a full-blown job scheduler with lots of setups, but more than BackgroundService is needed?
Meet: NCronJob!
- 3/11/2024
- 7 minute read
bUnit v2 - The Blazor unit testing library vNext
Next to the big release of .NET 8, we also released the first preview bUnit v2. This release is a major release, with a lot of new features and improvements. In this post, I will highlight some of the most important changes. This includes new features but also some breaking changes.
- 3/5/2024
- 1 minute read
Typesafety in xUnit with TheoryData<T>
I recently discovered this small but very useful utility in xUnit: TheoryData<T>.
- 2/27/2024
- 6 minute read
Lock statement patterns
A few weeks back, I wrote an article "A new lock type in .NET 9" where I showcased the new Lock type. Nothing fancy - well, at least it was more expressive. But now the dotnet team went a step further with this!
- 2/20/2024
- 4 minute read
Avoid multiple boolean parameters
Boolean parameters are nice, but it's hard to keep track of what each one does when you have multiple of them. In this blog post, we will see why it's better to avoid multiple boolean parameters and how to refactor them.
- 2/14/2024
- 1 minute read
LINQ MindMap: .NET 9 Edition
After my first LINQ MindMap: Here is an updated version that includes everything up until .NET 9.
- 2/11/2024
- 1 minute read
Garbage Collector (over)simplified
In this blog post, a small and (over)simplified infographic on how the Garbage Collector works.
- 2/2/2024
- 1 minute read
SearchValues object become better with .NET 9
SearchValues, which were introduced with .NET 8 will become an upgrade and becomes more usable! Let's see how.
- 1/27/2024
- 2 minute read
Three new LINQ methods in .NET 9
Even though we are in the alpha of .NET 9 and .NET 8 was released not more than two months ago, the dotnet team does not sleep and pushes new changes! In this blog post, we are checking what new methods were added to everyones favorite: LINQ.
- 1/20/2024
- 9 minute read
A replacement for BinaryFormatter in .NET 8
In the old .NET Framework days, you could use the BinaryFormatter class to serialize and deserialize objects. This can be convenient for cloning or storing some session states. As the BinaryFormatter has some serious security concerns, the .NET team marked it as obsolete (as error) in .NET 7 and onwards.
- 1/16/2024
- 3 minute read
An alternative to AutoMapper
I am not the biggest fan of AutoMapper. It starts with good intentions but often ends up being a big mess. I have seen it used in many projects, and the configuration of the mappings is often scattered all over the place, and or they are huge!
- 1/10/2024
- 3 minute read
Const strings are not so const after all
We know the const keyword with strings - but are they really constant after all? Or can we use some tricks to modify them? Let's see.
- 1/3/2024
- 7 minute read
An asynchronous lock free ring buffer for logging
In this blog post, I showcase a very simple lock-free ring buffer for logging. I'll show why it's useful and how it works.
- 12/27/2023
- 3 minute read
A new lock type in .NET 9
There is a new sheriff in town when it comes to the lock keyword, And that is the new System.Threading.Lock type that is introduced in .NET 9. And yes, I know - we still need time to digest the big .NET 8 release.
- 12/20/2023
- 2 minute read
The first possible new feature of C# 13: Params collection
Only one month after the big release of .NET 8, the dotnet team is already working on the next iteration: .NET 9. With that also comes new language features. The first one is about to be merged into the main development branch: Params Collections.
- 12/14/2023
- 2 minute read
Entity Framework - Storing complex objects as JSON
From time to time, it is nice to store complex objects or lists as JSON in the database. With Entity Framework 8, this is now easily possible. But this was possible all along with Entity Framework 7.
- 11/28/2023
- 7 minute read
A journey about the new interceptors of .NET 8
This blog post describes my journey writing a new interceptor for .NET 8. This is not meant as a general tutorial, even though I will showcase some of the code samples.
- 11/22/2023
- 4 minute read
Blazor .NET 8 - Enhanced Form Navigation
There are many new cool features with .NET 8 and Blazor in particular. In this blog post, I want to highlight a feature that I believe is very useful in the new context Blazor is living.
- 11/15/2023
- 2 minute read
A more flexible and enhanced way of logging in .NET 8
The latest version of the .NET (version 8) has introduced a "better" way of logging. This new way of logging is more flexible and enhanced than the previous versions. It is about the LoggerMessageAttribute.
- 11/10/2023
- 2 minute read
Interactive LINQ tutorial, especially for beginners
LINQ (Language Integrated Query) is a powerful feature of C# that allows you to query data from different data sources. It is a must-have skill for every C# developer. That is why I created: https://linqmarbles.info/
- 11/1/2023
- 2 minute read
Yes you can create classes on the stack!
In this article we will create a class, aka a reference type on the stack, and therefore don't use any managed memory!
- 10/25/2023
- 1 minute read
Interfaces can have private methods
Let's drop some "useless" knowledge here. Interfaces can have private methods. This comes with the C# 8 feature: "Default interface methods".
- 10/18/2023
- 4 minute read
Blazor with TailwindCSS
Ever wondered how to use TailwindCSS with Blazor? Let's make it work!
- 10/11/2023
- 5 minute read
Structured Concurrency in C#
Did you ever hear about "Structured Concurrency"? If not, this article is for you. We will discover what it is, why it is useful, and what it could look like in C#.
- 9/29/2023
- 5 minute read
Questions I asked as .NET interviewer
This blog post is a small collection of questions I asked as a technical interviewer when we had candidates for software developer positions. This might be helpful for you if you are preparing for a job interview.
- 9/24/2023
- 2 minute read
Less boilerplate code with the new primary constructor in C# 12
The new language feature "primary constructor" which will be released with C# 12 / .NET 8 this year (November 2023) allows you to remove some ceremonial code. Let's see how.
- 9/14/2023
- 11 minute read
Building a Minimal ASP.NET Core clone
In this article, we will build a minimal version of what ASP.NET Core does - yes, you read right. We will create a very simplistic clone of ASP.NET Core to discuss how the whole thing works. Beginning with a simple console application, we will add the necessary components to make it work as a web server. Bonus points for our own middleware pipeline and dependency injection.
- 9/7/2023
- 10 minute read
Enabling List<T> to store large amounts of elements
List<T> is one of the most versatile collection types in .NET. As it is meant for general-purpose use, it is not optimized for any specific use case. So, if we look closely enough, we will find scenarios where it falls short. One of these scenarios is when you have lots of data. This article will look at precisely this.
- 9/1/2023
- 3 minute read
Turn on Nullability checks by default
Since C# 8, we have nullable reference types. The word sounds odd, given the fact that reference types are always nullable. The idea is that the default is that your reference types have to be properly initialized. Here are my thoughts after a few years of using them.
- 8/27/2023
- 5 minute read
The "Weak Event" Pattern in C#
Events in C# are a powerful mechanism for decoupling components and enabling a publisher/subscriber model. However, they have a significant drawback: the publisher holds a strong reference to the subscriber, and this can cause memory leaks. This article describes a pattern for implementing weak events in C#.
- 8/21/2023
- 1 minute read
Expression-bodied members in properties
Are these two expressions the same?
public class MyClass
{
public int A { get; } = Random.Shared.Next(1000);
public int B => Random.Shared.Next(1000);
}
- 8/17/2023
- 2 minute read
Enum.TryParse unexpected behavior
Enums are very simple structures, but some functions like Enum.TryParse can have unexpected behavior. In this short blog post, we discover why and what are the alternatives.
- 8/12/2023
- 5 minute read
Creating Your Own Fakes Instead of Using Mocking Libraries
With respect to the current topic around Moq, I want to showcase how you can easily roll out your own fakes so that you are not depending on a third party library.¨
- 8/9/2023
- 6 minute read
What's going on with Moq? SponsorLink and burnt soil!
The famous Moq library faced some criticism due to the usage of SponsorLink. What is the problem, and what is going on here? And obviously, I will add all the sources to the articles.
- 8/7/2023
- 1 minute read
Keyed Services in the IServiceProvider in .NET 8 preview 7
The .NET 8 preview 7 will bring another exciting feature some of you probably awaiting for a long time: Keyed services.
- 8/2/2023
- 7 minute read
The combined power of F# and C#
Where C# is the most dominant language in the .NET world, other languages are built on top of the Framework that deserves their respective place. F# is strong when it comes down to functional programming! In this blog post, we will leverage the power of F# and C# to showcase where both excel!
- 7/30/2023
- 2 minute read
How to benchmark different .NET versions
With the famous BenchmarkDotNet library you can benchmark a lot - but it doesn't stop with a single .NET version. You can benchmark multiple versions of the same code that targets different runtimes!
- 7/24/2023
- 2 minute read
Gracefully Handling Entity Framework Exceptions with EntityFramework.Exceptions
Working with databases can sometimes be daunting, mainly when errors occur. These errors or exceptions can be due to many reasons, such as constraint violations, connection issues, or syntax errors. Entity Framework throws a generic DbException or DbUpdateException for most of these database issues. But we cand get more specific exceptions based on the concrete "problem"! That's where EntityFramework.Exceptions comes in.
- 7/19/2023
- 11 minute read
.NET Framework 4.8 to .NET 6 migration
I was recently tasked to migrate an application with around 150 projects from the "old"It is still supported .NET Framework 4.8 to a recent .NET 6. As the application is still under development and used, the migration should be done step by step over time in iterative steps rather than a big bang refactoring. This blog post will go a bit into more detail about how I approached the situation and what I learned.
This is a highly subjective post, and there are plenty of ways of approaching it - so take it with a grain of salt and mileage may vary.
- 7/13/2023
- 2 minute read
Three tricks with Dictionary
In this short blog post, I want to showcase three nice tricks you can do with everybody's favorite data type: the dictionary.
It is a versatile data structure, and we can make it even more versatile!
- 7/8/2023
- 3 minute read
Overload resolution in C#
On a recent LinkedIn Post from Saeed Esmaeelinejad, he asked what is the outcome of:
bool flag = SomeMethod();
M(flag ? 1 : 2);
void M(long number) => Console.WriteLine("long");
void M(short number) => Console.WriteLine("short");
What is the outcome?
- 7/3/2023
- 3 minute read
Why I like and prefer xUnit
In almost all of my projects, I only use xUnit, and here is a small love letter. Especially the one fact I do think makes it a good choice!
- 6/29/2023
- 8 minute read
LINQ: Select.Where or Where.Select?
LINQ is a very powerful tool for querying data. As the majority of functions are built on top of IEnumerable<T> and it, in most cases returns IEnumerable<T> as well, it is very easy to chain multiple functions together. That leaves you with a question: which one should I use, Select.Where or Where.Select?
- 6/25/2023
- 7 minute read
Missing Stack trace when eliding the await keyword
You may have heard that when you elide the await keyword in a method that returns a Task or Task<T>, you lose the stack trace. Buy why does that happen? Let's find out!
- 6/21/2023
- 10 minute read
Create your own Mediator (like Mediatr)
In this blog post, I'll show you the fundamentals of the Mediator pattern and how to implement it in your application from scratch. And yes, we basically implement the famous MediatR library.
- 6/13/2023
- 4 minute read
How does List work under the hood in .NET?
A List is one of the most used data types in .NET. You can dynamically add elements without taking care of how that happens. But do you know what is going on under the hood?
- 6/8/2023
- 5 minute read
Span / Memory / ReadOnlySequence in C#
There are many different memory types used in modern C# programs. The more common ones are Span<T> and Memory<T>. Occasionally there is also ReadOnlySequence<T>. What do these types do?
- 6/4/2023
- 2 minute read
Time abstraction in .NET 8
With the upcoming release of .NET, the team introduced an abstraction of time itself. That can bring you major benefits especially if you have to test scenarios where time is a crucial part! Until now, you had to create your own wrapper. This, of course, makes integration with 3rd party libraries tricky.
- 5/31/2023
- 3 minute read
New Terminal logger for .NET 8
With preview 4 of .NET 8, a new terminal logger was introduced. It basically removes a lot of the noise that the default logger produces. It also adds some nice colors to the output. Let's see how to use it!
- 5/28/2023
- 2 minute read
nameof get's a bit better in C# 12
The nameof operator is a great way to get the name of a variable, type, or member. With C# 12 it's getting even better. Let's see how.
- 5/26/2023
- 3 minute read
How does TryGetNonEnumeratedCount work?
TryGetNonEnumeratedCount attempts to determine the number of elements in a sequence without forcing an enumeration. It returns true if it could and false if it couldn't. The API was added with .NET 6 - let's have a look at how that thing works.
- 5/23/2023
- 4 minute read
6 useful extensions for IEnumerable
I did already write about some useful extension methods for Task and ValueTask. Today I want to show you some useful extension methods for IEnumerable.
- 5/18/2023
- 3 minute read
Some cool things you can do with ValueTuple
In this blog post, we will explore some cool things you can do with ValueTuple. Also, a short explanation of what ValueTuple is and how it works.
- 5/8/2023
- 3 minute read
Entity Framework and ordered indexes
In Entity Framework 7, the team has added support for ordered indexes to the fluent API. In this blog post we will look at how to use this feature and what it means for your database.
- 5/3/2023
- 2 minute read
Controlling the log level of your application
In this blog post, we will have a look at the different log levels and how to control them.
- 4/30/2023
- 6 minute read
Verifying your DI Container
Microsoft's integrated dependency injection (short DI) container is very powerful, but there are also certain pitfalls. In this article, I will show you what some of the pitfalls are and how you can verify them.
- 4/27/2023
- 3 minute read
Create your own Validationattribute in ASP.NET Core
In this small blog post, I will show you how to create your own Validation attribute in ASP.NET Core to tailor-made your validation rules.
- 4/22/2023
- 11 minute read
Domain events and the "Unit of Work" pattern
In this blog post, we will discuss the "Unit of Work" pattern and how it can be used to implement domain events in a DDD application. For that, we will also discuss how we can leverage middleware to implement the "Unit of Work" pattern in a .NET application. A lot of things are going to happen in this blog post, so let's get started.
- 4/17/2023
- 3 minute read
Covariance and Contravariance in C#
Let's talk about Contravariance and Covariance in C# using .NET Framework examples!
Contravariance and covariance are essential concepts in C# when dealing with generics, enabling us to have more flexibility when assigning generic types. So let's have examples straight from the framework itself!
Also, we will go a bit deeper and talk what some differences between generic constraints and things like Contravariance are.
- 4/13/2023
- 14 minute read
.NET 8 Performance Edition
As with every .NET release, Microsoft improves the performance of the runtime and guess what: This release is no exception to this. In this blog post, I want to go through some of the improvements made so far (.NET 8 preview 3).
- 4/10/2023
- 3 minute read
5 useful extensions for Task<T> in .NET
In this short blog post, I will show you 5 useful extensions for Task
- 4/5/2023
- 3 minute read
Source Generators and Regular Expressions
Source Generators are more and more an integral part of the .NET ecosystem. But how does that play together with everyone's favorite: Regular Expressions?
In this blog post we will dive in how we can leverage source generators in combination with regular expression to have a debuggable, but also very performant way of executing regular expressions!
- 4/1/2023
- 8 minute read
LINQ on steroids with SIMD
In this blog post, we will explore the use of SIMD instructions to speed up LINQ queries. We will use the Vector
- 3/31/2023
- 5 minute read
Creating a ToolTip Component in Blazor
In this blog post we will create a ToolTip component in Blazor from scratch. We will use the Blazor WebAssembly template to create a new project. We will then add a ToolTip component to the project and use it in the Index page. We will also add some styling to the ToolTip component.
The advantage over using a library is that we can customize the component to our needs as well as keeping it simple! So let's get started!
- 3/27/2023
- 5 minute read
C# Source Generators: How to get build information?
Source generators are a powerful feature introduced to C#, allowing developers to generate additional code during the compilation process automatically. They can help reduce boilerplate, improve performance, and simplify your codebase.
This blog post will introduce source generators, discuss how they work, and walk through an example of a source generator for generating build information.
- 3/24/2023
- 2 minute read
Leverage 'is not' Operator for Exception Filtering!
Did you know you can use the 'is not' operator with exception filtering to simplify and improve your error handling in C#?
In this short blog post, I will show you how to use it.
- 3/21/2023
- 8 minute read
Caching in .NET with MemoryCache
In this blog post, we will discuss how we can "cache" entries from the database. We will talk about why we would do this in the first place and how to achieve that.
Also, we will talk about some implications and what "cache invalidation" is.
- 3/18/2023
- 4 minute read
Write your own AutoMapper in C#
Sometimes you have to map an object to another representation in C#. And you think: Why isn't C# duck-typing capable?
You might hear of libraries like AutoMapper that do the tedious work of mapping one object to another with the same structure. This blog post will give a super simple introduction to how those libraries are working internally.
In the end a bit of a subjective topic on whether or not I would use such libraries.
- 3/14/2023
- 2 minute read
LINQ // Skip and Take
Skip and Take are used for pagination or limit the number of elements returned by a query.
Since C# 8 you can use Take with a Range. Let's see some examples.
- 3/11/2023
- 12 minute read
How to write your own cron Job scheduler in ASP.NET Core (like Quartz, Hangfire, ...)
In this blog post we will discover how to write your own small task scheduler / job scheduler with cron notation in ASP.NET Core. You might know similar approaches under the name of Quartz or Hangfire.
With the help of BackgroundService we will build our own, lightweight version of it.
- 3/8/2023
- 6 minute read
Benchmarking - A matter of perspective
In recent months and years, there was a certain hype around benchmarking, also in the .NET community.
This blog post is meant to ground some of the benchmarking topics and put this into relation to other things so you get a better understanding if it's worth the effort.
- 3/5/2023
- 3 minute read
Is a square a rectangle? Liskov substitution principle in action
I will put that simple question in the room: "Is a square a rectangle?" And you might thank: "Well dah, of course!"
But wait for a second and let's check it together. We will use the L in SOLID: The Liskov Substitution principle to check if this relationship makes sense for us!
- 3/2/2023
- 2 minute read
The Humble Object Pattern
The Humble Object Pattern is a design pattern to make especially unit testing easier with the goal of separating behaviors that are easy to handle (domain logic) from behaviors that are hard to handle (like external events or dependencies).
So let's have a look at what it is and how you can utilize it.
- 2/27/2023
- 5 minute read
Performance (ReadOnly)List vs Immutable collection types
A bit back on LinkedIn, there was a discussion about read-only collection and immutability where this is not the point I want to discuss now, as I already covered that here: "ReadOnlyCollection is not an immutable collection".
This post is just about the performance of those types compared to our baseline, the good old List<T>. It also explains why we see the results we see.
- 2/25/2023
- 4 minute read
From Testing Pyramid to Diamond
In this article, we will discuss the testing pyramid - what it is and what are some problems with that.
We will also discuss a different approach: The testing diamond.
- 2/22/2023
- 3 minute read
Getting git version information in your C# code
Did you ever need git-specific information like the latest tag or the current commit inside your C# code? Or even the semantic version number of your current build=
Well, there is an easy solution involving source generators.
- 2/19/2023
- 5 minute read
error NETSDK1194: The "--output" option isn't supported when building a solution.
Did you see the following error in recent days in your build-pipeline:
error NETSDK1194: The "--output" option isn't supported when building a solution.
If so - that is not necessarily your fault at all! Microsoft released a new SDK version, which breaks your builds. Let's see why and what we can do to tackle that.
- 2/15/2023
- 4 minute read
A (performance) quirk with JsonSerializer
System.Text.Json.JsonSerializer has a weird quirk in regard to performance and memory management. So we will discuss what is "wrong" with this code: JsonSerializer.Serialize(myObject, new JsonSerializerOptions(...));.
- 2/10/2023
- 6 minute read
What is a Middleware and how to use it in ASP.NET Core?
Did you ever ask yourself: What is a middleware, and why should I use it?
If so, this blog post is exactly for you. We will see where we could use a middleware and also how we can use the Dependecy Injection container of ASP.NET Core.
- 2/7/2023
- 12 minute read
Multi-Tenancy with RavenDB and ASP.NET Core
Multi-tenancy is a software architecture pattern where a single instance of a software application is used by multiple customers, with each customer having separate and isolated data, configurations, and resources. RavenDB is a NoSQL document database that provides a flexible and scalable solution for multi-tenant applications. This blog post will explore why multi-tenancy exists, the advantages of using RavenDB for multi-tenant applications, and provide code examples to get you started.
- 2/2/2023
- 8 minute read
Repository Pattern - A controversy explained
In this blog post, we'll dive into the ins and outs of the repository pattern and examine both its benefits and its potential drawbacks. We will start from the very basic to some more advanced use cases. So let's dive right into it.
- 1/26/2023
- 9 minute read
C# Lowering
Did you ever hear the word "compiler magic" or "syntactic sugar"? Probably yes and therefore we want to dissect what this "magic" really is!
We can see how we can predict performance or bugs by "lowering" our code. Also we will see how things like foreach, var, lock, using, async, await, yield, anonymous types, record, stackalloc, pattern matching, Blazor components, deconstructor, extension methods... do not really exist.
- 1/21/2023
- 5 minute read
Deep nesting - Why and how to avoid
... if you need more than 3 levels of indentation, you're screwed anyway, and should fix your program.
This is written in the Linux style guide. Let's see why they have that rule and how we can overcome deeply nested code.
- 1/18/2023
- 3 minute read
C# 12: Primary Constructors
Another new C# 12 feature might drop soon and makes its debut with the next iteration: Primary Constructors.
The blog post will talk about what a Primary constructor is, why we already have it, and what the proposal tries to change. Exciting times are ahead of us!
- 1/15/2023
- 3 minute read
Cohesion - An indicator for refactoring
Cohesion represents the degree to which the elements of a module belong together. A module or class is said to be highly cohesive if its methods and data are highly related, meaning that a change in one affects just a small number of elements.
We can use this metric to know whether or not an object is in a good shape or needs some refactoring.
- 1/11/2023
- 5 minute read
Easy Pagination for Entity Framework in 3 steps
Pagination is the process of dividing a set into discrete pages. In the context of Entity Framework, that means we are only getting a certain amount of entries from the database.
And we will implement a very easy solution to make that happen in 3 steps. The result will look like this:
var pagedList = DbContext.BlogPosts.ToPagedList(page: 1, pageSize: 5);
- 1/8/2023
- 6 minute read
No, No, No - Tasks are not threads and they are not for performance!
I often read that Task is used for multithreading in C# / .NET, but that is not the case. And it is crucial to understand why this isn't the case. We will also see which problem exactly Task is solving in the first place.
- 1/3/2023
- 3 minute read
.NET Tips and Tricks & ValueStringBuilder
I want to showcase two of my many side projects. My .NET Tips and Tricks website, where I collect and categorize, well, tips and tricks around .NET-related topics as well as my ValueStringBuilder.
- 1/1/2023
- 4 minute read
Give your strings context with StringSyntaxAttribute
Strings are one of the most universal data types. We use them for URLs or regular expressions or even to define some date. With .NET 7 we have a new way of giving those strings a bit of meaning. Meet StringSyntaxAttribute.
I also show you a way how to use them in .NET 6 and earlier.
- 12/30/2022
- 2 minute read
C# 12: Default Parameters in Lambdas
There is still a long road ahead of us until the release of .NET 8, but the first new language constructs are getting public. The first one I want to present is: Default Parameters in Lambdas.
- 12/29/2022
- 3 minute read
ReadOnlySpan<char> and strings - How not to compare them
Many know that you can take ReadOnlySpan<char> objects when dealing with strings. They give you a direct way of operating on the underlying memory. Often times you can use them interchangeably, but there are scenarios where you really have to watch out what is going on.
This blog post will have a look at a major problem with ReadOnlySpan when used like a "regular" string.
- 12/20/2022
- 2 minute read
Structure and order your DI container
Does your Dependency Injection container is one big pile of method calls one after the other?
Are there 50 lines of just AddScoped, AddTransient, and so on? Well, let's fix this.
We can utilize extension methods to make an order to that mess!
- 12/15/2022
- 14 minute read
Array, List, Collection, Set, ReadOnlyList - what? A comprehensive and exhaustive list of collection-like types
.NET knows a big list of collection-like types like: IEnumerable, IQueryable, IList, ICollection, Array, ISet, ImmutableArray, ReadOnlyCollection, ReadOnlyList, and many more.
This blog post will give you an exhaustive list of types in .NET and when to use what.
- 12/12/2022
- 10 minute read
Simple DI - Container
This blog post will show you a very simple Dependency Injection container.
This will give a better understanding of what Dependency Injection is and how it is done. And sure we will see how this is related to IoC - Inversion of Control.
- 12/10/2022
- 1 minute read
Delete a record without prior loading in Entity Framework
Sometimes you have an Id of an object and want to delete the underlying thing from the database. But it doesn't make sense to load the whole object from the database to memory first. So how can we achieve this quickly?
- 12/8/2022
- 9 minute read
ChatGPT - Current state for .NET - and in general
ChatGPT is going viral right now. Besides funny conversations, you can use that tool to generate also code for you. But does it really hold up to its reputation and it is a serious pairing partner? Let's see.
- 12/7/2022
- 1 minute read
Check for elevated rights in .NET 8
In the past, it was tricky to get if the current process runs under elevated rights. In the sense of it is run under the sudo group in *nix (Unix, Linux, macOS, you name it) or administrative rights in Windows.
But that changes with .NET 8 as we now have a unified API for that.
- 12/5/2022
- 4 minute read
Abstraction vs Encapsulation
Abstraction and Encapsulation are two fundamental concepts in object-oriented programming. So let us have a small look what the difference is between those two.
- 12/3/2022
- 10 minute read
How to enumerate through a StringBuilder
Did you ever wonder how we can iterate through a StringBuilder? I mean, of course, we can just call ToString and use the returned string, but that means we materialize the whole thing without good reason.
We can also use a normal for-loop. But we can also find a completely different and probably dumber way! And if you wonder: No, this is not something you do in your daily life, but by doing so, I can show some cool stuff C# and .NET offer.
- 12/1/2022
- 4 minute read
New ArgumentException and ArgumentOutOfRangeException helpers in .NET 8
Do you remember how .NET 6 introduced the ArgumentNullException.ThrowIfNull guard? And afterward, with .NET 7 we've got this excellent bit: ArgumentException.ThrowIfNullOrEmpty? Guess what, there might come some new handy additions for the upcoming .NET 8 iteration.
So let's see what are those new changes and how they make the code simpler.
- 11/27/2022
- 6 minute read
A new wave of analyzers in .NET 8
Analyzers did become an integral part of the .NET ecosystem. Their main responsibility is to find potential code issues and warn you. Often times this comes even with potential fixes you can directly apply.
And Microsoft will continue this journey with the upcoming .NET 8 release. This blog post will show you potential candidates, which will make the cut.
- 11/24/2022
- 6 minute read
Frozen collections in .NET 8
.NET 7 was freshly released but Microsoft does not sleep. .NET 8 is already in the making and I want to showcase to you one new area where the dotnet team is working on Frozen collections.
So let's have a look at what frozen collections are and how they are working.
- 11/22/2022
- 4 minute read
"Use always a StringBuilder" - Internet myths
Use always a
StringBuilder
That is what you can read from time to time. The basic idea is, that a StringBuilder is "better" to be defined.
Why are people telling that lie? Let's discuss this and see what it isn't true.
- 11/20/2022
- 3 minute read
How to get allocations in .NET? And how big is an empty array?
Often times we hear about allocations on the heap. How can we easily measure this? This article will show you a very easy way of doing so.
Plus we will answer the question how big is an empty array? And if you think 0 bytes, then spoiler alert, that is not the case at all.
- 11/19/2022
- 4 minute read
Anonymous test data with AutoFixture
Often times we have unit or integration tests that rely on some input data. The easiest solution is just to take some hard-coded values and move on with life. This has some major downsides:
Giving specific values in a test carries meaning, but we are often times not interested in that. We just need to pass the object around to fulfill the API. Also the simplest solution to fulfill your test is literally checking against those values.
Here is an elegant solution to that problem: AutoFixture. I will show you what it can do, especially in combination with xUnit.
- 11/6/2022
- 3 minute read
Mutable value types are evil! Sort of...
You might have heard that mutable value types are evil. But why is that and why does the .NET framework use them then? Are they really that evil?
Let's have a look at a few examples and have a look what is going on!
- 11/3/2022
- 3 minute read
Marking API's as obsolete or as experimental
Often times your API in your program or library evolves. So you will need a mechanism of telling that a specific API (an interface or just a simple method call) is obsolete and might be not there anymore in the next major version.
Also it can happen that you have a preview version of a API, which might not be rock-stable and the API-surface might change. How do we indicate that to the user?
- 11/2/2022
- 5 minute read
Infographics Compendium III - Exceptions, EF Sanitized, Operators, ...
This edition has the following infographics:
DebuggerDisplayAttribute- Entity Framework input and LINQ - is it safe?
ExceptionDispatchInfoimplicitandexplicitoperator
- 10/30/2022
- 7 minute read
local functions vs lambda expressions
.NET knows local functions and lambda expressions. You can almost take them interchangeably, but there are also some differences between them.
This article will show the differences between them.
- 10/21/2022
- 3 minute read
Throwing exceptions - Why is my stack trace lost?
You might have read, that re-throwing an exception like this: throw exc; is considered bad practice and you should just do this: throw; instead.
But why is it like that?
- 10/20/2022
- 6 minute read
LiteDB - A .NET embedded NoSQL database
In this article we will have a closer look at LiteDB, a .NET NoSQL Document Store in a single data file. We will discover the advantages of LiteDB and why it is a viable candidate for your next project.
We will also explore what are the differences between a NoSQL and a classical SQL database are and what this has to do with the reminiscent SQL CE or the more modern SQLite database.
- 10/15/2022
- 4 minute read
Cursed C# - Doing shenanigans in C#
In this short blog post I want to show you two silly things so that you can apply right now! Both of them equally silly, but that is not the point (is it ever?).
We will see how to await an integer or TimeSpan and how to foreach through an integer. All of this thanks to the magic of extensions methods.
- 10/15/2022
- 7 minute read
Infographics Compendium II - ThrowHelper, null Task and more
This edition has the following infographics:
ConfigureAwaitonIAsyncDisposable- Index in
foreach - Non-destructive mutations with
struct - Returning
nullfor aTask - Throw-Helper
- verbatim strings
- 10/5/2022
- 6 minute read
Introduction to WebApplicationFactory
This article will show you what exactly a WebApplicationFactory is and why it is so "mighty" when it comes down to testing. I will highlight some of the properties, which you can leverage to write powerful tests.
- 10/2/2022
- 4 minute read
Infographics Compendium I - Generators, pure functions and more
Sometimes I publish parts of my infographics I publish on various channels with more explanation.
And then sometimes I don't. This time I just put some of my (hopefully self-explanatory) infographics here.
- Pure functions
- Generator functions
- Cost of anonymous types
- 9/30/2022
- 9 minute read
x86 vs x64 in .NET
In this article I will show you what is the difference between x86 (32-bit) vs x64 (64-bit) in the .NET World.
What is the impact if you choose on or another.
- 9/27/2022
- 4 minute read
Pattern matching is awesome
Pattern matching, which was introduced in C# 9, is a hell of a beast and does more than you might think.
In this small blog post I show you where the magic is and what it does under the hood.
- 9/23/2022
- 3 minute read
Blazor Project Structure
Did you ever wonder what is a nice way of structuring your Blazor application?
I will show you how I structure my Blazor projects (as well as this very blog). What are the upside in contrast to the "default" structuring you get with the Blazor template.
- 9/21/2022
- 2 minute read
Memory is complicated
This is a small story about how memory operates in your .NET application. Well not only .NET but how memory does or does not get allocated.
We will see how a 1 Gigabyte big array is only a few megabytes big to some extend. Furthermore I will discuss working set and committed memory.
- 8/17/2022
- 15 minute read
NDepend
NDepend is a static analysis tool for .NET managed code. The tool proposes a large number features, from dependency visualization to Quality Gates and Smart Technical Debt Estimation. For that reasons the community refers to it as the "Swiss Army Knife" for .NET Developers.
So let's check if that descriptionI shamelessly stole from Wikipedia checks out and what we can do with that tool.
- 8/10/2022
- 9 minute read
LINQ explained with sketches
Often times it is easier to have a nice illustration at hand, which explains you things the easy way. So let's do this for a lot of LINQ operations like Where, Select and friends.
Of course a small explanation will be attached as well.
- 6/20/2022
- 3 minute read
Wrap Event based functions into awaitable Tasks - Meet TaskCompletionSource
You might have code where an object offers you an event to notify you when a specific operation is done. But event's can be tricky to use, especially when you want to have a continuous flow in your application.
That is where TaskCompletionSource comes into play. We can "transform" an event based function into something which is await-able from the outside world via the await keyword.
- 6/14/2022
- 6 minute read
What is the difference between C#, .NET, IL and JIT?
When you get started or even if you have quite some knowledge it can be confusing to juggle with those terms. So what is the difference between C# and .NET? And what does it have to do with IL and JIT?
- 6/10/2022
- 8 minute read
Delegate, Action, Func, Lambda expression - What the heck!?
C# offers a lot of utility especially around the delegate topic. So let's see what exactly a delegate is and how the distinct types like delegate, Action, Func, Predicate, anonymous function, lambda expressions and MulticastDelegate behave. A lot to digest and discover so let's go.
- 6/3/2022
- 4 minute read
The garbage collector in .NET - Part 2: Compacting
I already made a post about how the Garbage Collector works in .NET and also introduced the topic of Generation slightly. This article will look a bit more in detail into why we have those mechanisms in the first place, including the Large Object Heap.
- 6/2/2022
- 6 minute read
ObjectPool - Rent and return some instances
Just imagine a car pool: There is a dealer which bought the car and lent's it to you. After a while you will return this car where you got it from. Much like that works an ObjectPool in C#. You can rent an expensive object from the pool and when you are done with it, you just return it. Sounds beautiful, doesn't it?
Let's explore the advantages and disadvantages of a ObjectPools and how they work.
- 5/24/2022
- 9 minute read
How to unit test a RavenDB
RavenDB is a well known open-source document-oriented databse for .NET. And of course we want to test our logic and not only locally while developing, but also our continuous integration pipeline should be able to run our tests. So let's tackle exactly that.
- 5/21/2022
- 12 minute read
The garbage collector in .NET
This article will talk about the garbage collector in .NET. Why do we have and need him? And why it is essential to understand the behavior to know what impact on our application he has.
- 5/13/2022
- 7 minute read
Tail-Recursion - Explained with the Fibonacci series
What is Tail-Recursion? We will discover this "special" form of recursion on the example of the Fibonacci series. Also we will check how much faster it is and why.
- 5/12/2022
- 4 minute read
Why are sealed classes faster in C#? And should I seal them?
In C# we can add the sealed modifier to a class to indicate that no one is allowed to derive / inherit from that class.
Let's have a look at the compiler in certain scenarios what happens if you seal a class.
- 5/7/2022
- 8 minute read
Passing by value or by reference - What is faster?
When we are passing objects around we can do this either via reference or by value. Which of those two methods is faster?
To answer this question we have to dive into a bit of info about what happens exactly when you pass something around and how the other side will receive this.
- 10/17/2021
- 3 minute read
static abstract interfaces and generic math
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.
- 9/6/2021
- 2 minute read
IEnumerable vs IQueryable - What's the difference
.NET brings two types which seem very similiar
IEnumerableIQueryable
What is the difference? Most are familiar with using IQueryable when we want to go to the database and back. But why not using IEnumerable?