Tech with Christian

SOLID Principles - The art of writing maintainable code 👨‍💻

In this post I will show you a few things to be aware of that I have learned the hard way.

What happens when extension methods share name with instance methods?
How does the compiler decide what code it should call?
What real-world patterns to use.

I will show you a real-world example of a Order class, where we will add extension methods.

A Simple Order Class

Most projects I have been involved in, has something to do with order management. You might have guessed it - let's start with a basic Order class that represents a customer order in a system.

namespace ExtensionMethod;

internal class Order
{
    public int OrderId { get; set; }
    public double TotalAmount { get; set; }
    public bool IsShipped { get; set; }
    public string CustomerName { get; set; }
    
    public Order(int orderId, double totalAmount, bool isShipped, string customerName)
    {
        OrderId = orderId;
        TotalAmount = totalAmount;
        IsShipped = isShipped;
        CustomerName = customerName;
    }
    
    public override string ToString() => 
        $"Order ID: {OrderId}, Customer: {CustomerName}, Total: {TotalAmount:C}, Shipped: {IsShipped}";
    
    public void ApplyDiscount(double flatDiscount)
    {
        TotalAmount -= flatDiscount;
    }
}

Did your sharp eyes see the ApplyDiscount(double flatDiscount) and the ToString() methods? If not, read again 😄

Extending the Order Class

Alright - let's extend the Order class with some useful extension methods.

internal static class OrderExtensions
{
    // Extension method to apply a percentage discount
    public static void ApplyDiscount(this Order order, double discountPercentage)
    {
        order.TotalAmount -= order.TotalAmount * (discountPercentage / 100);
    }
    
    // Extension method to check if the order is high-value
    public static bool IsHighValue(this Order order, double threshold)
    {
        return order.TotalAmount > threshold;
    }
    
    // Extension method to mark an order as shipped
    public static void MarkAsShipped(this Order order)
    {
        order.IsShipped = true;
    }
}

Confused? That was the intention 😅 We now got two methods named ApplyDiscount. What is the difference, Christian?!

One instance method in the Order class (takes a flat discount)
One extension method in OrderExtensions (takes a percentage)

How does this work? Let's find out.

Method Overloading and Resolution Rules

This is where I messed up in the beginning of my career, and would like to teach you a thing, continue reading. Let's take a look at the usage of these methods.

public class OrderExtensionsDemo
{
    public static void Execute()
    {
        Order order = new(101, 1200.50, false, "Christian");
        Console.WriteLine(order);  // Initial Order
        
        // Apply a flat discount of $100 (Order Instance Method)
        order.ApplyDiscount(flatDiscount: 100);
        
        // Apply a 10% discount (Order Extension Method)
        order.ApplyDiscount(discountPercentage: 10);
        
        Console.WriteLine("After Discount:");
        Console.WriteLine(order);
        
        // Check if the order is high-value with a threshold of $1000
        bool isHighValue = order.IsHighValue(1000);
        Console.WriteLine($"Is High Value: {isHighValue}");
        
        // Mark the order as shipped
        order.MarkAsShipped();
        Console.WriteLine("After Marking Shipped:");
        Console.WriteLine(order);
    }
}

So... why is the code above safe and works as intended? Named arguments save the day 🙈 Did you notice the use of named arguments in the discount calls I made?

order.ApplyDiscount(flatDiscount: 100);        // Calls instance method
order.ApplyDiscount(discountPercentage: 10);   // Calls extension method

This saves our ass. By using named arguments, we can achieve

Disambiguate between methods with the same name.
Self-documenting code—readers immediately understand the difference.
Leverage method overloading between instance and extension methods.

Method Resolution Priority

The C# compiler follows these rules when resolving method calls - I had to go the hard way to find out, so here are the golden points.

Instance methods have priority. If an instance method matches the signature, it's chosen over an extension method.
Extension methods are considered next. If no instance method matches, the compiler looks for extension methods.
Closer namespaces win. Extension methods in the current namespace are preferred over those in imported namespaces. Did you know that?
Ambiguity causes compilation errors. If multiple extension methods match equally well, you'll get a compiler error.

What If We Don't Use Named Arguments?

Without named arguments, this code would be ambiguous. If you were using an IDE, it would warn you about this because of the compiler.

order.ApplyDiscount(10);  // Which method?

It's pretty simple, the compiler can't figure out what you want, since it has two options and both takes in the same parameter type.

A $10 flat discount (the instance method)
A 10% discount (the extension method)

Both methods takes in a double as parameter, so without named arguments, the call is ambiguous.

Running the Example

I have enabled debugging and placed a ton of break points in my code to trace what is happening. Let's break it down, and I will explain step-by-step what is happening.

Order ID: 101, Customer: Christian, Total: $1,200.50, Shipped: False

After flat discount of $100, we will have the following result

Total: $1,100.50

After 10% discount, the value will be

Total: $990.45  // $1,100.50 - ($1,100.50 * 0.10)

After checking high-value status, we got

Is High Value: False  // $990.45 is not > $1,000

After marking it as shipped, we will have the following

Order ID: 101, Customer: Christian, Total: $990.45, Shipped: True

Real-World Patterns and Best Practices

I have learned a lot, and also the hard way. Below are some of my best practices I have learned during the years of development and making architecture. You can skip them, read them and pick what you think works for you.

Use Extension Methods to Separate Concerns

I have come to the conclusion that extension methods are perfect for adding functionality without bloating your core classes.

// Core class stays focused on data and essential operations
class Order { /* ... */ }

// Business logic extensions
static class OrderBusinessExtensions { /* ... */ }

// Validation extensions
static class OrderValidationExtensions { /* ... */ }

// Formatting extensions
static class OrderFormattingExtensions { /* ... */ }

Why do this? It gives us the option to keep our classes focused and makes it easier to test different aspects of our codebase independently. What's not to like!?

Consider Mutability Carefully

Have you noticed that my extension methods mutate the Order object?

public static void MarkAsShipped(this Order order)
{
    order.IsShipped = true;  // Mutating state
}

Why does that work? It's simple - the Order is a reference type. But I would strongly encourage you to consider whether you want your extension methods to mutate the state or return a new instance, like here.

// Mutating (current approach)
order.ApplyDiscount(10);

// Immutable alternative
var discountedOrder = order.WithDiscount(10);

The only thing you have to be aware of is that for value types (structs), mutation in extension methods will not work as you expect, without you are using the ref keyword, as I am showing here.

public static void ExtensionMethod(ref this MyStruct s)  // Note the ref
{
    s.Value = 42;
}

Use Meaningful Names and Avoid Conflicts

When I am naming my extension methods, I have some rules.

Always be specific. MarkAsShipped() is better than Ship().
Follow conventions. If it returns bool, consider starting with Is, Has, or Can. It makes the codebase easier to read and maintain in the future.
Avoid collision with future framework methods. Don't create extensions that might conflict with future .NET versions. I know this is a hard to know about, but try to stay out of their framework.

Let’s say you add an extension method to a very common .NET type, like here.

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string value)
    {
        return string.IsNullOrEmpty(value);
    }
}

This works today, but it’s risky! But why?

string.IsNullOrEmpty already exists as a static method.
.NET could add an instance method called IsNullOrEmpty() in a future version.
If they do, your extension method either
- Stops being called.
- Causes ambiguity errors.
- Or behaves differently across .NET versions.

That’s a collision with the framework.

Consider Discoverability

Extension methods are only available when the namespace is imported. That is why I always try to group related extension into one namespace, and disable the pragma warning in the IDE for it.

using ExtensionMethod;  // Now OrderExtensions are available

Group related extensions in the same namespaces, will help you and other developers discover them.

Document Your Parameter Expectations

You should always use named parameters when it improves clarity of your extension method. Like shown here.

// Clear intent
order.IsHighValue(threshold: 1000);

// Less clear
order.IsHighValue(1000);  // 1000 what?

When to Use Extension Methods vs. Instance Methods?

Use Instance Methods When

✅ The functionality is core to the type's purpose.
✅ The method needs access to private members.
✅ The method is part of the type's contract/interface.
✅ Polymorphism is required (virtual/override).

Use Extension Methods When

✅ You don't own the type (framework types, third-party libraries).
✅ The functionality is supplementary or domain-specific.
✅ You want to separate concerns across different assemblies.
✅ You're creating fluent APIs or query helpers.
✅ You want to avoid bloating a core class.

Extension Method Chains

Remember i mentioned something about writing code that looks like a nice API? This is what chaining allows us to do. Imagine being able to do this:

var processedOrder = order
    .ApplyDiscount(discountPercentage: 15)
    .MarkAsShipped()
    .GenerateInvoice()
    .SendConfirmation();

For this to work, each extension method needs to return the order (or a modified version).

public static Order MarkAsShipped(this Order order)
{
    order.IsShipped = true;
    return order;  // Enable chaining
}

Key Takeaways

As always, I have some key takeaways 😄

Instance methods always win. They have priority over extension methods in method resolution, that's just how it is.
Named arguments disambiguate. Use them when you have overloaded instance and extension methods.
Extension methods enable separation of concerns. Keep core classes focused, extend with specialized functionality. This also promotes testability of your code.
Be mindful of mutability. Decide whether your extensions should mutate or return new instances.
Namespace organization matters. Group related extensions and use clear naming conventions, that makes it easier to discover all extensions for an object.
Extension methods can't access private members. They operate on the public surface of a type. I did not mention that earlier, but now you know.

Summary

An extension method is a very powerful tool in the developer toolbox. It gives us the option to write clean, and maintainable code. With extensions we can easily extend both built-in framework types and our own classes without violating the Single Responsibility Principle (from SOLID).

Learn what the SOLID principles are about and how you can use them to write clean and maintainable code in your applications. With C# examples.

runtime/src/libraries/System.Linq at main · dotnet/runtime

The big key is to use them when needed. Only create extensions when it makes sense and keep your method names clean and clear. Always go for named arguments when you got an ambiguity.

If you combine extension methods with LINQ, generics and other awesome C# features, your extension methods will become cornerstones. If you enjoyed this post, let me know in the comments. Until next time - happy coding! ✌️

Understanding Extension Methods in C#

Christian Schou Køster — Sun, 08 Feb 2026 20:13:47 +0100

I assume you know about LINQ and have used methods like Where(), Select(), or FirstOrDefault()? Do you know what they really are? Extension methods! 👌

In this collection post, I will show you how extension methods work, why they are handy, and how you can create your own to extend your own classes or framework types like e.g. IEnumerable.

What Are Extension Methods?

As I just mentioned, an extension method makes it possible to "add" methods to an existing type. In your IDE at development time, they appear as instance methods on the type you extend, but really they are just static methods you define in a static class.

I often refer to this as syntactic sugar - why? It makes our code more readable, and enable you and others to write code in a fluent, and "API" friendly design.

An extension method must always:

Be defined in a static class.
Be a static method.
Have this keyword along with the first parameter. This tells us about the type being extended.

Alright - let's get to the fun part, and see it in action 🔥

Building a Custom LINQ-Style Method

Let's start soft by extending IEnumerable with a custom find operation. Here is the code - I will explain below.

namespace ExtensionMethod;

internal static class IEnumerableExtensions
{
    public static IEnumerable CustomFind(this IEnumerable source, Func isMatch)
    {
        foreach (var item in source)
        {
            if (isMatch(item))
            {
                yield return item;
            }
        }
    }
}

Okay, let me break it down and tell you what is happening above.

The Method Signature

public static IEnumerable CustomFind(this IEnumerable source, Func isMatch)

this IEnumerable source. The this keyword makes this an extension method on IEnumerable. Any collection implementing this interface can now call CustomFind().
Generic Type . Makes the method work with any type. Awesome part about that is it provides type safety 🙌
Func isMatch. A predicate function that figures out whether an item matches our criteria or not.

💡

A predicate function is a function that returns a boolean value (true or false). It evaluates a condition and tells you whether something meets a certain criteria.

Deferred Execution with `yield return`

Do you care about performance? I do, and that is why I am using yield return inside the method, it is actually crucial when talking performance if you ask me.

foreach (var item in source)
{
    if (isMatch(item))
    {
        yield return item;
    }
}

Why is yield return making it perform better? The reason is because it creates an iterator that provides deferred execution. Christian... what the h... does that mean? Let me try to explain that for you.

The method doesn't process the entire collection instantly/immediately.
Items are evaluated one at a time, and only when requested.
If you only need the first matching item, you won't iterate through the entire collection of items.
Multiple operations can be chained without creating intermediate collections.

The exact same pattern is actually used by LINQ methods like Where(), Select(), and Take(). You can check out their source implementation at the link below if you are curious.

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps. - dotnet/runtime

GitHubdotnet

Using the Extension Method

Now that we have the extension method and we know how any why it works, let's try using it in some practical code.

public class IEnumerableExtensionsDemo
{
    public static void Execute()
    {
        List numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        
        // Find all even numbers
        var evenNumbers = numbers.CustomFind(n => n % 2 == 0);
        Console.WriteLine("Even Numbers:");
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number);
        }
        
        // Find all numbers greater than 5
        var greaterThanFive = numbers.CustomFind(n => n > 5);
        Console.WriteLine("Numbers Greater Than 5:");
        foreach (var number in greaterThanFive)
        {
            Console.WriteLine(number);
        }
    }
}

Can you see it now? Our extension method looks like it is a built-in method in the LINQ framework, but on the List variable. Why does this work? It works because List implements IEnumerable, this makes our extension available automatically.

The result?

Even Numbers:
2
4
6
8
10
Numbers Greater Than 5:
6
7
8
9
10

Why Not Just Use LINQ's `Where()`?

I know what you might be thinking. Why do that? Why not use the Where() method? and you are absolutely right! In a real-world solution, you would just stick to the LINQ method for solving that.

This was a demonstration, and with the code above, I was able to demonstrate the following:

How LINQ actually works under the hood. Many LINQ methods are extension methods using similar patterns.
How to create domain-specific extensions. You can build custom query methods tailored to your business logic. Cool right!?
The power of extending framework types. You're not limited to what Microsoft provides, the sky is the limit.

When to Create Extension Methods on Framework Types?

With great power comes great responsibility, and extension methods on framework types are powerful, let me tell you that, and it is also the reason why you should be careful.

Below are some of my key takeaways for using them and avoiding them in my projects. You are welcome to follow that route or just stick to your own.

✅ I use them when I

Create domain-specific query operations that compose well with LINQ.
Add utility methods that would benefit from a fluent syntax - we are back to the "API-like" design here.
Fill gaps in framework functionality for my specific needs in a solution.
Have to create more readable alternatives to static utility methods.

❌ Avoid them when

The functionality is too specific to one use case.
They would confuse other developers (especially naming conflicts with future framework additions)
A simple static helper method would be clearer for other developers.

Key Takeaways

Extension methods are syntactic sugar. They're static methods that appear as instance methods.
Use this on the first parameter. This tells us the type being extended.
Deferred execution matters. Use yield return for collection operations to maintain performance. ALWAYS!
Generic extension methods are powerful. They work across all types that match the constraint.
Namespace matters: You need to use the using namespace containing the extension class to access the methods. I often practice placing them in a global file for the project or placing them in a root namespace (if it makes sense - often the case in a class library).

End of part one

The end of the first post in this section. You should now have a great foundational knowledge about extension methods. By now I hope you have the idea that they make it possible for you to write expressive fluent code by extending on types.

When you learn to use them correctly, they can take your codebase to the next level and make it more like an API. I really enjoy reviewing code written in that style! Turn it into art, please 🙏

In the next and final post in this section, I will show you some cool and a bit more advanced scenarios. We will also take a look at what happens when an extension method clashes with instance methods, how the resolution of them works, and again some practical examples for how you can extend your own classes.

Extend your Extensions in .NET

Christian Schou Køster — Mon, 24 Nov 2025 13:56:38 +0100

When .NET 9 was released we got extension members. I am sure we have only seen the beginning of them, as there is a lot of potential in that (if you ask me). They are a way for developers to improve existing types.

To make it easier to understand what I mean, I have prepared a simple example for you:

// This will be possible in .NET 10
extension StringExtensions for string
{
    public int WordCount => this.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
}

// Using it
string sentence = "This is a test";
int count = sentence.WordCount;  // 4

See the awesome part about this? They will give you a feeling that the extension is at language-level. It's not just a static method you added as a workaround. With the extension members we can easily add new methods or properties to our existing types.

💡

You can actually define private members (methods or other properties) in the extension container. The only issue (right now) is that private members doesn't serve that much of a purpose at the moment.

🧑‍💻 A Practical Example

Let's make a practical example to see how we can utilize this in a real world. I have created a set of classes for your reference.

public abstract class Vehicle
{
    public string Make { get; set; }
    public string Model { get; set; }

    public sealed class Car : Vehicle
    {
        public int NumberOfDoors { get; set; }
        public bool IsElectric { get; set; }
    }

    public sealed class Truck : Vehicle
    {
        public double PayloadCapacity { get; set; }
        public bool HasFourWheelDrive { get; set; }
    }

    public sealed class Motorcycle : Vehicle
    {
        public bool HasSidecar { get; set; }
        public string EngineType { get; set; }
    }
}

Imagine you would like to perform some sort of validation on the truck for e.g. the payload capacity. That would end up in something similar to this code:

var truck = new Vehicle.Truck();

if (truck is Vehicle.Truck t)
{
    if (t.PayloadCapacity <= 0)
    {
        // Handle invalid payload (e.g., throw, set default, etc.)
    }
    else
    {
        // Payload is OK
    }
}

This becomes a bit cluttered, what if you could do all of that in an extension using the new extension members being available from .NET 10?

public static class VehicleExtensions
{
    extension(Vehicle.Truck truck)
    {
        public bool HasValidPayload => truck.PayloadCapacity > 0;
    }
}

This provides us with an extension for the Truck class now where the validation is abstracted away from the condition we made before. Let's use it to validate the payload.

var truck = new Vehicle.Truck { PayloadCapacity = 5.0 };

if (truck.HasValidPayload)
{
    Console.WriteLine("Truck payload capacity is valid.");
}
else
{
    Console.WriteLine("Truck payload capacity is invalid!");
}

See how clean my conditional logic became after doing that? It's now fully readable 💪 One thing I really like about this is that we now get the option to extend static classes and that is pretty awesome! 🔥

But it doesn't stop here, there is much more we can do. Below are a few examples to showcase it.

🧱 Extending Enums

Enums can be extended as well. When I first read that I was curious about what was possible. One thin I often see written over and over again are parsers for enums.

Yes... I have done a few myself in various projects, but this can be handled pretty beautiful with an extension.

Suppose you have a VehicleType enum.

public enum VehicleType
{
    Car,
    Truck,
    Motorcycle
}

Let's write an extension to parse a string to the enum member.

public static class VehicleTypeExtensions
{
    extension(T) where T : struct, Enum
    {
        public static T Parse(string value) =>
            Enum.Parse(value);
    }
}

And applied in the business logic, it ends up like this.

var type = VehicleType.Parse("Truck");
Console.WriteLine(type);  // Output: Truck

That is how easy it is. I know that example is pretty simple, but it is also just to showcase what is possible.

What about null or empty values? Something we hate as developers 😅

🚨 Null and Empty Checks

Image you have a List representing installed parts on a vehicle, and you want to ensure the list isn’t empty. How could we easily accomplish that?

I am so glad you asked... an extension 😆 Let's see how a null/empty check could be implemented using extensions.

public static class VehicleGuardExtensions
{
    extension(ArgumentException)
    {
        public static void ThrowIfPartsListEmpty(IList parts)
        {
            if (parts.Count == 0)
            {
                throw new ArgumentException("Vehicle must have at least one part installed.", nameof(parts));
            }
        }
    }
}

The extension above will throw an argument exception if the requirement about minimum installed parts are not met. Using it will be as easy as this.

var parts = new List();
ArgumentException.ThrowIfPartsListEmpty(parts);

Can you see the idea of doing that? Now we are using the base exception for arguments, but with our own logic behind a saying name making the code super readable for anybody.

I can say that I am already planning to implement this in a lot of the business applications where I got the design responsibility.

Let's have a look at one last thing, and call it.

🔄 Static Extension for Factory Defaults

If you find yourself having default values for a specific kind of your type, e.g. a truck, you could add an extension for creating just that. Let me show you how.

public static class VehicleFactoryExtensions
{
    extension(Vehicle)
    {
        public static Vehicle.Truck CreateDefaultTruck() =>
            new Vehicle.Truck
            {
                Make = "Generic",
                Model = "Hauler",
                PayloadCapacity = 2.0,
                HasFourWheelDrive = true
            };
    }
}

You can see this as a kind of a template, where you define what a default truck is. When applied in business logic, it will look like this.

var defaultTruck = Vehicle.CreateDefaultTruck();
Console.WriteLine(defaultTruck.Model);  // Output: Hauler

💭 Some Thoughts

I really like the extension members feature! They are a really cool way of making the code clean without having to re-invent the wheel. If you ask me, I think they are more powerfull and expressive at the same time, compared to the traditional extension methods we are building.

My example above was focused on a Vehicle, but it could literally be anything this could be applied to like types (the Vehicle) or static members like enums and factories.

They make our code more readable and when implement in a full codebase, your domain logic will start feeling like it is a natural part of the language. Can it be any better?

Behind all the awesome stuff I just showed and mentioned, there are always some things that could be made better, and hopefully they will in the future, who knows? To mention a few things:

❌ No Fields in Extension Containers

At the moment you cannot define fields inside an extension contianer. Only properties and methods are allowed. That limits a few optimizations or a shared internal state in the extension.

❌ No Private Reuse Across Extension Members

There is no option for reusing private computed properties or logic inside the same extension container. Here is an example:

extension(Vehicle.Truck truck)
{
    private bool IsOverloaded => truck.PayloadCapacity > 10;

    // ❌ Error: 'IsOverloaded' does not exist in this context
    public bool ShouldUpgradeSuspension => IsOverloaded;
}

This is currently not allowed, but would really be a nice feature! It could help improve the readability of the logic and encapsulate the shared logic inside the extension container.

🔐 No Instance Field Access from Extension

Let's say I wanted to give all my vehicles an internal field that only extensions could see. This could be for diagnostics or telemetry (thoughts on top of my head). If the .NET team implemented that, we might get something similar to this:

public abstract class Vehicle
{
    internal extension string _diagnosticsId;
}

extension(Vehicle vehicle)
{
    private string? DiagnosticsId => vehicle._diagnosticsId;
}

Why would I like that feature? Depends on your project, but I foresee that it could open the option for using patterns to accomplish metaprogramming or do diagnostics at runtime. I am currently building a modular monolith and I really think that this would be great in such a system.

🤓

Metaprogramming is an advanced concept where your code can inspect, modify, or generate other code at runtime or compile time 🔥 don't get scared 😁 I have personally used it for automating stuff. I once build a flexible API that was generated on the fly and even used it for injecting configurations in PLCs dynamically.

So, what do you think? 😅 How would you use extension members in your codebase? Let me know your thoughts in the comments! Until next time - happy programming! ✌️

📚 References

Metaprogramming - Wikipedia

Wikimedia Foundation, Inc.Contributors to Wikimedia projects

Extension members - C#

Extension members in C# enable you to add methods, properties, or operators to existing types without creating a new derived type, recompiling, or otherwise modifying the original type.

Extension member declarations - C# reference

Learn the syntax to declare extension members in C#. Extension members enable you to add functionality to types and interfaces in those instances where you don’t have the source for the original type. Extensions are often paired with generic interfaces to implement a common set of functionality across all types that implement that interface.

How to Add logging to ASP.NET Core using Serilog - .NET6

Serilog

Christian Schou Køster — Fri, 21 Nov 2025 14:52:35 +0100

Serilog is a very popular library for .NET when it comes to logging. It will give you a nice, and flexible way to log events in your application. If you are looking for my tutorials/posts about Serilog, they are just below. If you are only checking it out, just continue and read along. 🙌

Tutorials

Add Serilog to start logging to ASP.NET Core using Serilog with this easy step-by-step .NET Tutorial about logging using Serilog in .NET6.

Understanding Delegates in C#

Key features of Serilog

Below is a list that makes up some key features of Serilog (my personal opinion).

Structured logging

A normal logger is only writing text strings, and that is perfect as that is what logs really are. With Serilog you can do the same, but this time as structured data. This will give you a new level of options when it comes to analyse your logs. Why? Because Serilog can log objects and properties that you can query. 🙌 Wanna see how easy it is?

var user = new { Id = 123, Username = "john_doe", Email = "john@example.com" };
var orderTotal = 450.75m;

// The object properties are captured as structured data
Log.Information("User {@User} placed order for {OrderTotal:C}", user, orderTotal);

// Output includes the full user object structure, not just "User.ToString()"
// OrderTotal is formatted as currency

The @ operator destructures the object, and :C is a format specifier. Imagine that you can query logs like "show me all orders over $1000 that failed" is incredibly powerful for debugging production issues. 🔥

Sinks

With the many available sinks for Serilog, you can easily make it possible to "ship" your logs to multiple destinations at the same time. This could be:

The console.
A single- or rolling file.
A database.
A cloud service like:
- Azure Monitor.
- Seq by Datalust.
- etc...

Message templates

A feature that I really like are the templating syntax for separating my message from the data I am feeding to it. Here is an example.

Log.Information("User {Username} logged in from {IpAddress}", username, ipAddress);

Minimum level filtering

When developing the application I enjoy having my environment in either verbose or debug as that provides me a lot of logs and I can easily trace what is going on in the application.

With Serilog you can easily configure which log levels are captured at runtime. This can vary from Verbose, Debug, Information, Warning, Error, and up to Fatal.

Easy integration

If your applications are already using the built-in logging and DI (dependency injection), you can easily "enable" Serilog. It can be used in any .NET application and works well with the built-int logging system.

No need for rewriting your whole application, which also makes a great selling point. I am personally using Serilog in console apps, APIs, worker services, and much more.

My favorite things about Serilog

Below is a list with some of the coolest things I think that Serilog provides. If you got any suggestions that I should add, please let me know in the comments! ✌️

A super simple basic setup

All you have to do is install the Serilog package, and add the following code to your Program.cs file.

using Serilog;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .WriteTo.File("logs/myapp.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

Log.Information("Application starting up");

Multiple Sinks

In the market for a solution that can ship your logs to multiple places at the same time? This is how you can do it with Serilog.

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.File("logs/app.txt")
    .WriteTo.Seq("http://localhost:5341")
    .WriteTo.ApplicationInsights(telemetryConfiguration, TelemetryConverter.Traces)
    .CreateLogger();

Enrichers

If you would like to automatically add context to your logs, this can easily be done using the configuration. Here is an example where I am adding machine name, thread ID, and application name to all logs.

Log.Logger = new LoggerConfiguration()
    .Enrich.WithMachineName()
    .Enrich.WithThreadId()
    .Enrich.WithProperty("Application", "MyApp")
    .Enrich.FromLogContext() // Important for correlation IDs
    .WriteTo.Console()
    .CreateLogger();

Log context with scoped properties

You can create a scope and include necessary details within that scope when the logs are created. Here is an example where I make sure that everything logged within this scope will include OrderId.

using Serilog.Context;

public async Task ProcessOrder(int orderId)
{
    // All these logs will have OrderId attached
    using (LogContext.PushProperty("OrderId", orderId))
    {
        Log.Information("Starting order processing");
        await ValidateOrder();
        await ChargePayment();
        Log.Information("Order processing complete");
    }
}

Conditional Logging & Filters

Tired of logs from some providers? With the option for conditional logging and filters in Serilog, we can setup the configuration to suppress noise 😅

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Information()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning) // Suppress noisy MS logs
    .MinimumLevel.Override("System", LogEventLevel.Warning)
    .Filter.ByExcluding(logEvent => 
        logEvent.Properties.ContainsKey("RequestPath") && 
        logEvent.Properties["RequestPath"].ToString().Contains("/health"))
    .WriteTo.Console()
    .CreateLogger();

In the example above, I am suppressing Microsoft logs in the application.

Sub-loggers for Different Components

This is cool! Especially if you got something very specific like a component in your application and you would like to show exactly what class they come from. This is how you can do it.

public class OrderService
{
    private readonly ILogger _logger;

    public OrderService()
    {
        // Creates a logger specifically for this class
        _logger = Log.ForContext();
        // or
        _logger = Log.ForContext("SourceContext", "Orders.Processing");
    }

    public void ProcessOrder()
    {
        _logger.Information("Processing order");
    }
}

Logs will show they came from the OrderService.

Exception Logging

It's easy to log your exceptions. Serilog can log our full exceptions with the stack trace 🔥

try
{
    // risky operation ;)
    ProcessPayment();
}
catch (Exception ex)
{
    Log.Error(ex, "Payment processing failed for order {OrderId}", orderId);
    throw;
}

Configuration from appsettings.json

No need for hardcoding the configuration. I am often working with containers and I really want to have the option to configure the containers from environment variables. This is of course also an option in Serilog, as we can configure it from appsettings.json.

{
  "Serilog": {
    "Using": ["Serilog.Sinks.Console", "Serilog.Sinks.File"],
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "WriteTo": [
      { "Name": "Console" },
      {
        "Name": "File",
        "Args": {
          "path": "logs/log-.txt",
          "rollingInterval": "Day"
        }
      }
    ],
    "Enrich": ["FromLogContext", "WithMachineName"]
  }
}

The End

Serilog is my go-to for logging. I think it is one of the most adopted logging frameworks in the .NET ecosystem, and I think it is because of its great performance, flexibility, and many options it provides like sinks and enrichers making it easy to query logs in a structured way.

If you got any suggestions for this page, please let me know in the comments. Happy logging! ✌️

Newtonsoft.Json

Christian Schou Køster — Fri, 21 Nov 2025 14:42:51 +0100

Makes working with JSON in .NET feel effortless. It’s fast, flexible, and packed with helpful features—like easy serialization, handy querying tools, and even XML support.

RestSharp

Christian Schou Køster — Fri, 21 Nov 2025 08:44:04 +0100

Welcome

Some text to the page

Using Action and Func in C#

Christian Schou Køster — Tue, 18 Nov 2025 12:43:07 +0100

If you are working with C# on a daily basis, I am sure that you have ran into delegates, Action, and Func types. If you can understand the difference between these types and when you should use them, your code will end up being very flexible and maintainable at the same time.

What Are Delegates?

I will keep it ultra short. A delegate is a super type-safe function pointer in C#. They will allow you to pass a method as a parameter, store them in a variable, and invoke them later when you need it.

You can think of delegates as a contract that defines how your method should look like. interested in delegates? check out my Events and Delegates section in the Advanced C# Features collection.

In this section you will learn what delegates are all about, why they are so super useful, and how you can use them in an effective way in your own applications.

Learn about events. Events enable a class or object to notify other classes or objects when something of interest occurs.

Building A Data Processor

Alright, let's build something real. A scenario for a real world project could be a data processor. Data is the new gold, so why not make something that could process the data for us?

I will now show you a data processor that is capable of doing various mathematical operations- and validations on data. We will take off with some custom delegates, and then utilize Action, and Func to make the code simple.

Are you ready? Here are the delegates - one for validation, and one for calculation on the data.

namespace TWC.DelegateExamples;

public delegate bool ValidationDelegate(int value);
public delegate int CalculationDelegate(int a, int b);

That is pretty straight forward. Let's now implement the actual data processor.

namespace TWC.DelegateExamples;

public class DataProcessor
{
    // Using the first custom delegate
    public void ProcessWithValidation(int value, ValidationDelegate validator)
    {
        if (validator(value))
        {
            Console.WriteLine($"✓ Value {value} passed validation");
        }
        else
        {
            Console.WriteLine($"✗ Value {value} failed validation");
        }
    }

    // Using Action (for operations that don't return a value)
    public void ExecuteOperation(int a, int b, Action operation)
    {
        Console.WriteLine($"Executing operation on {a} and {b}...");
        operation(a, b);
    }

    // Using Func (for operations that return a value)
    public void Calculate(int a, int b, Func calculation)
    {
        var result = calculation(a, b);
        Console.WriteLine($"Calculation result: {result}");
    }

    // Func with different return type
    public void AnalyzeResult(int a, int b, Func analyzer)
    {
        var analysis = analyzer(a, b);
        Console.WriteLine($"Analysis: {analysis}");
    }
}

I know it is really simple, but it is only to show you the difference and maybe wake a light inside you for how awesome this is?! 😎

Using the Data Processor

Okay now that we have the data processor in place with some simple logic, let's bring it to life.

public class Program
{
    public static void Main()
    {
        var processor = new DataProcessor();

        // 1. Custom Delegate Example
        ValidationDelegate isPositive = (value) => value > 0;
        processor.ProcessWithValidation(42, isPositive);
        processor.ProcessWithValidation(-5, isPositive);

        // You can also pass the lambda directly
        processor.ProcessWithValidation(100, (value) => value % 2 == 0);

        Console.WriteLine();

        // 2. Action Example (no return value)
        processor.ExecuteOperation(10, 5, (a, b) => 
        {
            var sum = a + b;
            Console.WriteLine($"  Sum: {sum}");
        });

        processor.ExecuteOperation(10, 5, (a, b) => 
        {
            var product = a * b;
            Console.WriteLine($"  Product: {product}");
        });

        Console.WriteLine();

        // 3. Func Example (returns a value)
        processor.Calculate(15, 3, (a, b) => a / b);
        processor.Calculate(8, 7, (a, b) => a * b);

        Console.WriteLine();

        // 4. Func with different return type
        processor.AnalyzeResult(20, 10, (a, b) => 
        {
            var ratio = (double)a / b;
            return ratio > 1.5 ? "Significant difference" : "Similar values";
        });
    }
}

If you a new to custom delegates, Action, or Func. The code above might seem a bit confusing, I totally get that. So... please let me explain the difference.

Key Differences Explained

Custom Delegates

When to use? When you want to define a reusable way a method should look for your domain.
Pros? Easier to understand because the name tells you what it’s meant to do.
Cons? Requires explicit declaration.

Action

When to use? When you need to pass a method that performs an operation but doesn't return a value.
A signature can take 0-16 parameters, returns void.
An example could be Action that takes two integers and returns nothing.

In C#, a method’s signature is the shape of the method. The word signature might seem quite technical for some, but using it daily will start making it the default go-to 😅 Signature is the specific combination of the following in a method.

Its name
Its parameter list (types, number, and order)
Its return type (For delegates and interfaces, the return type is considered part of the signature. In class methods it doesn’t affect overload resolution, though it still contributes to how we think about the method’s overall structure. Makes sense? 😄)

Func

When to use? When you need to pass a method that calculates or returns a value, like in my example above.
Again signature can take 0-16 parameters. Remember that the last type parameter is always the return type!
An example could be Func that takes two integers and returns a string.

When To Use What?

I get it... it might seem overwhelming or confusing. To fix that, I have created a diagram that might help you.

Diagram to select between custom delegate, Action, or Func

Real-World Use Cases

To make things more simple or easier to undertand, I have broken them down into some real-world use cases.

Custom Delegates should be used for Event handlers, and callback patterns with specific domain meaning.

public delegate void OrderProcessedDelegate(Order order, DateTime timestamp);

Action should also be used for Event handlers, but also async callbacks, and LINQ operations like ForEach().

items.ForEach(item => Console.WriteLine(item));

Func should be used for LINQ queries, factory patterns, and transformation pipelines.

var doubled = numbers.Select(n => n * 2);
var filtered = items.Where(item => item.IsActive);

My Best Practices

I prefer Action and Func for most cases. Why? They are baked-in and universally understood.
I use custom delegates when the name adds clarity to my domain (like ValidationDelegate).
I Keep lambdas simple. If they're complex, extract them to named methods. Will make your life so much easier 🙌
I always consider async variants. This could be Func and Func> for async operations.

Summary

Custom delegates, Action, and Func all overlap each other in terms of purpose. If you want to write idiomatic C# code, you need to understand their differences. I always use custom delegates when a clear, and domain-drive name will provide me value. Finally I use Action and Func when I would like to write some code that provide a simple, and convenient callback.

What are you using and why? Please let me know about that and any other related questions in the comments. Thank you for reading this far! ✨

Event Subscription and Management

Christian Schou Køster — Tue, 18 Nov 2025 08:32:52 +0100

Final section of events and delegates for now. We have previously seen how delegates and events work. Events are nothing without one or more subscribers.

In this final post I will show you how to subscribe to events, manage subscriptions, and how you can avoid common pitfalls that in most cases lead to memory leaks. By the end you will know how the publisher -subscriber pattern works and how you can implement that in a .NET application.

The Publisher-Subscriber Pattern

I won't deep dive into this pattern theoretically. I will keep it short and then focus on how to implement it instead. The publisher-subscriber (often referred to as pub-sub) is a messaging pattern where you three primary thing.

The publisher is the one responsible for raising events. This could be a worker or an order processor, etc...
A subscriber that will listen to and act/handle events that has been raised by the publisher.
And finally we have the event, which can also be seen as an internal notification mechanism between the publisher and the subscriber.

One thing I really like about this pattern is that it promotes loose coupling. Why? Publishers won't know a thing about who their subscribers are, and the subscribers don't know anything about the implementation of the publishers.

Alright - let's get to the fun part and write some code. I will start with the basics and advance along the way all to the bottom of this post.

Basic Event Subscription

Let's start out with a basic example. This is a task manager with a task logger as the subscriber.

public class TaskManager
{
    public event EventHandler? TaskCompleted;
    
    public void CompleteTask(string taskName)
    {
        Console.WriteLine($"Completing task: {taskName}");
        TaskCompleted?.Invoke(this, new TaskEventArgs(taskName));
    }
}

public class TaskEventArgs : EventArgs
{
    public string TaskName { get; }
    public TaskEventArgs(string taskName) => TaskName = taskName;
}

// Subscriber
public class TaskLogger
{
    public void Subscribe(TaskManager manager)
    {
        // Subscribe using += operator
        manager.TaskCompleted += OnTaskCompleted;
    }
    
    private void OnTaskCompleted(object? sender, TaskEventArgs e)
    {
        Console.WriteLine($"  [Logger] Task logged: {e.TaskName}");
    }
}

// Usage
var manager = new TaskManager();
var logger = new TaskLogger();

logger.Subscribe(manager);
manager.CompleteTask("Deploy Application");

/* Output:
Completing task: Deploy Application
  [Logger] Task logged: Deploy Application
*/

There is not much to say about it. It has a manager responsible for managing the tasks, and then we have the subscriber that will subscribe to the manager and handle events it will publish.

Multiple Subscribers

A cool feature of events is that multiple subscribers can listen for the same event. This gives us the option to do multiple different things for a single event, like shown below.

public class EmailNotifier
{
    public void Subscribe(TaskManager manager)
    {
        manager.TaskCompleted += (sender, e) =>
        {
            Console.WriteLine($"  [Email] Notification sent for: {e.TaskName}");
        };
    }
}

public class MetricsCollector
{
    public void Subscribe(TaskManager manager)
    {
        manager.TaskCompleted += (sender, e) =>
        {
            Console.WriteLine($"  [Metrics] Recorded completion of: {e.TaskName}");
        };
    }
}

// Usage
var manager = new TaskManager();
var logger = new TaskLogger();
var emailer = new EmailNotifier();
var metrics = new MetricsCollector();

logger.Subscribe(manager);
emailer.Subscribe(manager);
metrics.Subscribe(manager);

manager.CompleteTask("Database Backup");

/* Output:
Completing task: Database Backup
  [Logger] Task logged: Database Backup
  [Email] Notification sent for: Database Backup
  [Metrics] Recorded completion of: Database Backup
*/

A simple example of multiple subscribers for a single event. As you can see we could be sending emails to the admin team, and update maybe Prometheus with some metrics once this events was raised.

Why It Is Important To Unsubscribe

When you subscribe to an event, the publisher will hold a reference to the subscriber. If you do not unsubscribe, the subscriber can never be garbage collected, even if you are done using it. This will lead to a memory leak!

Let's take a look at how we successfully can unsubscribe from the event again.

public class TaskMonitor
{
    private TaskManager _manager;
    
    public TaskMonitor(TaskManager manager)
    {
        _manager = manager;
    }
    
    public void Subscribe()
    {
        Console.WriteLine("  → Subscribing to events");
        _manager.TaskCompleted += OnTaskCompleted;
    }
    
    public void Unsubscribe()
    {
        Console.WriteLine("  → Unsubscribing from events");
        _manager.TaskCompleted -= OnTaskCompleted; // Important!
    }
    
    private void OnTaskCompleted(object? sender, TaskEventArgs e)
    {
        Console.WriteLine($"  [Monitor] Tracked: {e.TaskName}");
    }
    
    // Finalizer to clean up
    ~TaskMonitor()
    {
        Unsubscribe();
    }
}

// Usage demonstrating proper cleanup
var manager = new TaskManager();
var monitor = new TaskMonitor(manager);

monitor.Subscribe();
manager.CompleteTask("First Task");

monitor.Unsubscribe();
manager.CompleteTask("Second Task"); // Monitor won't receive this

/* Output:
  → Subscribing to events
Completing task: First Task
  [Monitor] Tracked: First Task
  → Unsubscribing from events
Completing task: Second Task
*/

How To Store Event Handlers for Correct Unsubscription

If or when you are using a lambda expression or an anonymous method, you would need to store a reference somewhere to unsubscribe from the event correctly. Let's see how we could accomplish that.

public class NotificationService
{
    private TaskManager _manager;
    private EventHandler _taskHandler;
    
    public NotificationService(TaskManager manager)
    {
        _manager = manager;
        // Store the handler reference
        _taskHandler = (sender, e) =>
        {
            Console.WriteLine($"  [Notification] {e.TaskName} completed!");
        };
    }
    
    public void Subscribe()
    {
        Console.WriteLine("  → Subscribing");
        _manager.TaskCompleted += _taskHandler;
    }
    
    public void Unsubscribe()
    {
        Console.WriteLine("  → Unsubscribing");
        _manager.TaskCompleted -= _taskHandler; // Works because we stored it
    }
}

// Usage
var manager = new TaskManager();
var notifier = new NotificationService(manager);

notifier.Subscribe();
manager.CompleteTask("Build Project");

notifier.Unsubscribe();
manager.CompleteTask("Run Tests"); // Notifier won't receive this

The Problem With Lambda Expressions

A word of warning. An inline lambda expression cannot be unsubscribed. Just saying it 😄 (an advice from a friend of mine)

var manager = new TaskManager();

// ❌ PROBLEM - Cannot unsubscribe
manager.TaskCompleted += (sender, e) =>
{
    Console.WriteLine($"Handled: {e.TaskName}");
};

// This does NOT work - creates a new lambda, doesn't remove the old one
manager.TaskCompleted -= (sender, e) =>
{
    Console.WriteLine($"Handled: {e.TaskName}");
};

// ✅ SOLUTION - Store the handler
EventHandler handler = (sender, e) =>
{
    Console.WriteLine($"Handled: {e.TaskName}");
};

manager.TaskCompleted += handler;
// Later...
manager.TaskCompleted -= handler; // This works! 😎

Okay, now that we have seen how to unsubscribe from events of different kinds, I think it is time to bring it all together and build something that makes sense.

Building A Stock Trading System With Events

Below is the code for a system that implement event management for a stock trading system. Who doesn't like money?! 💰 Let's split it into multiple sections.

EventArgs

public class StockPriceChangedEventArgs : EventArgs
{
    public string Symbol { get; }
    public decimal OldPrice { get; }
    public decimal NewPrice { get; }
    public decimal Change => NewPrice - OldPrice;
    public decimal ChangePercent => (Change / OldPrice) * 100;
    
    public StockPriceChangedEventArgs(string symbol, decimal oldPrice, decimal newPrice)
    {
        Symbol = symbol;
        OldPrice = oldPrice;
        NewPrice = newPrice;
    }
}

Publisher

public class StockMarket
{
    public event EventHandler? PriceChanged;
    
    private Dictionary _prices = new();
    
    public void UpdatePrice(string symbol, decimal newPrice)
    {
        decimal oldPrice = _prices.GetValueOrDefault(symbol, newPrice);
        _prices[symbol] = newPrice;
        
        if (oldPrice != newPrice)
        {
            OnPriceChanged(symbol, oldPrice, newPrice);
        }
    }
    
    protected virtual void OnPriceChanged(string symbol, decimal oldPrice, decimal newPrice)
    {
        var args = new StockPriceChangedEventArgs(symbol, oldPrice, newPrice);
        PriceChanged?.Invoke(this, args);
    }
}

Subscribers

The system will have multiple subscribers, each having different behavior.

Subscriber 1 - Alert Service

public class AlertService
{
    private StockMarket _market;
    private EventHandler _priceChangedHandler;
    
    public AlertService(StockMarket market)
    {
        _market = market;
        _priceChangedHandler = OnPriceChanged;
    }
    
    public void Subscribe()
    {
        Console.WriteLine("  [Alert Service] Subscribed");
        _market.PriceChanged += _priceChangedHandler;
    }
    
    public void Unsubscribe()
    {
        Console.WriteLine("  [Alert Service] Unsubscribed");
        _market.PriceChanged -= _priceChangedHandler;
    }
    
    private void OnPriceChanged(object? sender, StockPriceChangedEventArgs e)
    {
        if (Math.Abs(e.ChangePercent) > 5)
        {
            Console.WriteLine($"  🚨 ALERT: {e.Symbol} moved {e.ChangePercent:F2}% " +
                            $"(${e.OldPrice} → ${e.NewPrice})");
        }
    }
    
    ~AlertService()
    {
        Unsubscribe();
    }
}

Subscriber 2 - The Trading Bot

public class TradingBot
{
    private StockMarket _market;
    private EventHandler _priceChangedHandler;
    
    public TradingBot(StockMarket market)
    {
        _market = market;
        _priceChangedHandler = OnPriceChanged;
    }
    
    public void Subscribe()
    {
        Console.WriteLine("  [Trading Bot] Subscribed");
        _market.PriceChanged += _priceChangedHandler;
    }
    
    public void Unsubscribe()
    {
        Console.WriteLine("  [Trading Bot] Unsubscribed");
        _market.PriceChanged -= _priceChangedHandler;
    }
    
    private void OnPriceChanged(object? sender, StockPriceChangedEventArgs e)
    {
        if (e.Change > 0)
        {
            Console.WriteLine($"  🤖 BOT: {e.Symbol} trending up! Consider buying.");
        }
        else if (e.Change < 0)
        {
            Console.WriteLine($"  🤖 BOT: {e.Symbol} trending down! Consider selling.");
        }
    }
    
    ~TradingBot()
    {
        Unsubscribe();
    }
}

Subscriber 3 - Market Logger

public class MarketLogger
{
    private StockMarket _market;
    private EventHandler _priceChangedHandler;
    
    public MarketLogger(StockMarket market)
    {
        _market = market;
        _priceChangedHandler = OnPriceChanged;
    }
    
    public void Subscribe()
    {
        Console.WriteLine("  [Market Logger] Subscribed");
        _market.PriceChanged += _priceChangedHandler;
    }
    
    public void Unsubscribe()
    {
        Console.WriteLine("  [Market Logger] Unsubscribed");
        _market.PriceChanged -= _priceChangedHandler;
    }
    
    private void OnPriceChanged(object? sender, StockPriceChangedEventArgs e)
    {
        Console.WriteLine($"  📝 LOG: {DateTime.Now:HH:mm:ss} - {e.Symbol}: " +
                        $"${e.OldPrice:F2} → ${e.NewPrice:F2} " +
                        $"({e.ChangePercent:+0.00;-0.00}%)");
    }
    
    ~MarketLogger()
    {
        Unsubscribe();
    }
}

Wirering it all up

public class StockTradingDemo
{
    public static void Run()
    {
        var market = new StockMarket();
        var alerts = new AlertService(market);
        var bot = new TradingBot(market);
        var logger = new MarketLogger(market);
        
        // Subscribe all services
        Console.WriteLine("=== Subscribing Services ===");
        alerts.Subscribe();
        bot.Subscribe();
        logger.Subscribe();
        
        Console.WriteLine("\n=== Price Updates ===");
        market.UpdatePrice("AAPL", 150.00m);
        market.UpdatePrice("AAPL", 155.00m); // +3.33%
        market.UpdatePrice("AAPL", 165.00m); // +6.45% - triggers alert!
        
        Console.WriteLine("\n=== Unsubscribing Alert Service ===");
        alerts.Unsubscribe();
        
        Console.WriteLine("\n=== More Price Updates ===");
        market.UpdatePrice("GOOGL", 2800.00m);
        market.UpdatePrice("GOOGL", 2600.00m); // -7.14% - alert service won't see this!
        
        Console.WriteLine("\n=== Cleanup ===");
        bot.Unsubscribe();
        logger.Unsubscribe();
    }
}

The Result

=== Subscribing Services ===
  [Alert Service] Subscribed
  [Trading Bot] Subscribed
  [Market Logger] Subscribed

=== Price Updates ===
  🤖 BOT: AAPL trending up! Consider buying.
  📝 LOG: 14:30:15 - AAPL: $150.00 → $155.00 (+3.33%)
  🤖 BOT: AAPL trending up! Consider buying.
  📝 LOG: 14:30:15 - AAPL: $155.00 → $165.00 (+6.45%)
  🚨 ALERT: AAPL moved 6.45% ($155.00 → $165.00)

=== Unsubscribing Alert Service ===
  [Alert Service] Unsubscribed

=== More Price Updates ===
  📝 LOG: 14:30:15 - GOOGL: $2800.00 → $2600.00 (-7.14%)
  🤖 BOT: GOOGL trending down! Consider selling.
  📝 LOG: 14:30:15 - GOOGL: $2600.00 → $2650.00 (+1.92%)

=== Cleanup ===
  [Trading Bot] Unsubscribed
  [Market Logger] Unsubscribed

My Top Advices for Event Subscriptions

Here are some of my top advices that I really recommend you to follow when you are working with event subscriptions.

Always Store Event Handlers When Using Lambdas

private EventHandler _handler;

public void Subscribe()
{
    _handler = (s, e) => HandleEvent();
    publisher.Event += _handler;
}

public void Unsubscribe()
{
    publisher.Event -= _handler;
}

Implement IDisposable for Cleanup

public class EventSubscriber : IDisposable
{
    private StockMarket _market;
    private EventHandler _handler;
    
    public EventSubscriber(StockMarket market)
    {
        _market = market;
        _handler = OnPriceChanged;
        _market.PriceChanged += _handler;
    }
    
    private void OnPriceChanged(object? sender, StockPriceChangedEventArgs e)
    {
        // Handle event
    }
    
    public void Dispose()
    {
        _market.PriceChanged -= _handler;
    }
}

// Usage with using statement
using (var subscriber = new EventSubscriber(market))
{
    // Subscriber is active here
} // Automatically unsubscribed when disposed

Use Weak Event Pattern for Long-Lived Publishers

If you have publishers in your application that will live longer than the subscribers, I would recommend you to use a weak reference to prevent a memory leak. This is advanced, but it is important to know about. An example would be an application-level singleton - that would probably live longer than your subscriber.

Be Careful with Lambda Expressions

// ❌ You can't unsubscribe from this
publisher.Event += (s, e) => Console.WriteLine("Event!");

// ✅ A named method
publisher.Event += OnEvent;
void OnEvent(object? s, EventArgs e) => Console.WriteLine("Event!");

// ✅ A stored lambda
var handler = (object? s, EventArgs e) => Console.WriteLine("Event!");
publisher.Event += handler;

Common Pitfalls and Solutions

Forgetting to Unsubscribe

The problem is that your subscribers never get garbage collected.

And the solution is to always unsubscribe in finalizers or Dispose() methods.

Subscribing Multiple Times

The problem is that your handler gets called multiple times per event.

The solution is to make sure you unsubscribe before subscribing, or check if already subscribed.

publisher.Event -= OnEvent; // Remove if exists
publisher.Event += OnEvent; // Add fresh subscription

Exception in Event Handler

Your problem is that if one subscriber throws an exception, subsequent subscribers don't get notified.

A solution is to make sure publishers should catch exceptions when invoking events (advanced technique).

Key Takeaways

This time listed as dots and not a plain text. Here are 7 things I would recommend you to write down by hand to memorize it both in your head and hand.

Remember to always unsubscribe from events when you're done with them.
Always store lambda expression references if you need to unsubscribe later.
Make sure to use finalizers or IDisposable to make sure you clean up properly.
A single event can have multiple subscribers.
Using events will promote loose coupling in your application between the publishers and subscribers.
Making inline lambda expressions cannot be unsubscribed from. Why? They will create a new instance each time they are invoked.
Implementing the pub-sub pattern correctly, will make sure that your application is maintainable and can scale in the future.

You Made It!

Congratulations! You made it to the end of my events and delegates section. You should now have a good understanding of the following.

Delegates are type-safe function pointers. We can use them to enable callbacks.
Events are encapsulated delegates that makes the publisher-subscriber pattern possible.
Subscription Management is a technique to make sure that you can subscribe, unsubscribe, and avoid memory leaks in your application.

What you just went trough is fundamental to C# and .NET. It runs everything from UI frameworks like WPF or WinForms to huge complex backends with multiple services, and reactive programming.

Additional Resources

Some good resources you should take your time to read, if you got it.

Events - C#

.NET garbage collection - .NET

Learn about garbage collection in .NET. The .NET garbage collector manages the allocation and release of memory for your application.

Implement a Dispose method - .NET

In this article, learn to implement the Dispose method, which releases unmanaged resources used by your code in .NET.

Work with delegate types in C# - C#

Understanding Events in C#

Christian Schou Køster — Tue, 18 Nov 2025 07:36:38 +0100

I assume you have basic knowledge of delegates at this point. If not, please go back and read my first post in this section about events and delegates - Understanding Delegates in C#.

Using events we as the developers can provide a standardized way to implement the observer pattern in our applications. The observer pattern is a way for objects to notify other objects when something interesting happens.

What Are Events?

An event is a special type of a multicast delegate, where only the class declaring it can invoke it. Ever heard of encapsulation? Here you have it! Using events will encapsulate the logic and that is the very difference from a regular delegate.

I often tell other to think of events as a publish-subscribe setup.

The publisher will raise an event when something happens. This could be a domain event (UserCreatedDomainEvent).
The subscriber will listen for the events (the domain event in this example), and it will respond when the event arrives.
A subscriber is a standalone piece of code. They should not interact/affect others behavior
A subscriber should not trigger events itself. Only the event publisher should be allowed for raising it. e.g. an entity/domain object.

Why Use Events Instead of Plain Delegates?

When using an event you are promised some safety, that is not the case with delegates. Let me show you 😎

// ❌ Problem with public delegates
public delegate void WorkDelegate(int hours);
public WorkDelegate WorkPerformed; // Anyone can invoke this!

// ✅ Solution with events
public event WorkDelegate WorkPerformed; // Only this class can invoke

By using events, external code is only able to subscribe (+=) or unsubscribe -=. It won't be able to invoke the event or clear any subscriber of the event.

Creating Custom Events with Custom Delegates

Ever heard of workers? I will now show you how to build a worker system that can track when work is done. The first thing you will have to do is defining a custom delegate, and event.

Define a custom delegate

// 1. Define a custom delegate
public delegate void WorkPerformedDelegate(int hours, string workType);

public class Worker
{
    // 2. Declare an event using that delegate
    public event WorkPerformedDelegate? WorkPerformed;
    
    // 3. Method to perform work
    public void DoWork(int hours, string workType)
    {
        Console.WriteLine($"Working on {workType} for {hours} hours...");
        
        // 4. Raise the event
        OnWorkPerformed(hours, workType);
    }
    
    // 5. Protected method to raise the event
    // This pattern allows derived classes to customize event raising
    protected virtual void OnWorkPerformed(int hours, string workType)
    {
        // Invoke the event if there are subscribers
        WorkPerformed?.Invoke(hours, workType);
    }
}

Using the custom event

var worker = new Worker();

// Subscribe to the event
worker.WorkPerformed += (hours, workType) =>
{
    Console.WriteLine($"  → Logged: {hours} hours of {workType}");
};

worker.WorkPerformed += (hours, workType) =>
{
    Console.WriteLine($"  → Notified manager about {workType}");
};

// Trigger the work
worker.DoWork(8, "Development");

/* Output:
Working on Development for 8 hours...
  → Logged: 8 hours of Development
  → Notified manager about Development
*/

Creating Custom EventArgs

Instead of passing multiple parameters, it's a best practice to create a custom EventArgs class:

// Custom EventArgs class
public class WorkPerformedEventArgs : EventArgs
{
    public int Hours { get; }
    public string WorkType { get; }
    public DateTime Timestamp { get; }
    
    public WorkPerformedEventArgs(int hours, string workType)
    {
        Hours = hours;
        WorkType = workType;
        Timestamp = DateTime.Now;
    }
}

Why would you do that? 🤔 It's simple..

Having a custom class for event arguments, allows you to add new properties without breaking any of your existing code.
You can group related data in a single object.
It will follow standard .NET conventions.

Using The Built-in Generic EventHandler

In C# we got something named EventHandler and it is generic. Using this you can get rid of the custom delegates. 🙌 Let me show you how we can refactor our code to use that generic instead.

Defining the EventHandler

public class Worker
{
    // No custom delegate needed 👍
    // EventHandler is defined as:
    // public delegate void EventHandler(object? sender, TEventArgs e)
    
    public event EventHandler? WorkPerformed;
    
    public void DoWork(int hours, string workType)
    {
        Console.WriteLine($"Starting: {workType}");
        
        for (int i = 1; i <= hours; i++)
        {
            // Simulate work
            Console.WriteLine($"  Hour {i}...");
            
            // Raise event
            OnWorkPerformed(i, workType);
        }
        
        Console.WriteLine("Work completed!");
    }
    
    protected virtual void OnWorkPerformed(int hours, string workType)
    {
        var args = new WorkPerformedEventArgs(hours, workType);
        WorkPerformed?.Invoke(this, args);
    }
}

Clean and easy to maintain! 😎

Using The Generic Event

Now that we have defined the generic event, let's write some code that can actually use it.

var worker = new Worker();

worker.WorkPerformed += (sender, e) =>
{
    Console.WriteLine($"    [Logger] {e.Hours}h on {e.WorkType} at {e.Timestamp:HH:mm:ss}");
};

worker.DoWork(3, "Code Review");

/* Output:
Starting: Code Review
  Hour 1...
    [Logger] 1h on Code Review at 14:30:15
  Hour 2...
    [Logger] 2h on Code Review at 14:30:15
  Hour 3...
    [Logger] 3h on Code Review at 14:30:15
Work completed!
*/

The 1h, 2h, and 3h will arrive within the same second as we have no timer in the for loop earlier, but this was only meant for simulating some work. Let's see how we can use the built-in event handler to avoid any custom data.

Using Built-in EventHandler

When you have an event that do not need any custom data, there is no need for the generic. Instead we can swop it, and use the non-generic EventHandler.

public class Worker
{
    public event EventHandler? WorkPerformed;
    public event EventHandler? WorkCompleted; // No custom data needed 👍
    
    public void DoWork(int hours, string workType)
    {
        for (int i = 1; i <= hours; i++)
        {
            OnWorkPerformed(i, workType);
        }
        
        // Notify that all work is done
        OnWorkCompleted();
    }
    
    protected virtual void OnWorkPerformed(int hours, string workType)
    {
        var args = new WorkPerformedEventArgs(hours, workType);
        WorkPerformed?.Invoke(this, args);
    }
    
    protected virtual void OnWorkCompleted()
    {
        // EventArgs.Empty is a reusable empty instance
        WorkCompleted?.Invoke(this, EventArgs.Empty);
    }
}

That is how easy it is to work with events in .NET - pretty cool right?! 🔥 Thanks to the awesome engineers behind C# and the .NET framework, we get a lot of features out-of-the box and we are not forced to re-invent the wheel. I love it! 😄

So with all those small examples, let's put them all in a dish and see what we can do.

Building a Order Processing System

Let's take a real-world example where we will use what you just learned. This example is a simple order processing system that I just created.

// EventArgs for order processing
public class OrderProcessedEventArgs : EventArgs
{
    public string OrderId { get; }
    public decimal Amount { get; }
    public string Status { get; }
    
    public OrderProcessedEventArgs(string orderId, decimal amount, string status)
    {
        OrderId = orderId;
        Amount = amount;
        Status = status;
    }
}

public class OrderProcessor
{
    // Custom delegate with custom event
    public delegate void OrderValidationDelegate(string orderId);
    public event OrderValidationDelegate? OrderValidating;
    
    // Generic EventHandler
    public event EventHandler? OrderProcessed;
    
    // Standard EventHandler
    public event EventHandler? ProcessingCompleted;
    
    public void ProcessOrder(string orderId, decimal amount)
    {
        Console.WriteLine($"\n{'='.ToString().PadLeft(50, '=')}");
        Console.WriteLine($"Processing Order: {orderId}");
        Console.WriteLine($"{'='.ToString().PadLeft(50, '=')}");
        
        // Raise custom event
        OnOrderValidating(orderId);
        
        // Simulate processing
        Console.WriteLine("  → Processing payment...");
        
        // Raise generic event
        OnOrderProcessed(orderId, amount, "Completed");
        
        // Raise standard event
        OnProcessingCompleted();
    }
    
    protected virtual void OnOrderValidating(string orderId)
    {
        Console.WriteLine($"  → Validating order {orderId}");
        OrderValidating?.Invoke(orderId);
    }
    
    protected virtual void OnOrderProcessed(string orderId, decimal amount, string status)
    {
        var args = new OrderProcessedEventArgs(orderId, amount, status);
        OrderProcessed?.Invoke(this, args);
    }
    
    protected virtual void OnProcessingCompleted()
    {
        ProcessingCompleted?.Invoke(this, EventArgs.Empty);
    }
}

// Usage
var processor = new OrderProcessor();

// Subscribe to validation event (custom delegate)
processor.OrderValidating += (orderId) =>
{
    Console.WriteLine($"    ✓ Validated: {orderId}");
};

// Subscribe to processed event (generic EventHandler)
processor.OrderProcessed += (sender, e) =>
{
    Console.WriteLine($"    ✓ Order {e.OrderId}: ${e.Amount} - {e.Status}");
};

// Subscribe to completion event (standard EventHandler)
processor.ProcessingCompleted += (sender, e) =>
{
    Console.WriteLine("    ✓ All processing completed!");
    Console.WriteLine($"{'='.ToString().PadLeft(50, '=')}");
};

// Process orders
processor.ProcessOrder("ORD-001", 99.99m);
processor.ProcessOrder("ORD-002", 149.50m);

Code is clean and easy for other engineers to maintain or extend. The code above is a combination of custom events (delegates), work simulation, generic and standard events.

When running that code, we will get the following.

==================================================
Processing Order: ORD-001
==================================================
  → Validating order ORD-001
    ✓ Validated: ORD-001
  → Processing payment...
    ✓ Order ORD-001: $99.99 - Completed
    ✓ All processing completed!
==================================================

==================================================
Processing Order: ORD-002
==================================================
  → Validating order ORD-002
    ✓ Validated: ORD-002
  → Processing payment...
    ✓ Order ORD-002: $149.50 - Completed
    ✓ All processing completed!
==================================================

That is how easily you can build an order processor. No custom packages, etc... everything straight out of the C# language and .NET framework. It's clean and powerful. 😎

My Best Practices for Raising Events

I always follow this pattern when I am raising events in any application I am a part of.

protected virtual void OnEventName(EventArgs e)
{
    // 1. Make it virtual so derived classes can override
    // 2. Use null-conditional operator for safety
    // 3. Pass 'this' as sender to identify event source
    EventName?.Invoke(this, e);
}

I am using the virtual keyword to allow derived classes to do the following.

Add their own custom behavior before or after raising the event.
Stop the event from being raised under certain conditions.
Modify the event arguments.

When am I Using Each of The Event Types?

I know it can seem a bit confusing with custom, generic, non-generic, etc... Let's break them down and I will tell you what I am using for what/when.

Custom Delegate + Event

Use this when you are in a need of a super specific signature that doesn't fit the standard pattern.

public delegate void ProgressDelegate(int percent, string message);
public event ProgressDelegate? Progress;

EventHandler

This is the one I am using for 95% of my cases. It is also the recommended approach.

public event EventHandler? OrderProcessed;

EventHandler

This one should be used when you do not need to provide any custom data for the event.

public event EventHandler? Completed;

Key Takeaways

Summing it all down. An event in C# is an encapsulated delegate that provide a safe and managed way for objects to communicate. When you need to pass data along your events, use the EventArgs, and utilize EventHandler as the way for declaring your events.

Best practice is to follow the conventional OnEventName() method when you are raising new events. Mark the event methods virtual to provide support for extensibility in any derived class. Always use the null-conditional operator (.?) when raising an event and that you can only raise an event in the class that declared it.

What's Next?

That was quite a bit, but awesome that you made it to the end! Give yourself a high-five on that 🎉 Now that you know how to create and raise events, I think it is time to have a look at how we can subscribe to them.

In the next section we will take a closer look at how we properly subscribe and unsubscribe to events. I will also give you an introduction on how to avoid some common pitfalls (that I personally got into when I first started making publisher-subscriber apps) - especially memory leaks are one that many stumble upon.

Understanding Delegates in C#

Christian Schou Køster — Sat, 15 Nov 2025 05:10:32 +0100

Ever heard of delegates? If you ask me I would say it is one of the most powerful features in C# and really opened my eyes for the language when I first found out about them.

Yeah... they can be confusing for anyone new to C# I know that, but stay calm and follow along. I promise you will be eager to implement them after these three short posts.

What Are Delegates?

So.. what is it all about? A simple explanation would be to say that a delegate is a type-safe function pointer or a reference type and all it is doing is holding a reference to a method.

You can think of a delegate as a contract that dictates/defines/says how or what a method should look like (a kind of a signature), and then you can pass around references to methods that match that contract. Smart right? 🔥

In other words - a delegate makes it possible to "treat" your methods as variables that can be passed as a parameter, kept in a collection or invoked whenever you need it.

Why Use Delegates?

Delegates will give you several great things like:

Callback mechanisms. These will make it possible to execute code at specific points without tight coupling. What's not to like!? 👍
Event handling. This is the foundation for the event-driven programming model in .NET/C#.
Flexibility. You can pass different behaviors to methods at runtime like i mentioned above.
Decoupling. This will make it possible to separate the caller from the implementation details.

How to Declare a Custom Delegate?

Okay, I promised to give you some simple and practical examples. Let's start with the bare minimum or should we say basics. This is how you declare a custom delegate in C#.

public delegate bool SendConfirmationDelegate(string message);
public delegate void TaskCompletedDelegate();

What is going on? 🤔

The delegate keyword defines that this is a delegate type.
bool or void is your return type.
The SendConfirmationDelegate name is the name of the delegate.
A as we know it from methods, the parameters are defined in parentheses.

So... above are two new delegates. They create new types that can reference any method that has a matching signature

These declarations create new types that can reference any method with a matching signature. Remember the signature I mentioned earlier?

Real-World Example - A Notification System

I learn by seeing some real examples, and not just a snip of some code, and then the person behind the documentation expects that I totally get it. If you are like me, you have come to the right place.

Let's create a real-world example. I will now show you how to build a notification system in .NET.

Declaring The Delegates

public class NotificationService
{
    // Declare delegate types
    public delegate bool SendMessageDelegate(string message);
    public delegate void TaskCompletedDelegate();

    public void ProcessNotification(
        string message,
        SendMessageDelegate sendMessage,
        TaskCompletedDelegate onComplete = null)
    {
        Console.WriteLine("Processing notification...");
        
        // Invoke the send message delegate
        bool success = sendMessage?.Invoke(message) ?? false;
        
        if (success)
        {
            Console.WriteLine("✓ Message sent successfully");
        }
        else
        {
            Console.WriteLine("✗ Failed to send message");
        }
        
        // Invoke completion callback
        onComplete?.Invoke();
    }
}

That code look pretty simple. Did you notice the null-conditional operator ?.?That makes it possible for us to safely invoke the delegate only if it's not null.

Using the Notification Service

Okay, we have the implementation in place for the notification system. Let's now take a look at how to use it from different methods.

var notificationService = new NotificationService();

// Send via Email
notificationService.ProcessNotification(
    message: "Your order has shipped!",
    sendMessage: SendEmail,
    onComplete: LogCompletion);

bool SendEmail(string message)
{
    Console.WriteLine($"📧 Email sent: {message}");
    return true;
}

void LogCompletion()
{
    Console.WriteLine("✓ Notification logged");
}

// Send via SMS using lambda expressions
notificationService.ProcessNotification(
    message: "Your package arrives tomorrow",
    sendMessage: (msg) => 
    {
        Console.WriteLine($"📱 SMS sent: {msg}");
        return true;
    },
    onComplete: () => Console.WriteLine("✓ SMS notification complete"));

Did you just see a bright light? 💡 😅

The two examples above shows how much power the delegates gives us. The NotificationService is not aware or actually doesn't evene care about how the messages are sent.

This gives you the option to plug-and-play new options for notifications, like:

SMS
Emails
Push Notifications
etc...

Multicast Delegates - Notify Multiple Recipients

If you got amazed or happy about the examples above due to the power you are given, you are going to be super happy now! 😄 Delegates can hold references to multiple methods 🔥 This is referred to as a multicast delegate.

Creating a logger with multiple destinations

Let's take a practical example that I often practice in API's and systems in general. Logging to multiple destinations, but keeping it simple and maintainable for everyone.

public class Logger
{
    // Delegate that takes a message
    public delegate void LogMessageDelegate(string message);
    
    public void LogImportantEvent(string message)
    {
        // Create a multicast delegate
        LogMessageDelegate logger = WriteToConsole;
        logger += WriteToFile;
        logger += SendToMonitoring;
        
        // Single invocation calls all three methods
        Console.WriteLine("Logging event to all destinations...");
        logger(message);
    }
    
    private void WriteToConsole(string message)
    {
        Console.WriteLine($"[Console] {message}");
    }
    
    private void WriteToFile(string message)
    {
        Console.WriteLine($"[File] {message}");
    }
    
    private void SendToMonitoring(string message)
    {
        Console.WriteLine($"[Monitoring] {message}");
    }
}

// Usage
var logger = new Logger();
logger.LogImportantEvent("System started successfully");

/* Output:
Logging event to all destinations...
[Console] System started successfully
[File] System started successfully
[Monitoring] System started successfully
*/

When you call/invoke a multicast delegate, all the methods you have declared in the delegate are called in the order they have been defined. Awesome right?! 🙌

A few things I would mention, that I think are crucial or important to know are:

If you delegate has a return type, you will only get the value from the last method that was invoked in the delegate.
If any of the methods in your delegate throws an exception, any upcoming/next methods won't be executed/invoked.
You can use the += operator to add methods or -= to remove them again.

Lambda Expressions with Delegates

Lambda expressions is something most devs knows. Especially if you have been working with LINQ 😄 Using lambdas will make your code for the delegates more concise.

Let's take a look at a practical example where we will create a very simple payment processor.

public class PaymentProcessor
{
    public delegate void PaymentDelegate(decimal amount);
    
    public void ProcessPayment(decimal amount, PaymentDelegate processMethod)
    {
        Console.WriteLine($"Processing ${amount}...");
        processMethod(amount);
    }
}

// Usage with different payment methods
var processor = new PaymentProcessor();

// Traditional method reference
processor.ProcessPayment(100.00m, ChargeCreditCard);

void ChargeCreditCard(decimal amount)
{
    Console.WriteLine($"💳 Charged ${amount} to credit card");
}

// Lambda expression - inline
processor.ProcessPayment(50.00m, (amount) =>
{
    Console.WriteLine($"💰 Processed ${amount} via PayPal");
});

// Lambda expression - single line
processor.ProcessPayment(25.00m, amt => Console.WriteLine($"📱 Processed ${amt} via Apple Pay"));

As you can see, lambda expressions are very useful if you have some simple, one-off logic that you don't need to reuse.

Practical Example - Data Processing Pipeline

Let's take another round looking at a practical example. In this example I will show you how to create a flexible data processing setup using delegates.

public class DataProcessor
{
    public delegate bool ValidationDelegate(string data);
    public delegate string TransformDelegate(string data);
    
    public void ProcessData(
        string input,
        ValidationDelegate validator,
        TransformDelegate transformer)
    {
        Console.WriteLine($"Input: {input}");
        
        // Validate
        if (!validator(input))
        {
            Console.WriteLine("❌ Validation failed");
            return;
        }
        
        // Transform
        string result = transformer(input);
        Console.WriteLine($"Output: {result}");
    }
}

// Usage
var processor = new DataProcessor();

processor.ProcessData(
    input: "hello world",
    validator: (data) => !string.IsNullOrEmpty(data),
    transformer: (data) => data.ToUpper());

processor.ProcessData(
    input: "test@christian-schou.com",
    validator: (email) => email.Contains("@"),
    transformer: (email) => $"User: {email.Split('@')[0]}");

/* Output:
Input: hello world
Output: HELLO WORLD

Input: test@christian-schou.com
Output: User: test
*/

Two Ways to Invoke Delegates

Delegates can be invokes in two ways in C#, this is how you can do it.

public delegate void MessageDelegate(string msg);

MessageDelegate handler = (msg) => Console.WriteLine(msg);

// Method 1: Direct invocation
handler("Hello");

// Method 2: Using Invoke method (safer with null checking)
handler?.Invoke("World");

Are there any difference? Nope 😎 Both ways gives you the same result. I prefer option two, where you explicitly use the Invoke() method as it is more descriptive and works great in condition with null-conditional operators.

Building a Simple Task Scheduler

Okay, let's take another practical example that a lot of applications often has some sort of, a task scheduler. This one will be my last practical example in this post, and will tie everything together that I have explained and showed above.

public class TaskScheduler
{
    public delegate void TaskDelegate(string taskName);
    
    public void RunTasks(params (string name, TaskDelegate task)[] tasks)
    {
        Console.WriteLine($"Running {tasks.Length} tasks...\n");
        
        foreach (var (name, task) in tasks)
        {
            Console.WriteLine($"Executing: {name}");
            task?.Invoke(name);
            Console.WriteLine();
        }
        
        Console.WriteLine("All tasks completed!");
    }
}

// Usage
var scheduler = new TaskScheduler();

scheduler.RunTasks(
    ("Backup Database", (name) => Console.WriteLine($"  ✓ {name} completed")),
    ("Send Reports", (name) => Console.WriteLine($"  ✓ {name} sent to admin")),
    ("Clear Cache", (name) => Console.WriteLine($"  ✓ {name} cleared successfully"))
);

/* Output:
Running 3 tasks...

Executing: Backup Database
  ✓ Backup Database completed

Executing: Send Reports
  ✓ Send Reports sent to admin

Executing: Clear Cache
  ✓ Clear Cache cleared successfully

All tasks completed!
*/

When building applications, it is very common practice to run small tasks in sequence. This could be stuff like making a backup, sending a data report, etc... In my example above, we are using the built-in task scheduler in .NET and it accepts any number of taks, that each has a name a small amount of code to execute.

Building you applications like I have shown above will make your code easy to read, easy to extend and let it stay organized. This way it won't be a nightmare to introduce another step in your sequence of tasks that goes into making a backup.

The final result using delegates, and not just in the example above, but in any application is a clean and super flexible way to chain operations.

Key Takeaways

As I mentioned at the very beginning, delegates in C# is a type-safe way of referencing methods. They will make your applications flexible as they allow you to pass behavior as parameters - that is pretty cool right?! 🔥 If you ask me, it's the perfect choice if you want to make your code clean and modular at the same time without reinventing the wheel. One very nice feature I really like are the multicast delegates. They allows us to hold multiple methods and trigger all of them in one go.

If you are looking for a quick and readable delegate, stick to the lambda expressions. They will make your code concise and easy to maintain. I have been asked quite a few times about the usage of the null-conditional operator, and I always tell developers that it is good practice to use it, as it will prevent null reference exceptions when invoking the delegates.

What's Next?

This post was about delegates. Now I think it is time for you to take a look at events. Events build upon delegates (see what I did there), and they will give us even more power in C# to create e.g. a publish-subscribe pattern.

Resources

Explore delegate types in C#. A delegate is a date type that refers to a method with a defined parameter list and return type. You use delegates to pass methods as arguments to other methods.

Delegates - C# language specification

This chapter defines delegates, which are objects that hold type safe function pointers.

Sign up for a marketstack account and get instant access to market data for 125,000+ stock tickers, 72 global stock exchanges and 30 years of historical data.

Advanced C# Features

Christian Schou Køster — Fri, 14 Nov 2025 20:05:10 +0100

Are you ready to get even better at C#? In this collection I am breaking down 17 advanced, but awesome features of C# for you.

When you have finished reading/watching all of them, you have been introduced to practical and simple examples with explanation of some cool features like:

Events
Delegates
Records
Pattern Matching
Span
And much much more...

C# for Beginners

Christian Schou Køster — Tue, 30 Sep 2025 23:35:15 +0200

C# is a powerful language that works on many platforms. You can use it to create various applications, including mobile apps for Windows, Android, and iOS, as well as games, websites, and desktop software.

Once you grasp the basics of C# and .NET development, many opportunities open up. Whether you want to build mobile apps, move into web development, or explore other areas, having solid fundamentals makes it easier to shift between technology stacks.

In this course, I will teach you the fundamentals of C# programming in a clear and straightforward way. You’ll go beyond just syntax; you’ll learn best practices and techniques that can boost your growth as a developer.

Each section includes focused video lectures and hands-on coding exercises. These exercises combine academic concepts with real-world situations, helping you build strong problem-solving skills. To become a successful programmer with high-paying job options and career flexibility, you need to think like a programmer. These exercises are designed to help with that. Each exercise comes with solutions, so you can compare your approach with mine and find areas to improve.

While free tutorials may teach C#, this course provides a deeper understanding. If you want to be a well-rounded developer with solid job prospects, this course is for you. For each topic, you will learn not just what to do, but also why and how. You will encounter common errors that often happen in real C# development, complete with detailed explanations and solutions to help you troubleshoot effectively.

Validate Settings Using The IOptions Pattern in .NET

Christian Schou Køster — Tue, 13 May 2025 21:02:21 +0200

We have all been there 😅 configuration options or settings that we needed in our applications, but they were not available or in the wrong format. In this quick tutorial I am going to show you how easy it is to add validation to your options/settings classes using IOptions.

With the options-pattern, we can write strongly typed options/settings that our application can use at runtime. This makes our code more robust as we become type-safe.

The only problem I have encountered a lot of times with users of my code is that they write invalid values for their option fields. It tends to cause a lot of problems as the code tries to parse and use them, and that results in errors as they are incorrect.

So... I thought it would be nice to have a quick tutorial that showcases how easily we can get around that problem. It is actually fairly simple to solve that problem and make sure the users of your software are using it in the intended way.

🙋 What is a strongly typed configuration?

A strongly typed configuration is a class where we define each settings/options property inside. Let's say I wanted to integrate my app with the Marketstack API, I could create a MarketstackSettings class that would contain the required details.

public sealed class MarketstackSettings
{
  public string AccessKey { get; init; }
}

This of course has to be defined inside appsettings.json for the application, so that we can get the values for our configuration of the app.

"MarketstackSettings" {
  "AccessKey" : "YOUR_ACCESS_KEY"
}

If you want a key, you can get it by signing up at the link below.

marketstack Logo

Alright! Now we simply need to configure the MarketstackSettings at the startup of our app.

builder.Services.Configure(
  builder.Configuration.GetSection(nameof(MarketstackSettings)));

This makes it able for us to inject the configuration values for that settings class using IOptions().

public class MarketstackService : IMarketstackService
{
  private readonly MarketstackSettings _marketstackSettings;

  public class MarketstackService(IOptions marketstackSettings)
  {
    _marketstackSettings = marketstackSettings.Value;
  }

  public void GetMarketData()
  {
    var accessToken = _marketstackSettings.AccessKey;

    ...
  }
}

🎯 Why isn't that a bullet-proof solution?

Let's say we would ship our app with the configuration of our market settings like I did above. That would make the user of the app responsible for entering the correct information in the configuration of the app.

Many developers would have no problem doing this if they carefully read the documentation and understood what was expected by the app at startup. But from experience I just know that most engineers skip where they can (not because they are dumb, but because they are lazy and will deal with issues like this later). So... how can we solve that problem? 😄

We could use validation for the configuration properties ⚙️

🧑‍💻 Using validation with the options-pattern

Luckily for us, .NET provides an easy way of performing validation for the properties we have in the settings class. All we have to do is add data annotations on the properties.

Let's say we wanted to make the AccessKey required. All we have to do is add the [Required] attribute on the property.

public sealed class MarketstackSettings
{
  [Required]
  public string AccessKey { get; init; }
}

Now for the configuration part, we need to tell .NET that we want to validate the data annotations on the properties.

It's a minor change. Delete the configuration from before and update it to the following:

builder.Services
  .AddOptions()
  .BindConfiguration(nameof(MarketstackSettings))
  .ValidateDataAnnotations();

What did we just do now? 🤔

AddOptions() will return OptionsBuilder() that will bind to our MarketstackSettings class.
BindConfiguration(nameof(MarketstackSettings)) will make sure to bind the actual values from our configuration file appsettings.json.
ValidateDataAnnotations() will enable validation by using the added data annotations on the properties in our settings class. Here it will make sure there is a value in the AccessKey property as we specified that it was required.

Now if you try to inject the MarketstackSettings and the AccessKey is missing, we would encounter a runtime exception. Awesome! ✌️

🚀 Validate settings at startup

What if I told you that it is possible to validate your configuration properties at startup to avoid runtime exceptions later down the road? 😎

It is totally possible, and all you have to do is call ValidateOnStart() when you configure the settings.

builder.Services
  .AddOptions()
  .BindConfiguration(nameof(MarketstackSettings))
  .ValidateDataAnnotations()
  .ValidateOnStart();

Now our application will throw an exception when starting up if the AccessKey is missing during startup.

📝 Summary

In this short tutorial you learned how to use the options-pattern in .NET for retrieving configuration values from appsettings.json and bind them to your configuration classes.

You also learned how to validate the data annotations on the settings classes from the option values, and do it at the startup of your application. This should help you minimize the number of runtime errors or exceptions that could happen.

If you got any questions, please leave a comment below. Until next time - happy coding! ✌️

Avoid Complexity with the State Design Pattern in .NET

Christian Schou Køster — Tue, 06 May 2025 21:24:00 +0200

I am reading a lot of code on the internet in open-source repositories, when making reviews on pull-requests and understanding other developers' code. One thing that I often see is code full of if-else statements checking tons of various states 😅

It's fine when we got a small application doing a simple operation/task, but imagine a codebase that is growing. If your code has a lot of conditional branches (if-else statements), it can be hard to read and understand by others (or yourself in half a year, when you need to refactor something).

How can we solve it? That is what I am going to show you in this article about the state design pattern. It will help you implement a more maintainable, extensible and testable code base in your projects. ✌️

I will show you a practical example of how to do it. More specifically, we will be building a document processing system, where the documents will go through various transitions and change state from e.g. draft to review, approved and finally published. 🔥

Before I show the good stuff, I want to briefly tell you a little about the state design pattern and what the real problem is with conditional logic. If you are ready, let's get to it.

💡 What is the State Design Pattern?

So... What is it really all about? The State Design Pattern is a behavioral design pattern that allows an object to alter its behavior when its internal state changes. It will do it by making an object change its class, providing a clean way to organize your code that has state-dependent behavior. 💪

Some key takeaways about the state pattern that I want you to know are 🧠

The class that contains the state and delegates state-specific behavior to the current state object is what we refer to as context.
A common interface for all concrete states is defined as a state interface.
Classes that implement the state interface and provide the behavior associated with a particular state are what we refer to as concrete states.

🤔 The Problem with Conditional Logic

Before I show you how to use the state design pattern, I would like to address the problem with excessive use of conditional logic in our software.

To demonstrate is with code, I have written a simple program for the Document transition that I will be fixing later. When a new state or behavior is added, the code-base grows exponentially, which is the big problem.

Another thing that you should consider is that I am breaking the single responsibility principle as I make my class handle all business logic for the states. While adding new states, it requires us to modify existing code, which is a violation of the open/closed principle. You can read more about SOLID in the article below.

SOLID Principles - The art of writing maintainable code 👨‍💻

Learn what the SOLID principles are about and how you can use them to write clean and maintainable code in your applications. With C# examples.

Christian Schou KøsterChristian Schou Køster

And the last but not least thing is that testing our code (which is crucial) gets more complex, at you would have to test all conditional branches separately. Let's take a look at it, shall we 😄

public class Document
{
    public enum Status
    {
        Draft,
        InReview,
        Approved,
        Published
    }

    public Status CurrentStatus { get; private set; } = Status.Draft;
    
    public string Content { get; set; }
    
    public void Edit(string newContent)
    {
        if (CurrentStatus == Status.Draft)
        {
            Content = newContent;
        }
        else if (CurrentStatus == Status.InReview)
        {
            throw new InvalidOperationException("Cannot edit document in review");
        }
        else if (CurrentStatus == Status.Approved)
        {
            throw new InvalidOperationException("Cannot edit approved document");
        }
        else if (CurrentStatus == Status.Published)
        {
            throw new InvalidOperationException("Cannot edit published document");
        }
    }
    
    public void Submit()
    {
        if (CurrentStatus == Status.Draft)
        {
            CurrentStatus = Status.InReview;
        }
        else if (CurrentStatus == Status.InReview)
        {
            throw new InvalidOperationException("Document is already in review");
        }
        // More conditionals...
    }
    
    public void Approve()
    {
        if (CurrentStatus == Status.InReview)
        {
            CurrentStatus = Status.Approved;
        }
        else if (CurrentStatus == Status.Draft)
        {
            throw new InvalidOperationException("Document must be reviewed before approval");
        }
        // More conditionals...
    }
    
    public void Publish()
    {
        // Even more conditionals...
    }
}

Can you see the problems? We will end up breaking the SOLID principles and have a codebase growing exponentially and getting more complex with each addition. Let's fix that! 💪

✍️ Visualizing the State Pattern for our solution

Below is a class diagram that visualizes the state pattern structure for our document transitioning app in this article. It will be totally different from yours as it all depends on your requirements for the application you are building.

All states are inheriting from IDocumentState to make sure that all business logic is taken care of in the state implementation itself. This will promote the SOLID principles and make transitions explicit. What's not to like!? 🔥

Let's take a look at how a document can change states and the lifecycle of the document in our app.

In all its essence, it is fairly simple. A document will always be created in a draft state (the context class will handle that when constructing the document).

🧑‍💻 Implementing the State Pattern

So, let's move on to the good stuff and write some code that will solve our problem. I will start by defining the IDocumentState that will define the states for a Document.

public interface IDocumentState
{
    void Edit(Document document, string content);
    void Submit(Document document);
    void Approve(Document document);
    void Publish(Document document);
    void Reject(Document document);
    string GetStateName();
}

Let's implement the concrete classes for each state. As mentioned earlier, they will inherit from the abstraction `IDocumentState`.

public class DraftState : IDocumentState
{
    public void Edit(Document document, string content)
    {
        document.Content = content;
    }
    
    public void Submit(Document document)
    {
        document.SetState(new ReviewState());
    }
    
    public void Approve(Document document)
    {
        throw new InvalidOperationException("Cannot approve a draft document. It must be submitted for review first.");
    }
    
    public void Publish(Document document)
    {
        throw new InvalidOperationException("Cannot publish a draft document. It must be reviewed and approved first.");
    }
    
    public void Reject(Document document)
    {
        throw new InvalidOperationException("Cannot reject a draft document. It must be submitted for review first.");
    }
    
    public string GetStateName() => "Draft";
}

public class ReviewState : IDocumentState
{
    public void Edit(Document document, string content)
    {
        throw new InvalidOperationException("Cannot edit a document that is under review.");
    }
    
    public void Submit(Document document)
    {
        throw new InvalidOperationException("Document is already under review.");
    }
    
    public void Approve(Document document)
    {
        document.SetState(new ApprovedState());
    }
    
    public void Publish(Document document)
    {
        throw new InvalidOperationException("Cannot publish a document under review. It must be approved first.");
    }
    
    public void Reject(Document document)
    {
        document.SetState(new DraftState());
    }
    
    public string GetStateName() => "In Review";
}

public class ApprovedState : IDocumentState
{
    public void Edit(Document document, string content)
    {
        throw new InvalidOperationException("Cannot edit an approved document.");
    }
    
    public void Submit(Document document)
    {
        throw new InvalidOperationException("Document is already approved.");
    }
    
    public void Approve(Document document)
    {
        throw new InvalidOperationException("Document is already approved.");
    }
    
    public void Publish(Document document)
    {
        document.SetState(new PublishedState());
    }
    
    public void Reject(Document document)
    {
        document.SetState(new DraftState());
    }
    
    public string GetStateName() => "Approved";
}

public class PublishedState : IDocumentState
{
    public void Edit(Document document, string content)
    {
        throw new InvalidOperationException("Cannot edit a published document.");
    }
    
    public void Submit(Document document)
    {
        throw new InvalidOperationException("Document is already published.");
    }
    
    public void Approve(Document document)
    {
        throw new InvalidOperationException("Document is already published.");
    }
    
    public void Publish(Document document)
    {
        throw new InvalidOperationException("Document is already published.");
    }
    
    public void Reject(Document document)
    {
        throw new InvalidOperationException("Cannot reject a published document.");
    }
    
    public string GetStateName() => "Published";
}

Finally we will implement the context class for the Document where the state of the document can be changed.

public class Document
{
    private IDocumentState _currentState;
    
    public string Content { get; set; }
    
    public Document()
    {
        // Initial state is Draft
        _currentState = new DraftState();
    }
    
    public void SetState(IDocumentState state)
    {
        _currentState = state;
    }
    
    public string GetCurrentStateName() => _currentState.GetStateName();
    
    // Operations delegated to the current state
    public void Edit(string content) => _currentState.Edit(this, content);
    
    public void Submit() => _currentState.Submit(this);
    
    public void Approve() => _currentState.Approve(this);
    
    public void Publish() => _currentState.Publish(this);
    
    public void Reject() => _currentState.Reject(this);
}

As you can see a Document is now capable of changing state to any of the defined states, as they have been defined using the abstraction IDocumentState for the state implementation.

The constructor of the Document class makes sure that the initial state of the document is set to DraftState. When you try to change the state of the document, each state will make sure to validate if you can actually change the state to that state your are trying to. It's readable and maintainable! No more if-else statements! 🙌

💛 Key take aways from the changed implementation

By refactoring the implementation from the conditional logic to the state pattern, we have achieved several benefits.

We have made the Document state transitions explicit. This means transitions are now clear and contained within the Document itself.
All conditional logic has been removed, as each state is responsible of its own behavior. By doing this we conform with the single responsibility principle.
Adding new states is made easy, simply by adding a new state class and inheriting from the abstraction. By doing this we comply with the open/closed principle, as new states doesn't require us to change existing code.
Testing is now made much easier as we can test each state implementation isolated.

Now that you have seen how to implement the business logic, let's take a look at how we can unit test it properly.

✅ Unit Testing the implementation

Alright, we have the business logic in place but what about testing. Let's see how we can properly unit test our business logic for the states using xUnit, NSubstitute, and AwesomeAssertions for adding some syntactic sugar.

using System;
using FluentAssertions;
using NSubstitute;
using Xunit;

public class DocumentStateTests
{
    [Fact]
    public void Document_ShouldStartInDraftState()
    {
        // Arrange
        var document = new Document();
        
        // Act & Assert
        document.GetCurrentStateName().Should().Be("Draft");
    }
    
    [Fact]
    public void DraftDocument_CanBeEdited()
    {
        // Arrange
        var document = new Document();
        var newContent = "Updated content";
        
        // Act
        document.Edit(newContent);
        
        // Assert
        document.Content.Should().Be(newContent);
    }
    
    [Fact]
    public void DraftDocument_CanBeSubmittedForReview()
    {
        // Arrange
        var document = new Document();
        
        // Act
        document.Submit();
        
        // Assert
        document.GetCurrentStateName().Should().Be("In Review");
    }
    
    [Fact]
    public void DocumentInReview_CannotBeEdited()
    {
        // Arrange
        var document = new Document();
        document.Submit(); // Move to review state
        
        // Act & Assert
        Action editAction = () => document.Edit("New content");
        editAction.Should().Throw()
            .WithMessage("Cannot edit a document that is under review.");
    }
    
    [Fact]
    public void DocumentInReview_CanBeApproved()
    {
        // Arrange
        var document = new Document();
        document.Submit(); // Move to review state
        
        // Act
        document.Approve();
        
        // Assert
        document.GetCurrentStateName().Should().Be("Approved");
    }
    
    [Fact]
    public void DocumentInReview_CanBeRejected()
    {
        // Arrange
        var document = new Document();
        document.Submit(); // Move to review state
        
        // Act
        document.Reject();
        
        // Assert
        document.GetCurrentStateName().Should().Be("Draft");
    }
    
    [Fact]
    public void ApprovedDocument_CanBePublished()
    {
        // Arrange
        var document = new Document();
        document.Submit(); // Move to review state
        document.Approve(); // Move to approved state
        
        // Act
        document.Publish();
        
        // Assert
        document.GetCurrentStateName().Should().Be("Published");
    }
    
    [Fact]
    public void PublishedDocument_CannotBeEdited()
    {
        // Arrange
        var document = new Document();
        document.Submit(); // Move to review state
        document.Approve(); // Move to approved state
        document.Publish(); // Move to published state
        
        // Act & Assert
        Action editAction = () => document.Edit("New content");
        editAction.Should().Throw()
            .WithMessage("Cannot edit a published document.");
    }
}

That is how you can test the transition workflow for a document. But what about a real-world project? Are you interested in seeing how this could be applied in e.g. a web API?

✨ A Real-World example - Document Workflow API

We have the business logic in place for how a document should be able to change state. Let's try implementing this in an actual application. For demonstration purposes, I will be creating a Document Workflow API which allows users to manage documents in a document repository.

Here is the code seen from a high-level to give you an idea on how I am designing the controller using the document repository.

// DocumentController.cs
[ApiController]
[Route("api/[controller]")]
public class DocumentController : ControllerBase
{
    private readonly IDocumentRepository _documentRepository;
    
    public DocumentController(IDocumentRepository documentRepository)
    {
        _documentRepository = documentRepository;
    }
    
    [HttpPut("{id}/content")]
    public IActionResult UpdateContent(int id, [FromBody] UpdateContentRequest request)
    {
        try
        {
            var document = _documentRepository.GetById(id);
            document.Edit(request.Content);
            _documentRepository.Save(document);
            return Ok();
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }
    
    [HttpPost("{id}/submit")]
    public IActionResult Submit(int id)
    {
        try
        {
            var document = _documentRepository.GetById(id);
            document.Submit();
            _documentRepository.Save(document);
            return Ok();
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }
    
    [HttpPost("{id}/approve")]
    public IActionResult Approve(int id)
    {
        try
        {
            var document = _documentRepository.GetById(id);
            document.Approve();
            _documentRepository.Save(document);
            return Ok();
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }
    
    [HttpPost("{id}/publish")]
    public IActionResult Publish(int id)
    {
        try
        {
            var document = _documentRepository.GetById(id);
            document.Publish();
            _documentRepository.Save(document);
            return Ok();
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }
    
    [HttpPost("{id}/reject")]
    public IActionResult Reject(int id)
    {
        try
        {
            var document = _documentRepository.GetById(id);
            document.Reject();
            _documentRepository.Save(document);
            return Ok();
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(ex.Message);
        }
    }
}

public class UpdateContentRequest
{
    public string Content { get; set; }
}

// IDocumentRepository.cs
public interface IDocumentRepository
{
    Document GetById(int id);
    void Save(Document document);
}

This is a simple API that uses the state of each document to handle requests. I know business logic should not live in the controller actions, but for demo purposes it should be fine. 😅

🙌 Improving the pattern with dependency injection

You might have given it a thought, but how can we act in the state implementations when something happens and we want to trigger something outside the state class? I am so glad you asked 😆

In a real world scenario, we probably want to use dependency injection in our states to apply more complex logic. For demo purpose, I will show you an example with the ReviewState. We are going to refactor the Approve state a little by making it validating the document and ecent send a notification on success.

public class ReviewState : IDocumentState
{
    private readonly INotificationService _notificationService;
    private readonly IDocumentValidator _validator;
    
    public ReviewState(INotificationService notificationService, IDocumentValidator validator)
    {
        _notificationService = notificationService;
        _validator = validator;
    }
    
    public async Task Edit(Document document, string content)
    {
        throw new InvalidOperationException("Cannot edit a document that is under review.");
    }
    
    public async Task Submit(Document document)
    {
        throw new InvalidOperationException("Document is already under review.");
    }
    
    public async Task Approve(Document document)
    {
        // Check if the document meets requirements
        var validationResult = await _validator.ValidateForApproval(document);
        if (!validationResult.IsValid)
        {
            throw new ValidationException(validationResult.ErrorMessage);
        }
        
        var approvedState = new ApprovedState(_notificationService);
        document.SetState(approvedState);
        
        // Notify relevant parties
        await _notificationService.NotifyDocumentApproved(document);
    }
    
    // You can add more methods if you need that...
    
    public string GetStateName() => "In Review";
}

Get the point? 😊 Now we are performing validation using IDocumentValidator where you can have different business logic to make sure that a document is OK to be approved. When the document is approved a notification is sent or published in the app using the INotificationService.

🗂️ Persisting State with Entity Framework Core

So... one thing that will be a challenge for you is persisting the state of a document in a database. I am almost always using EF Core to persist my data, as code is generated from the model itself.

Let's start by defining a DocumentEntity that we can use to represent documents in the database.

public class DocumentEntity
{
    public int Id { get; set; }
    public string Content { get; set; }
    public string StateName { get; set; } // Store state name as string
}

Now let's add a simple implementation of the IDocumentRepository that we used in our DocumentController earlier. For this we need the database context and a factory to create state objects.

We can start by writing the factory. I will name it IDocumentStateFactory and add a method named CreateState which is responsible for creating the state using the state name.

public interface IDocumentStateFactory
{
    IDocumentState CreateState(string stateName);
}

public class DocumentStateFactory : IDocumentStateFactory
{
    private readonly IServiceProvider _serviceProvider;
    
    public DocumentStateFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public IDocumentState CreateState(string stateName)
    {
        return stateName switch
        {
            "Draft" => _serviceProvider.GetRequiredService(),
            "In Review" => _serviceProvider.GetRequiredService(),
            "Approved" => _serviceProvider.GetRequiredService(),
            "Published" => _serviceProvider.GetRequiredService(),
            _ => throw new ArgumentException($"Unknown state: {stateName}")
        };
    }
}

In the DocumentRepository we can now use this factory. It will just implement the two declared methods from the interface.

public class DocumentRepository : IDocumentRepository
{
    private readonly DocumentDbContext _dbContext;
    private readonly IDocumentStateFactory _stateFactory;
    
    public DocumentRepository(DocumentDbContext dbContext, IDocumentStateFactory stateFactory)
    {
        _dbContext = dbContext;
        _stateFactory = stateFactory;
    }
    
    public Document GetById(int id)
    {
        var entity = _dbContext.Documents.Find(id);
        if (entity == null)
        {
            throw new DocumentNotFoundException(id);
        }
        
        var document = new Document();
        document.Id = entity.Id;
        document.Content = entity.Content;
        
        // Recreate the state object based on the stored state name
        var state = _stateFactory.CreateState(entity.StateName);
        document.SetState(state);
        
        return document;
    }
    
    public void Save(Document document)
    {
        var entity = _dbContext.Documents.Find(document.Id) ?? new DocumentEntity { Id = document.Id };
        
        entity.Content = document.Content;
        entity.StateName = document.GetCurrentStateName();
        
        if (entity.Id == 0)
        {
            _dbContext.Documents.Add(entity);
        }
        
        _dbContext.SaveChanges();
    }
}

Finally we have to register our services to the service container so the app knows how to resolve the services for dependency injection. I have made an extension class for IServiceCollection to handle that.

public void AddDocumentStates(this IServiceCollection services)
{
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    // Other services...
}

Add the migrations, and woila you have solution that is able to persist the states in the database as well.

💭 When should you use the state pattern, and when should you avoid it?

This is the hard part - when should you implement the state pattern, and when should you avoid it to keep the code base as small as possible? 😅

✅ When to use it?

If you are looking for a way to avoid duplicating state-checks, you can utilize the state pattern to centralize your check behavior. This is great in scenarios where you have multiple behaviors associated with a single object, as we had in the example above.

If the object behavior depends on the current state of the object and you need to update the state during runtime, it would be a good idea to use the state pattern. This way you can avoid writing tens of if statements making the code complex to maintain.

When your application might change in the future in relation to the states and you would like to make sure that nothing currently implemented will break during addition of new states.

❌ When to avoid it?

If the object is not going to change state often or you already know that the business logic behind the object will remain the same from the first deployment, skip it.

When your objects only contains a few states and their behavior is very basic, implementing the full pattern might be a little overkill. This could be the case if you are just throing an exception like I did above for most of the state change operations.

💡

You should always ask yourself this question: Do I have complex transitions in object making the state change? If yes, apply the pattern as it makes your life easier (speaking of experience 🥵).

📝 Summary

In this .NET tutorial I have shown you how powerful a tool the state pattern is to manage complex state-dependent behaviors. By encapsulating our state-specific business logic into separate state classes, we can achieve the following:

Zero to none sprawling conditional logic in our code. The tens of hundreds if-else statements are forever gone when it comes to the state change.
The codebase is made maintainable and future proof as we can easily extend it and it is testable at the same time!
State transitions are made explicit and controlled. The code is easier to read for you and for others who will refactor or extend it in the future.

One thing I will tell you about design patterns is that they are awesome tools we have in our toolbox, but use them where it makes sense. Dont force them into your app because a senior developer or architect told you to in a task-description if it doesn't make sense.

If you got any questions, please let me know in the comments below. Until next time - happy coding! ✌️

🌐 References

A friendly substitute for .NET mocking libraries | NSubstitute

NSubstitute

Home

Documentation site for the xUnit.net unit testing framework

xUnit.net

Awesome Assertions

Awesome AssertionsThe AwesomeAssertions team, Dennis Doomen

How To Use GitHub Actions To Build And Test .NET Projects

Christian Schou Køster — Thu, 09 Jan 2025 18:00:32 +0100

GitHub is primarily known for its awesome Git repository hosting features. Over the past year GitHub has expanded its capabilities to also include other features. One of the services has been named GitHub Actions, and it's pretty cool if you ask me! ✌️

GitHub Actions was made available to the public in 2018 and has since gained in popularity due to its great extensibility and features. I could talk a lot about this tool, but that's not what you are here for. 😅

GitHub Actions

Easily build, package, release, update, and deploy your project in any language—on GitHub or any external system—without having to run code yourself.

GitHub

GitHub Actions is an integrated CI/CD tool in the GitHub platform that will help you build and do various tasks on your code and projects. By using these actions you can fully avoid hosting a build server as we used to back in the days. 😁

If you are ready, then let's move on to the stuff you are here for. 🔥

Your First Workflow With GitHub Actions

Before we dive in to the good stuff, I wan't to highlight what the different words I will be using mean. A workflow at GitHub Actions is what you will know as a build process. A Workflow is described using YAML.

Workflow files can get rather complex as you start to dive deeper and deeper into how the build process is and each step that goes into your build process. Fear not! There are lots of templates you can use and tweak to fit on your project.

An Easy Way

A guy named Tim Heuer has made a project named dotnet-workflow and it will help you build most .NET projects.

GitHub - timheuer/dotnet-workflow: Template for quickly creating a starting GitHub Actions workflow for a .NET Core app

Template for quickly creating a starting GitHub Actions workflow for a .NET Core app - timheuer/dotnet-workflow

GitHubtimheuer

According to Tim, who made the README for the project, it is:

A simple global tool to give you a handy and quick method to create a GitHub Actions workflow file for continuous integration (CI) builds.

To use it, you would have to install the package from NuGet with the following command, as it's not available in dotnet by default.

dotnet new --install TimHeuer.GitHubActions.Templates

When you have installed the package, you can invoke it from your terminal with the following command:

dotnet new workflow

dotnet new workflow

You should now have a YAML file in the .github/workflows folder with the name of your project folder. This YAML file will contain the steps required to build and test your .NET project/solution.

This is what you should have in your YAML file. You can safely remove the part with Restore workloads if you are not using Aspire, Wasm or Maui.

name: "Build"

on:
  push:
    branches:
      - main
    paths-ignore:
      - '**/*.md'
      - '**/*.gitignore'
      - '**/*.gitattributes'
  pull_request:
    branches:
      - main
    paths-ignore:
      - '**/*.md'
      - '**/*.gitignore'
      - '**/*.gitattributes'
  workflow_dispatch:
      
jobs:
  build:
    name: Build 
    runs-on: ubuntu-latest
    env:
      DOTNET_CLI_TELEMETRY_OPTOUT: 1
      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
      DOTNET_NOLOGO: true
      DOTNET_GENERATE_ASPNET_CERTIFICATE: false
      DOTNET_ADD_GLOBAL_TOOLS_TO_PATH: false
      DOTNET_MULTILEVEL_LOOKUP: 0
      DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION: true
      TERM: xterm

    steps:
    - uses: actions/checkout@v4
      
    - name: Setup .NET SDK
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: 9.0.101

    # if not using any workloads (e.g, Aspire, Wasm, Maui), remove this step
    - name: Restore workloads
      run: dotnet workload restore

    - name: Restore
      run: dotnet restore

    - name: Build
      run: dotnet build --configuration Release --no-restore

    - name: Test
      run: dotnet test

Now go ahead and commit the file to your repository at GitHub. by default, it will run every time you are creating a new pull-request or push to your main branch.

In the image below you can see the actions in the workflow defined in the YAML file above, but being executed at GitHub Actions.

Build actions for .NET project at GitHub Actions

When the build is complete, you will have the option in the Summary to see warnings and the result of each step. In this workflow file we have only defined one step named Build, hence you will only see a Build step in the overview, as shown in the image below.

Summary for finished .NET build with one Build step

That works pretty well, and it was super easy - if you ask me! 💪

Summary

In this short DevOps tutorial on how to build and test .NET projects at GitHub Actions, you learned an easy way of creating a new workflow file to speed up your development process.

I am thinking of forking Tim's project and refactoring it a bit to become a CLI tool with extra options and features for creating these build templates for .NET projects. Let me know what you think in the comments below.

Until next time, happy coding! ✌️

How To Achieve High-Performance Logging in .NET

Christian Schou Køster — Thu, 02 Jan 2025 12:26:00 +0100

Ever wondered if logging in .NET could be made more efficient? Efficient logging is crucial for modern software development. It helps monitor applications and aids in debugging and performance tuning.

In .NET, while the traditional extension methods for logging are common, there are better, more performant ways to log messages. In this short .NET post, I will show you these options and teach you how they can elevate your logging practices. 🔥

Traditional Logging

Most .NET developers are familiar with the standard approach, like the one below.

logger.LogInformation("Processing request for {Endpoint}", endpoint);

While pretty straightforward, this method can lead to performance issues due to the repeated parsing of message templates and the overhead of handling variable parameters. Modern .NET versions may even warn you about this, which is cool! ✌️

CA1848 - Use LoggerMessage delegates for improved performance

An error/warning you might encounter in your IDE (if enabled) would be this one.

CA1848: Use the LoggerMessage delegates (code analysis) - .NET

Learn about code analysis rule CA1848: Use the LoggerMessage delegates

Microsoft LearnYoussef1313

If you don't have it but would like to enable this warning, you should update your .csproj file and change the analysis level to latest-recommended. That will automatically give you this warning.


  latest-recommended

So how can we make this warning go away and improve our software? 🤓

Unlocking Performance with LoggerMessage Delegates

Wo what does that message mean? Let's break it apart a bit.

.NET offers LoggerMessage delegates to improve the performance. How? .NET is capable of pre-compiling message templates and strongly type parameters. Here’s how you can achieve just that.

Step 1 - Define a new delegate

The first thing we would have to do in our application would be to define a new delegate. In the example below I have created a new ProcessRequestLog template that I will be using whenever I log some information about processing an event in my application.

You can place it at any place in your application, but I would recommend you do it within the same project and inside a folder for all your delegates.

private static readonly Action ProcessRequestLog =
    LoggerMessage.Define(
        LogLevel.Information,
        new EventId(101, "ProcessRequest"),
        "Processing request for {Endpoint}"
    );

🧑‍💻

A delegate in .NET is essentially a type-safe function pointer. It allows you to encapsulate a method’s reference in an object, enabling the method to be passed as a parameter or assigned to a variable. In the context of LoggerMessage, delegates help pre-define logging methods to improve performance and enforce consistency.

Step 2 - Wrap it

Now that we have a new delegate in place, we should wrap it inside an extension method for our convenience. Here is the code for that:

public static void LogProcessRequest(this ILogger logger, string endpoint)
{
    ProcessRequestLog(logger, endpoint, null);
}

Step 3 - Use it

With the extension in place, we can now easily use it on the existing logger instance in our classes. Here how-to:

logger.LogProcessRequest("/api/users");

By following the above approach we can eliminate the need to parse the message template every time the log is invoked, improving performance in high-throughput applications. ⚡️

Taking It One Step Further

Beginning with .NET 6 we have the option to take advantage of source generators. What does that mean Christian and do I need it? Well if you want to make our logging even more efficient and developer-friendly then read along.

We are in such a lucky position that LoggerMessage is also an attribute 💪 In .NET we can use attributes to enable compile-time generation of our logging methods with little to minimal effort.

Here is how you can achieve just that.

Step 1 - Declare a partial method

The first thing we have to do is declare a partial method for our LogProcessRequest. The code you need:

[LoggerMessage(
    EventId = 101,
    Level = LogLevel.Information,
    Message = "Processing request for {Endpoint}"
)]
public static partial void LogProcessRequest(this ILogger logger, string endpoint);

With that in place, we can now continue in our business logic with the following as we did before:

logger.LogProcessRequest("/api/users");

Why do it this way compared to the first way I showed you? With this approach, the logging logic is generated at compile time, reducing runtime overhead and boilerplate code in your application.

Comparing The Two Approaches

Interested in a high-level comparison of the two approaches? Here is a quick comparison for you.

Approach	Benefits	Drawbacks
Traditional Logging	Simple and familiar	Performance overhead
LoggerMessage Delegates	High performance, strong typing	Requires additional boilerplate
Source-Generated Logging	Best performance, minimal code	Requires .NET 6 or later

Pro Tips for Better Logging

Here are my top three tips for improved logging in .NET applications.

Set Analysis Level - Enabling latest-recommended analyzers help identify areas for improvement directly in your IDE.
Use Event IDs - Event IDs will make it easier to filter and identify logs at runtime.
Leverage Source Generation - It’s the future of logging in .NET, reducing runtime costs - what's not to like?!

Summary

Modern .NET frameworks provide several tools for high-performance logging, from LoggerMessage delegates to source-generated logging.

By using these built-in methods, you can write cleaner, faster, and more maintainable logging code. I am sure you and your colleagues will thank you. I hope you learned something new in this short post. Until next time - Happy coding! ✌️

Resources

Code analysis in .NET

Learn about source code analysis in the .NET SDK.

Introducing C# Source Generators - .NET Blog

We’re pleased to introduce the first preview of Source Generators, a new C# compiler feature that lets C# developers inspect user code and generate new C# source files that can be added to a compilation. This is done via a new kind of component that we’re calling a Source Generator. To get started with Source […]

.NET BlogPhillip Carter

LoggerMessage Class (Microsoft.Extensions.Logging)

Creates delegates that can be later cached to log messages in a performant way.

System.Text.Json Namespace

Use JsonSerializer to Pretty-Print JSON in .NET

Christian Schou Køster — Wed, 11 Dec 2024 17:38:00 +0100

To pretty-print a JSON string in .NET and make it suitable for inclusion in an email, text page, a string, or any other thing, you can format the JSON with proper indentation and ensure it is styled as plain text for easy readability.

Code Example

Let's have a look at how we can implement this method on strings in our code.

using System;
using System.Text.Json;

class Program
{
    static void Main()
    {
        string jsonString = "{\"name\":\"Christian\",\"age\":28,\"country\":\"Denmark\"}";
        
        // Pretty-print the JSON string
        string prettyJson = PrettyPrintJson(jsonString);

        // Print the result
        Console.WriteLine(prettyJson);
    }

    static string PrettyPrintJson(string jsonString)
    {
        var jsonElement = JsonDocument.Parse(jsonString).RootElement;
        return JsonSerializer.Serialize(jsonElement, new JsonSerializerOptions { WriteIndented = true });
    }
}

What happens above? 🤔 Let me explain.

Parsing the JSON text - The JsonDocument.Parse method reads and parses the JSON string.
Serialization with Indentation - The JsonSerializer.Serialize method outputs the JSON string with indentation by setting WriteIndented to true in the options.

As An Extension Method

using System.Text.Json;

namespace ;

public static class StringExtensions
{   
    /// 
    ///     Pretty prints a JSON string.
    /// 
    /// 
    /// 
    public static string PrettyPrintJson(this string jsonString)
    {
        JsonElement jsonElement = JsonDocument.Parse(jsonString).RootElement;
        return JsonSerializer.Serialize(jsonElement, new JsonSerializerOptions { WriteIndented = true });
    }
}

With this, you can easily extend logic on your default strings to return a string in JSON format in a pretty way. 👌

I hope you solved a problem in your code with this short tutorial. If you have any questions, please let me know in the comments below. ✌️

Resources

Provides high-performance, low-allocating, and standards-compliant capabilities to process JavaScript Object Notation (JSON), which includes serializing objects to JSON text and deserializing JSON text to objects, with UTF-8 support built-in. It also provides types to read and write JSON text encoded as UTF-8, and to create an in-memory document object model (DOM) for random access of the JSON elements within a structured view of the data.

The nameof expression - evaluate the text name of a symbol - C# reference

Use nameof to Keep Code Refactoring-Safe

Christian Schou Køster — Mon, 18 Nov 2024 05:40:45 +0100

When you are writing .NET code, there is one thing I enjoy using to make my code more maintainable (and who doesn't like that?! 😅) and resilient to errors, is the use of the nameof operator.

The nameof operator returns the variable, type, or member as a string and nothing else. The genius thing here is that it has been tied strictly/directly to the code where it's being used, making our development much safer if we decide to refactor it.

What Is nameof?

According to Microsoft Learn, nameof is the following:

💡

A nameof expression produces the name of a variable, type, or member as the string constant. A nameof expression is evaluated at compile time and has no effect at run time. - Microsoft.

Why Use nameof? 🤔

So why exactly should I use the nameof operator in my code, Christian? I am glad you asked. Here are a few reasons why I think you should do it and encourage your colleagues and other engineers to do the same.

👓 Readability - You can make it super clear that the value is derived from a specific variable or method, which will make your code easier to understand and as I just mentioned, refactor/maintain.
🧑‍💻 Refactoring - We have all been there, hardcoding strings... When you rename variables your methods could potentially break because it's referencing other code across your code base. When you implement nameof, your IDE will automatically update all references when you rename stuff, making it a breeze to implement changes in your code.
⚙️ Compiling - When you are compiling your code, you will get what I call compile-time checking. Your compiler will tell you about errors if you try to compile code where you have used a non-existing member in nameof. That will be another great tool in preventing compile-time errors and catching mistakes earlier.

How To Use nameof? 🧑‍💻

To demonstrate what I just talked about, I have created a small practical example you can reference to see how easy it is to use the nameof operator in your own code.

public class MyClass
{
    public string MyProperty { get; set; }

    public void LogPropertyChange()
    {
        Console.WriteLine($"{nameof(MyProperty)} has changed.");
    }
}

What happens above? 🤓

In the code above, nameof(MyProperty) outputs "MyProperty" at runtime. If you ever should rename MyProperty, the nameof reference updates automatically, and will prevent your compiler from complaining and errors/bugs will be equal to 0. 🐛

Resources

The C# `nameof` expression produces the name of its operand. You use it whenever you need to use the name of a symbol as text

StringSyntaxAttribute Class (System.Diagnostics.CodeAnalysis)

Enhance String Semantics with the StringSyntax Attribute

Christian Schou Køster — Mon, 11 Nov 2024 05:31:00 +0100

The StringSyntax attribute was added in .NET 7, so let's just say it's a relatively new feature (at the time of writing). This new attribute allows you to specify the intended syntax or format of a string.

Having a feature like this can make our code more readable and safer. In this short .NET tip, I will show you how it works and why it is useful.

What Is StringSyntax? 🤔

The StringSyntax attribute can only be applied to string parameters, properties, or fields in .NET. We do this to indicate to other developers (and ourselves 😅) the specific format or syntax that we expect the string to be within.

Ever heard of code analyzers? Well... by adding the StringSyntax attribute we can give them a hint about the semantic meaning of a string we are expecting. This can help with easier validation and give developers a better experience due to improved IDE support. I am talking about syntax highlighting here.

Why Use StringSyntax? 💭

You probably already have a good idea of why this is a good thing to make use of 😄 but here are my top three reasons why I think you should start using it.

Better readability - By indicating that a string follows a specific syntax (e.g., Json, Regex, or Uri), you can make the intended purpose of the string clearer to anyone reading, refactoring, or consuming the code. ✅
IDE support - Visual Studio and other IDEs like Rider can use the attribute to give the developer a syntax highlighting, autocompletion, and even validation on the string. What's not to like here!? 👌
Minimize the risk of errors - By indicating a specific syntax for your string, you can avoid misinterpretation errors. Example - Imagine a method might expect a JSON-formatted string rather than plain text, and the attribute can help ensure the correct format.

How to Use StringSyntax 🧑‍💻

No .NET tip without a demonstration 🧑‍💻 Here is a quick example of how you can use StringSyntax in your code or get an idea of how it's implemented. It's luckily pretty straightforward.

using System.Diagnostics.CodeAnalysis;

public class ExampleClass
{
    public void ConfigureRegexPattern([StringSyntax(StringSyntaxAttribute.Regex)] string regexPattern)
    {
        // Code that uses regexPattern with the assumption it's a valid regular expression
    }

    public void SetJsonString([StringSyntax(StringSyntaxAttribute.Json)] string jsonString)
    {
        // Code that processes jsonString as JSON
    }
}

Available Syntax Options ✅

The StringSyntax attribute class provides several common syntax types, you can read more about those in the link below in my resources for this .NET tip.

Regex - Marks the string as a regular expression pattern.
Json - Indicates the string should follow JSON formatting.
DateTimeFormat - Indicates the string should follow DateTime formatting.
Uri - Indicates a URI format is expected.
Xml - Indicates XML format.

Use Cases ⚡️

I have tried to think about some use cases for this attribute, and here are my thoughts so far for when I would use it myself.

API Design

Helps clarify what specific string values are intended for in APIs, especially for complex formats like JSON or regular expressions.

Tooling and Analyzers

Can help static analysis tools provide warnings if the string doesn’t match the expected format.

Improved Developer Experience

Improves the development experience with IntelliSense and validation support, leading to fewer bugs and better self-documenting code.

Resources 📚

Specifies the syntax used in a string.

What is a Container? | Docker

LXC vs Docker - What To Choose?

Christian Schou Køster — Tue, 15 Oct 2024 05:54:00 +0200

Creating software in the modern world can be complex, but running it can be even more complicated as there are many requirements for supporting it. To fix that we can use containers, which have become a go-to tool for developers crafting modern software.

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.

Docker

If you are new to containers, it can be quite overwhelming... Where to start and what to use?! 🤔 We have several options available, but two of the most popular technologies are Linux Containers (LXC) and Docker Containers. Don't know the difference? Perfect! You have come to the right place 🔥

In this post, I will discuss the differences between LXC- and Docker containers. By the end of the post, you will have a much better understanding of what both technologies are capable of and know how to pick the right platform for your software project. 🧑‍💻

🐧 LXC - Linux Containers

LXC is short for Linux Containers, I will use LXC in the rest of the post when describing Linux Containers.

Linux Containers - LXC - Introduction

The umbrella project behind Incus, LXC, LXCFS, Distrobuilder and more.

Linux containers logo

What Is LXC?

LXC is an advanced virtualization technology engineers can use to create a lightweight but still efficient isolated environment with key features from the Linux kernel.

It's perfect for running more than one application in a single host system. It uses the kernel's cgroups (control groups) and namespaces features to provide lightweight, virtualized environments that share the host's kernel but can behave like independent systems. Cool right?! 🤌 So what does it look like from 20.000 thousand feet? ⬇️

LXC Environment

Common Use Cases Of LXC

LXC can be used for a lot of things, but some of the most common use cases I have seen and normally see it being used for are:

Application Isolation - You can run applications in an isolated environment to avoid conflicts.
DevOps & Testing - As a DevOps Engineer you have the option to test software in different Linux distributions or configurations without needing multiple physical or virtual machines.
Lightweight Virtualization - With LXC you can deploy multiple services on a single host while ensuring security and resource control.

LXC was originally released as an open-source project and became a part of Linux distributions like Ubuntu, Debian, and others. Canonical, the makers of Ubuntu, played a significant role in the popularization of LXC because they baked it into their releases and helped improve its usability.

✅ - When LXC May Be The Right Choice

LXC can be a great choice in several scenarios (it always comes down to your specific requirements), but I have outlined some key points below you should ask yourself when you need to choose a platform for running your application.

When Full System Containers Are Needed

LXC is focused on running a complete operating system inside a container, rather than just the application itself. This is why LXC is a great choice when you need the option to manage the entire OS and not just an app.

In many companies a lot of legacy applications make the foundation for their business and modernization is too expensive. LXC would be a great choice here as you don't have to containerize the application, but just the OS where the application is running. This way you can support legacy systems with their environment-specific services and configurations.

Resource-Constrained Environments

If you need an operating system just to run one or a few applications, but don't have the hardware for it, LXC would be a good fit. Linux Containers are more lightweight compared to a traditional virtual machine. This makes it a perfect choice when you are limited on CPU, memory, and storage.

In cases where you need to run a lot of machines on a single machine, you could achieve what is referred to as high-density hosting. Because of the lightweight architecture, you can host more containers than you would be able to with virtual machines. The most awesome part of that, which I like is that we can reduce overhead and increase efficiency on our servers.

Need for Fine-Grained Control Of Your Environment

Looking for a way to be in full control of networking, storage, resource limits, and access to the host system's hardware? This can be achieved with LXC. Here you can customize those settings at another level than you are allowed to with e.g. Docker.

A thing I think is awesome is how much performance you can achieve with LXC. Since Linux Containers share the host kernel directly (without too much abstraction 😅), it's often a preferred choice if you need a system where you have high performance with full control of the resources underneath.

When System Isolation is Important

As I mentioned earlier in my introduction to LXC, you can make use of namespaces and cgroups.

🛡️

Namespaces and cgroups gives you a perfect way of creating total isolation between your containers. This is great when you need an environment where the processes, files and networks in one system is isolated from the other containers.

A great use case would be a multi-tenant environment, where you need to ensure full/strict isolation between services.

I have used it professionally for test environments. From my DevOps days, I used LXC to create isolated environments where the engineers would be able to test their software on multiple Linux distributions without having to configure a whole new virtual machine or actual physical server every time.

Enterprise and Production Environments

If you need an environment for a stable and long-term project that potentially could run for months or maybe years, LXC would be a great fit! It would handle your production workloads without frequent changes perfectly!

One thing I think is very important to highlight is the maturity of LXC. It's a very well-tested technology and has proven to be able to run without problems in large environments. This is also one of the reasons why it would be a great choice if you are looking for a solution that would be enterprise-worthy and something you could count on.

❌ - When LXC May Not Be The Right Choice

I would not recommend using Linux Containers if you are planning to deploy a microservice platform or containerized applications. Applications like those tend to be rapidly evolving and need a lot of redeployments. In that case, you should go with Docker or Kubernetes as they would provide more tooling and be more developer-friendly.

LXC is not a tool that is easy to use compared to Docker. If you want a system where you can make quick deployments and manage with a few commands, Linux Containers are not the right choice. You need some more Linux skills and be able to understand how the OS works.

🐳 Docker

Docker is an open-source software platform that helps Software Developers, DevOps, and IT operations simplify the process of developing and managing applications. When using docker you can package an application into a container and distribute it to millions of servers.

What is Docker? Docker beginner guide - Christian Schou

Get started with Docker and learn how to create your first container running Nginx and serve your own webpage written in HTML. Docker is a very powerful tool to run applications without having to install a lot of dependencies.

Christian Schou | Tech with ChristianChristian Schou

I won't be diving that much into what Docker is in this post. You are more than welcome to read my article above or visit the official Docker website to learn more. Since you are reading this article, I am pretty sure though, that you know what Docker is. In case you don't here is a quick drawing of what the architecture would look like in a production environment.

Docker Environment

So let's skip to the part we are all here for. How can Docker improve LXC, and when is it a better choice?

How Docker Simplifies and Enhances LXC for Modern Containerization

Docker enhances LXC by simplifying container management through an easy-to-use interface, automating tasks that would require manual setup in LXC. This is a game-changer to me!

It also introduces efficient image management, utilizing a layered filesystem and providing access to prebuilt images via Docker Hub, which streamlines the sharing and updating of containers. Docker Hub is normally used for public images, but you can sign up for an account and have the option to host private images as well.

Additionally, Docker extends support to multiple platforms, including Windows and macOS, and offers built-in orchestration tools like Docker Compose and Swarm, making it easier to deploy and manage multi-container applications compared to LXC.

Key Benefits of Docker

Docker offers several key benefits that make it a popular choice for modern application development, please note the word modern! Why? 🤔 Docker ensures portability by allowing containers to run consistently across different environments.

Have you ever heard an engineer say this ⬇️

it works on my machine

One of the awesome benefits of using Docker is that we can minimize the "it works on my machine" problem - hallelujah 👏 I am so tired of that phrase... Docker's efficiency comes from its lightweight nature, which leads to faster startup times ⚡ and better resource utilization compared to traditional virtual machines 👌.

It also supports scalability, making it easy to manage and deploy multi-container applications with tools like Docker Swarm and Kubernetes.

#1 Docker Swarm Tutorial - Orchestration & Management 🐳

Learn Docker Swarm - #1 guide to master the art of container orchestration and management. Deploy, scale, monitor, and manage services with ease.

Christian Schou | Tech with ChristianChristian Schou

Additionally, Docker provides consistency across development, testing, and production environments, while its great ecosystem—including Docker Hub and integrations with CI/CD pipelines—further streamlines the development process.

Docker Hub Container Image Library | App Containerization

Welcome to the world’s largest container registry built for developers and open source contributors to find, use, and share their container images. Build, push and pull.

App Containerization

Top Use Cases for Docker

I could come up with 10+ use cases for picking Docker as a tool, but that would end up in a wall of text and no one would read that. Instead, I have picked my top four use cases of why you should use Docker.

Microservices - Docker is perfect for deploying applications built on the microservices architecture, allowing each service to be developed, scaled, and managed independently.
CI/CD Pipelines - It streamlines continuous integration and deployment by providing consistent environments for building, testing, and releasing code, reducing integration issues and speeding up deployment. ⚡
Development and Testing - Docker enables quick setup of isolated environments that will mirror your production environment, ensuring consistent application behavior across all machines and minimizing bugs during deployment. What's not to like here?! 😄
Cloud Migration - Docker simplifies the migration of applications to the cloud or the creation of hybrid environments, ensuring compatibility and reducing vendor lock-in - a thing I appreciate! Don't like your hosting provider? No problem, I will just take my images and find another home for my platform.

Where Docker May Not Ne The Right Choice

While Docker is a powerful tool for modern application development, there are some scenarios where it may not be the best tool. I have tried to boil it down to three bullet points I think are some key takeaways for you in this post, for when you should not use Docker.

Heavyweight Virtualization Needs - Avoid Docker if you need to run full operating systems with dedicated resources.
Legacy Applications - If your applications are tightly coupled with the underlying OS or require specific configurations, Docker may complicate deployment rather than simplify it. 😅
High-Performance or Real-Time Applications - For applications that require low latency or high-performance computing, the overhead introduced by Docker could hinder performance compared to bare-metal setups or traditional virtualization.

🆚 Comparing LXC and Linux

Let's take a high-level but still detailed view of LXC vs Docker. I have tried to narrow down their key features and differences in the table below. This can be a go-to place for you when you need to figure out what technology you should choose for your project.

⚡️ Feature	🐧 LXC (Linux Containers)	🐳 Docker
Abstraction Level	Low-level container management	High-level container management
Use Case	System-level virtualization; lightweight VMs	Application containerization
Image Management	Requires manual image creation and management	Uses Dockerfiles for automated builds; Docker Hub for image sharing
Networking	More manual networking setup required	Built-in networking features with easy configuration and service discovery
Portability	Limited portability; typically Linux-only	Highly portable; runs on multiple platforms (Windows, macOS, Linux)
Isolation	Strong isolation using Linux namespaces and cgroups	Uses namespaces for isolation, with added features like AppArmor and Seccomp
Performance	More efficient for system-level tasks	Optimized for application performance, with lightweight containers
Scaling	Manual scaling and orchestration	Native support for scaling with Docker Swarm and Kubernetes
Ecosystem	Less mature ecosystem, primarily command-line tools	Rich ecosystem with GUI tools, CI/CD integration, and extensive community support
Development Workflow	More complex setup for development and testing environments	Simplified workflow with Docker Compose for managing multi-container applications
Use of Filesystems	Standard filesystem usage	Uses a layered filesystem (UnionFS) for efficient storage and reuse
Container Management	Requires manual configuration and management	Simplified management using Docker commands and orchestration tools
Security Features	Basic security through Linux kernel features	Advanced security options including container isolation, network security, and image signing

📝 Summary - Choosing Between LXC and Docker

Software development is moving fast, like really fast! LXC and Docker serve different purposes and are tools we can use to help us in the crafting of software.

If you are in the market for a lightweight virtualization platform where you can run a full operating system or support your legacy applications, LXC will be your go-to.
If you are developing modern software and need CI/CD pipelines, easy spin-up of environments, etc... Docker will be the perfect choice. It has everything baked directly into it in terms of management and gives you the option to easily port your applications to other environments.

In the end, I can only say it all comes down to your specific requirements and use cases, but understanding the strengths of each technology can help you make an informed choice. I hope you learned a thing or two in this post about LXC and Docker. If you have any questions, let me know below. ✌️

How Port Mapping Works In Docker Compose

Christian Schou Køster — Wed, 09 Oct 2024 05:10:00 +0200

When working with containers, we often (in 99% of all cases) need a way to access our container software to interact with it. But running multiple of the same containers in the same environment would cause some troubles... it would not be possible.

To solve that issue, Docker has something called port mapping, and that allows us to translate one port to another when configuring our containers.

In this short post, I will tell you about how Docker Compose port mapping works, with some YAML examples and illustrations. If you are ready, then let's get to it. 😎

TL;DR 🚀

When talking Docker and ports, a port is something we use to provide an option for communicating with an endpoint to exchange data between the host and a container. In other words - ports make it possible to send and receive data/information to and from a containerized application.

In Docker Compose, the ports of a service can be defined and mapped using the ports property in with YAML with the following syntax: [host:]container[/protocol] like shown below.

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - 80:8080

...

If you wanted to, you could also manage the protocols to be either TCP or UDP, depending on your application. Here is an example of what it would look like:

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - 80:8080/tcp

...

My example above shows that TCP port 80 at the Docker Host is mapped to the TCP port 8080 of the web-app container. This means that the docker image used for the container listens to requests on port 8080, but we can send a request to port 80 and then receive the information from the container.

If you want to see how it looks with an illustration, then check my image below, where I have tried to make a drawing that shows what is going on.

Docker Port Mapping

With that in place, let's take a closer look at how we can work even more with ports.

How To Map Multiple Ports

With Docker, we can run multiple services inside one container and that makes the container expose multiple ports that we have to map.

In a Docker Compose file, we can easily map multiple ports for the service we are defining. To illustrate it with a YAML example, I have copied the example from before and modified it to map multiple ports at once.

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - 80:8080
      - 2222:22

...

In my example above the container exposes a service at port 8080 and an SSH service at port 22. Port 22 is often used for local SSH connections on the host connecting to it. To fix that I have mapped the port to 2222 at the host machine. By default all traffic is served using the TCP protocol, so no need to specify that every time.

Mapping Using Port Ranges

If you have a lot of ports, it can get messy in the compose file if you are mapping each port one by one. Instead, we can use port ranges to specify multiple host ports in one go.

🐋

When using port ranges, Docker will automatically assign the first available port you have specified in the list. When moving on, Docker will then continue assigning ports in an ascending order - meaning that the next available port will be used.

To use the port range syntax in your Docker Compose file, you can follow the following pattern.

"[host_port_start-host_port_end]container-name[/transfer protocol]"

Here is an example of how it's implemented in a compose file.

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - "8080-8085:80"

...

What happens when we ask Docker Compose to spin up this file? 🤔

Docker will now look at the service and discover our port range. The first available port in our port range is 8080, and this one will be assigned to port 80 in our container. 💪

If you need the opposite, then swap the port range to be inside the container instead of the host, as I have shown below.

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - "80:8080-8085"

...

Automatic Port Mapping 🤖

Manual specification of ports is great for production environments, where we would like everything to be configured and not left up to chance.

When developing an application we don't bother if the container is started on one port or another, we just want it to launch, test, debug, develop, etc...

If you do not specify a specific port in the compose file for your container/service, Docker will do it for you automatically. Docker will look for the first available port and assign it to your service by itself.

This is all you need to make it happen 😎

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - "8080"

...

What happens above? 🤔 When the container launches, it will listen for requests at port 8080 (in the container). Docker will now look for the first available port at the host and assign it to the container, making the mapping happen automatically. ✅

Being Very Specific In Port Mappings

So far we have been using the short-form syntax of mapping ports in our Docker Compose file. What if we would like to be very specific about the port mapping? Well, then we can use the long-form syntax.

Just like before on the service, we use the ports section, but this time we are being very explicit in our configuration. Below is a template of the syntax for achieving this.

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - target: "container-port"
        host_ip: host_ip
        published: "published-port"
        protocol: [tcp or udp]
        mode: host

...

Let's see that in action for our web-app in the compose file. The target on the container will be 8080, as that is the default port for .NET 8 containerized apps, and I love .NET 🥳

version: '3.3'

services:
  web-app:
    image: cool-project/web-app:latest
    ports:
      - target: "8080"
        host_ip: 127.0.0.1
        published: "80"
        protocol: tcp
        mode: host
      - target: "8080"
        host_ip: 127.0.0.1
        published: "443"
        protocol: tcp
        mode: host

...

So what exactly happens above? 🤔 Let me explain...

The target property is used to specify the container port or port range.
We use the host_ip to tell Docker what IP address we would like to bind on the host. (if no host_ip is specified, 0.0.0.0 will be used making it available for all Docker network interfaces)
The published property is the one we tell our host to map requests to from the client environment to the service.
As explained earlier, the protocol tells our network configuration how we would like to communicate over the network.
Docker has several drivers for the network mode. The default value, if none is specified, is bridge, but for this I have chosen host. Choosing host, allows me to remove network isolation between the container and the Docker host.

You can read more about the network configuration at the link below.

Networking overview

Learn how networking works from the container’s point of view

Docker Documentation

Summary

In this post you learned about Docker port mapping. You saw examples explaining how to map host ports to container ports to enable communication between the host and containerized applications. It covers key topics like basic port mapping, mapping multiple ports, and using port ranges to simplify configurations. Additionally, we also had a look at automatic port mapping and the more detailed long-form syntax for precise control over port mapping.

You should now have a clearer understanding of Docker port mapping and be able to apply this knowledge to solve your container networking issues. If you got any questions, please let me know in the comments below. Until next time - Happy Dockerizing! 🐳

URL-Safe Base64 Encoding With .NET 9

Christian Schou Køster — Wed, 09 Oct 2024 04:12:00 +0200

In .NET 9 we will get a new Base64Url Type. It will make it possible for developers to do URL-safe Base64 encoding on the fly.

Coming from earlier version of .NET you might think, why? We already have the Convert.ToBase64String() method? That's correct, but that method can produce strings which contains characters such as: /, +,or =. These characters are not safe for use in URL's without encoding them first, because they are used for special operations.

To fix that, the .NET team now introduces a new Base64Url.EncodeToString() method. 👌

What Is Base64 And Why? 🤔

💡

Base64 is an encoding scheme that translates arbitrary bytes into text composed of a specific set of 64 characters. It's a common approach for transferring data and has long been supported via a variety of methods.

How To Use It 🧑‍💻

Here us a practical example of how to implement and use the Base64URL helper in .NET 9.

byte[] stringToEncode = Encoding.UTF8.GetBytes("Tech with Christian");

var unsafeEncoding = Convert.ToBase64String(stringToEncode);
var safeEncoding = Base64Url.EncodeToString(stringToEncode);

Console.WriteLine($"Unsafe encoding: {unsafeEncoding}");
Console.WriteLine($"Safe encoding: {safeEncoding}");

// Unsafe encoding: VGVjaCB3aXRoIENocmlzdGlhbg==
// Safe encoding: VGVjaCB3aXRoIENocmlzdGlhbg

That's how easy it is to use the new Base64Url class with the EncodeToString method. Just remember it's only available beginning from .NET 9.

Resources 📚

Base64Url Class (System.Buffers.Text)

Converts between binary data and URL-safe ASCII encoded text that’s represented in Base64Url characters.

What’s new in .NET libraries for .NET 9

Learn about the new .NET libraries features introduced in .NET 9.

Member access and null-conditional operators and expressions: - C# reference

A Docker Clean Up Cheat Sheet

Christian Schou Køster — Mon, 07 Oct 2024 05:37:00 +0200

Are you looking for an easy way to clean up your Docker environment? I recently came across several threads on another website where users were asking how to clean up their Docker servers.

This included everything from images and volumes to containers with volumes, or even the entire environment. It's fairly easy, but since it's not something we do every day, most people would need to look it up each time.

Below is a quick command to help you clean up different components. Just copy the command and run it on your system. Bon appétit! 🤌

Linux 🐧

The commands you will find below is for Linux only. If you are looking for Windows commands (PowerShell) please go here. Windows Commands.

Delete All Containers Including Their Volume 🚧

To delete all containers and their volumes on your system, you can use the below command.

docker rm -vf $(docker ps -aq)

Delete All Images 📦

To delete all images on your system, you can use the command below.

docker rmi -f $(docker images -aq)

Delete Containers In Exited State 🏚️

docker rm $(docker ps -a -f status=exited -q)

Delete Containers In Created State 🏠

docker rm $(docker ps -a -f status=created -q)

Delete Everything ☠️

🤓

If you are looking for a way to prune your whole system, you can use the command below. Please be aware that it will remove EVERYTHING NOT IN USE! It's a great way to free up diskspace if you are running low.

docker system prune -a --volumes

Running it will result in the following output in your terminal.

WARNING! This will remove:
    - all stopped containers
    - all networks not used by at least one container
    - all volumes not used by at least one container
    - all images without at least one container associated to them
    - all build cache

Windows (PowerShell) 🪟

PowerShell treats $() as a subexpression operator, just like in the shell, but it needs to be used differently in some cases. Due to that, we can try using ForEach-Object for more robustness when running the command.

Delete All Containers Including Their Volume 🚧

To delete all containers and their volumes on your system, you can use the below PowerShell command.

docker ps -aq | ForEach-Object { docker rm -vf $_ }

Delete All Images 📦

To delete all images on your system, you can use the PowerShell command below.

docker images -aq | ForEach-Object { docker rmi -f $_ }

Delete Containers In Exited State 🏚️

Looking for a way to delete all the containers in an exited state? Remember to manually remove the volumes after, if any is attached.

docker ps -a -f status=exited -q | ForEach-Object { docker rm $_ }

Delete Containers In Created State 🏠

Looking for a way to delete all the containers in an created state? Remember to manually remove the volumes after, if any is attached.

docker ps -a -f status=created -q | ForEach-Object { docker rm $_ }

Delete Everything ☠️

This command is the same across Windows and Linux. It will give you the same warning as it does on Linux.

docker system prune -a --volumes

WARNING! This will remove:
    - all stopped containers
    - all networks not used by at least one container
    - all volumes not used by at least one container
    - all images without at least one container associated to them
    - all build cache

Summary

I hope you got your problem solved and learned something at the same time.

Resources 📚

Below are links for reference to the locations with documentation I have used to create this Docker clean up tutorial.

docker system prune

″”

Docker Documentation

Replace IF-Statements With Null Conditional Operators

Christian Schou Køster — Sun, 29 Sep 2024 09:41:00 +0200

Ever heard about the null conditional operator? It is also referenced by instructors, software engineers and programmers in general as:

Null propagation operator.
Safe navigation operator.

It was a feature we first saw in C# 6.0 and I personally use it a lot! ✌️ It will allow you to make your code much more clean and concise, when you are working with data that might be null.

How Does It Work? 🤔

The null conditional operators is also known as a ?. in C# (question mark with a. dot). This notation is used to access a member or invoke a method that you know might return null when invoked. If the invoked object is null, it will return null instead of throwing a new exception, genius right?! 🔥

How To Do It? 💡

Let's get to the fun part and see how we can replace an IF-statement with this null conditional operator, in practice.

👎

The long way with an IF-statement.

if (invoice != null && invoice.Payment != null)
{
    invoice.Payment.AddFee(10);
}

👍

Using null conditional operator instead.

invoice?.Payment?.AddFee(10);

See the difference? 😅

Why Should I Do It? 🤓

I know a lot of programmers would think, yeah but I know my IF-statements and they work, why should I make the switch? Here are three reasons:

Cleaner Code - You will reduce the need for if-statements, making your code shorter and easier to read. 🫶
Prevents Errors - You will avoid the NullReferenceException by safely handling null objects. What's not to like? ✌️
Consistent Null Checks - Standardizes null handling, improving code reliability and maintainability. Other engineers will love you! ❤️

Resources 🔗

C# operators that you use to access type members or null-conditionally access type members. These operators include the dot operator - `.`, indexers - `[`, `]`, `^` and `..`, and invocation - `(`, `)`.

Microsoft Learnpkulikov

Do You Know About The File Access Modifier In C#?

Christian Schou Køster — Wed, 18 Sep 2024 06:17:00 +0200

In C# 11, a new access modifier called file was introduced. It restricts the accessibility of types and members to the containing file, offering a lightweight alternative to internal or private. 🤘

This is especially useful for helper classes or methods you want to limit to a single file, ensuring cleaner code organization and better encapsulation. 🔥

A Quick Demonstration 🧑‍💻

Below is a simple example on how to use the file access modifier in C#.

file class HelperClass
{
    public static string GetMessage()
    {
        return "This is a file-scoped class.";
    }
}

public class MyClass
{
    public string DisplayMessage()
    {
        return HelperClass.GetMessage();
    }
}

What is going on above? Let me explain 😄

The HelperClass is restricted to the file MyHelper.cs because of the file access modifier. It can only be used within this file, ensuring it’s not accessible anywhere else in the project.

This keeps HelperClass isolated, allowing you to organize utility or helper functionality without exposing it to other parts of your application. Awesome right?! 👌

Still Not Getting It? 😅

I totally understand! Let me try with another example. Imagine you have two files with helper classes that could potentially conflict if they were accessible across the entire project.

Without `file` Modifier

Image you got a file named Utilities1.cs.

internal class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine($"Utilities1 Log: {message}");
    }
}

public class MyClass1
{
    public void DoWork()
    {
        Logger.Log("Doing work in MyClass1.");
    }
}

And another named Utilities2.cs.

internal class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine($"Utilities2 Log: {message}");
    }
}

public class MyClass2
{
    public void DoWork()
    {
        Logger.Log("Doing work in MyClass2.");
    }
}

What could possible end up bad here? Well... both Logger classes are internal. If someone from another file in the same project tries to use Logger, there will be confusion or conflicts since both files have a Logger class. You might even accidentally reference the wrong one. 😬

So how can we solve that?

With `file` Modifier

Let's update our Utilities to use the file access modifier instead of internal.

First file named Utilities1.cs goes here.

file class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine($"Utilities1 Log: {message}");
    }
}

public class MyClass1
{
    public void DoWork()
    {
        Logger.Log("Doing work in MyClass1.");
    }
}

And the second one named Utilities2.cs is here.

file class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine($"Utilities2 Log: {message}");
    }
}

public class MyClass2
{
    public void DoWork()
    {
        Logger.Log("Doing work in MyClass2.");
    }
}

Why This Is a Good Idea? 🤨

No Naming Conflicts! Each file has its own Logger class, but they can't conflict because their scope is limited to the file. Both Logger classes can coexist even though they have the same name, and neither will accidentally be accessed from other files.
Cleaner Encapsulation. You ensure that Logger in Utilities1.cs and Utilities2.cs only impacts the respective file. If you don't need the Logger class outside these files, file helps prevent accidental exposure of them.

This approach helps with modularity, avoids naming clashes, and keeps the scope of helper classes or utility methods limited to where they're needed.

An Analogy To Understand It

Imagine you're working on two different school projects at the same time, and each project has its own helper friend named "Alex." But the problem is, if both projects are in the same room, you might get confused about which "Alex" to ask for help!

Now, the file access modifier is like keeping each "Alex" in their own room (one for each project). So, when you're working on Project 1, you only see and talk to Alex from Project 1, and when you’re working on Project 2, you only see Alex from Project 2.

This way, there’s no confusion or mix-up, and you can work on both projects without accidentally calling the wrong "Alex". Genius right? 🙌

Resources

You can read more about the file keyword from the official Microsoft documentation below.

file keyword - C# reference

file modifier: Declare types whose scope is the file in which it’s declared

StringBuilder Class (System.Text)

Why You Shouldn't Concatenate Strings Using "+" In Loops

Christian Schou Køster — Mon, 22 Jul 2024 07:47:00 +0200

In this .NET tip I will show you why strings should not be concatenated using a + in your loops.

I often see beginners use that operator, because it's easy and that is what they learned during the YouTube videos.. However it's not efficient and leads to bad performance. 😥

Why? 🤷‍♂️

Strings are immutable, which means that once a string object is created, it cannot be modified. When you concatenate strings using the + operator in your loops, you actually creates a new string object at each iteration.

The old/previous objects are discarded of course, but it can lead to performance issues, turning your app into a snail 🐌. It can especially be a problem in large applications where you need to handle a lot of data.

The Right Way ✅

It's not rocket science and you will gain in performance 🚀 Ever heard about the StringBuilder? The StringBuilder is designed for building strings (hence it's name 😄) in loops. It will allow you to append a strings, without having to create a new object for each iteration!

❌

Don't do this

string names = string.Empty;

foreach (var name in arrayOfNames)
{
    names += name;
}

✅

Do this

var sb = new StringBuilder();

foreach(var name in arrayOfNames)
{
    sb.Append(name);
}

var names = builder.ToString();

Conclusion

By using the string builder we can deal with large datasets for strings in .NET without having to sacrifice performance. It's great in conditions where you have an unknown number of strings that needs concatenation.

It will drastically reduce the memory allocations and help you improve the performance of the code in your methods.

Resources

Represents a mutable string of characters. This class cannot be inherited.