Nick Verhoeven

My Zero Waste Grocery Habits

2026-03-14T20:10:45Z

Zero waste is an ambitious term. While it is possible to reach the goal of zero package waste for some products, reducing the amount of packaging that enters my home is the best alternative for some products. Unfortunately, I often contribute to the amount of waste for many products.
Below is a list of the things I buy to reduce or eliminate waste.

Tea

More than ten years ago, I started thinking about reducing packaging in my daily life. One of the first products I tried this with was tea, it felt so easy. I’ve always preferred loose leaf tea, it tastes so much better. In real tea-producing countries, people probably laugh at our tea bags because they see them as the waste left from broken or lower-quality leaves, so maybe tea bags are also a way of zero waste ;-).

I buy my tea at Simon Lévelt. You can bring your own tea tins to fill, and they even give a small discount of ten cents. It’s nice to see companies encouraging us to reduce waste.

For me, this became a simple routine: bring the tin, refill it, and enjoy tea without extra packaging. It feels so normal now that I can’t imagine it anymore buying it in plastic, to fill a tin at home, and then throwing the plastic away.

Deposit jars

A couple of years ago, Wisselwaar was introduced. It's perhaps the easiest way if you want to pursue a zero waste lifestyle. It's available in several product groups, such as nuts, dried fruit, cookies, coffee and tea, pasta, rice, legumes and grains. The selection within each group is limited, usually to a few items. However, the assortment grows slightly each year, which is nice. Because of this, you don’t always find exactly what you need, and some products can be expensive, so I only buy them occasionally or for special occasions.

Self‑serve refill wall

How I do my shopping at the refill wall is something I often get questions about at the checkout. At Ekoplaza, it’s really no different than weighing vegetables, only here you weigh products like nuts, grains, or dried fruit.

I always bring my own jars and a reusable bag. I use the bag to weigh the products, then transfer everything neatly into the jars for storage at home.

Cleaning and toothpaste

Another category where I try to reduce packaging is cleaning products. Over time I switched to a few alternatives that use much less plastic than the typical bottles from the supermarket.

For laundry I use for many years soap nuts and sometimes wash strips. Soap nuts are a natural product which is great. Both still have packaging but far less than the large plastic bottles of liquid detergent.

The product for bathroom cleaning I use from Yokuu. They use bacteria-based cleaning and come as powder refills that you mix with water in a reusable spray bottle. The bottle itself is quite nice to use. It builds pressure, so it keeps spraying while pumping, which works better than many ordinary spray bottles.

Most of these alternatives are comparable in price, sometimes even cheaper. Soap nuts in particular last a long time. One downside is that the brands available at the Ekoplaza change from time to time. Products compete for shelf space, so every few years a refill system disappears and another brand replaces it, which sometimes means buying a new reusable bottle.

For toothpaste I use toothpaste tablets. At the moment I use them from Smyle. They are easy to use and reduce plastic tubes, although the price depends on the brand. I also noticed that the packaging slowly became larger over time. It started as a small paper bag, then a cardboard box around it, and now a bigger box to stand out on the shelf.

Previously Ekoplaza also sold tablets from Denttabs, which had more tablets for the same price and less marketing packaging. I really miss them in the store, although the taste was a bit less. I’m not sure what I’ll do in the future. Ordering them online would mean a much larger shipping package and more waste, buying Smyle means accepting the growing box and higher price, or maybe deciding it’s not worth it and going back to toothpaste tubes.

Cotton bags

For many people, it's probably already common practice to take reusable cotton bags when buying fruits and vegetables. It's super easy because they don't take up much space.

Final Thoughts

Some habits have been easy to adopt. For example, I really like using refillable tea tins and bringing my own jars to the deposit system. However, I hope the variety of products in the deposit system grows faster in the future, making it easier to achieve zero waste.

The reality is that not all products have a permanent place on the store shelves. Some products compete heavily for shelf space, and brands may increase packaging to stand out, which can make zero-waste shopping more expensive. Other products may disappear entirely, making zero-waste shopping inconsistent. It’s a long road, but small choices can still make a difference.

I hope this post gives you ideas for your own shopping habits. If you have any tips or experiences to share, I'd love to hear them in the comments!

Extending the ASP.NET Identity user

2026-03-17T21:46:21Z

In the last few weeks, I wrote two blog posts: Using ASP.NET Identity and Using External Login in ASP.NET Identity. How I Added It to My MiniBlog Project" and "Part 2: Using External Login in ASP.NET Identity: How to Extend It with an External Login Provider." In this blog, I will explain how I extended the Identity user with custom fields to store additional profile information.

I extended the user with a display name so that I could show who commented on a post.

Create a class that inherits from IdentityUser

By default, IdentityDbContext works with the IdentityUser class to define the user table. To add custom properties, create your own class that inherits from IdentityUser. You can also add additional indexes if needed, for example:

[Index(nameof(DisplayName), IsUnique = true)]
public class ApplicationUser : IdentityUser
{
    [MaxLength(64)]
    public required string DisplayName { get; set; }
}

Update your DbContext

Update your DbContext. You need to configure it to use your custom user class for the Identity user table instead of the default one. For example, you can do this like this:

public class MiniBlogDbContext : IdentityDbContext<ApplicationUser> // specify your created user class here
{
    // your own internal DbSet(s)

    public MiniBlogDbContext(DbContextOptions<MiniBlogDbContext> options)
        : base(options)
    {
    }
}

Replace IdentityUser with your custom class everywhere

Begin by updating Program.cs or Startup.cs where you register Identity. Replace IdentityUser with you custom user class.

// Replace the IdentityUser for you custom user class
builder.Services.AddIdentity<ApplicationUser, IdentityRole>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddRoles<IdentityRole>() // Only needed when you use roles in your application
    .AddEntityFrameworkStores<DbContext>()
    .AddDefaultTokenProviders();

The less fun part of it is that you also need to update all the scaffolded views that use IdentityUser and replace them with your custom user class. You also need to replace IdentityUser with your custom user class in any controller or other classes that use it. For example, in the login.cshtml.cs:

public LoginModel(SignInManager<ApplicationUser> signInManager, ILogger<LoginModel> logger)
{
    _signInManager = signInManager;
    _logger = logger;
}

Don’t Forget to Update the Database

After adding your custom user class and updating the DbContext, don’t forget to update your database schema.

dotnet ef migrations add AddCustomUserFields
dotnet ef database update

Wrapping Up

This was the final part of my series on adding ASP.NET Identity to my MiniBlog project. If something isn’t working as expected, I recommend starting from the beginning with Part 1: Using ASP.NET Identity to ensure everything is set up correctly.

Thanks for following along, I hope this series helped you integrate Identity into your own project.

Using External Login in ASP.NET Identity

2026-03-14T20:14:41Z

Last week, I wrote this blog Using ASP.NET Identity: How I added it into my MiniBlog project. In this blog, I will explain how I added the external logins for Google and GitHub.

For my blog I chose Google and GitHub because they let me create a polished, branded login experience, even as a private individual. Unlike some other providers (like Microsoft) that require you to be a registered company for verification.

Create an OAuth app/client at the external login provider

As mentioned above, I used Google and GitHub. You created an OAuth app/client at the following URLs:

Both pages will guide you through the necessary steps.
For Google and also some other providers that I didn't implement, you need a privacy and terms of use page.

Adding the NuGet packages

For Google and GitHub you need to install these packages below.

If you're using a different provider, there's probably an official Microsoft package for it. Search for Microsoft.AspNetCore.Authentication.*. If not, the AspNet.Security.OAuth.Providers project on GitHub will most likely have one.

Configure the external providers

The only thing left to do is to add your provider to your Program.cs or Startup.cs and implement it with the ClientId and ClientSecrets of your created OAuth app/client.

if (configuration["Authentication:GitHub:ClientId"] != null && configuration["Authentication:GitHub:ClientSecret"] != null)
{
    builder.Services.AddAuthentication().AddGitHub(githubOptions =>
    {
        githubOptions.ClientId = configuration["Authentication:GitHub:ClientId"]!;
        githubOptions.ClientSecret = configuration["Authentication:GitHub:ClientSecret"]!;
        githubOptions.Scope.Add("user:email");
    });
}

if (configuration["Authentication:Google:ClientId"] != null && configuration["Authentication:Google:ClientSecret"] != null)
{
    builder.Services.AddAuthentication().AddGoogle(googleOptions =>
    {
        googleOptions.ClientId = configuration["Authentication:Google:ClientId"]!;
        googleOptions.ClientSecret = configuration["Authentication:Google:ClientSecret"]!;
    });
}

If you notice that not everything is working you might want to check out the first part: Using ASP.NET Identity

What’s Next

This was the second part of adding ASP.NET Identity to support external logins to my MiniBlog project. In the final part of the series, I’ll show you how to extend the Identity user with custom fields, like a display name, so you can store and use additional profile information.

Using ASP.NET Identity

2026-03-17T21:46:55Z

When I started customizing my MiniBlog, I wanted a more robust comment section than one that relied on JavaScript to prevent bots from adding comments. Email confirmation was an option, but I chose to require a login. While it gives me more control, unfortunately it also acts as a barrier for users trying to create an account. That's why I also wanted to support also external logins so that users wouldn’t have to create yet another account.

Fortunately, there is ASP.NET Identity. I integrated it into my MiniBlog using scaffolding as a starting point. Identity provides a solid foundation for handling authentication, with built-in support for local and external logins, two-factor authentication (2FA), and more. Here are the steps I took:

Adding the NuGet packages

I'm using Entity Framework, so I'm also using the Microsoft.AspNetCore.Identity.EntityFrameworkCore package. You can use ASP.NET Identity. If you're not using EF, then you don't need the package. However, you will need to add your implementations of some Identity interfaces, such as IUserStore and IRoleStore, among others.

Create or Update DbContext

Create or Update your DbContext to use the IdentityDbContext instead of the DbContext.

public class MiniBlogDbContext : IdentityDbContext
{
    // your own internal DbSet(s)

    public MiniBlogDbContext(DbContextOptions<MiniBlogDbContext> options)
        : base(options)
    {
    }
}

Update Program/Startup.cs

Registrate DbContext
I use the lightest basic Azure SQL Database available. I know that it can experience transient (temporary) connectivity issues. The EnableRetryOnFailure makes it reliable in case that happens. You probably only want to use it with a cloud-based database in cases like this.
```
builder.Services.AddbContextFactory<DbContext>(options =>
    options.UseSqlServer(configuration.GetConnectionString("MyConnectionString"), providerOptions => providerOptions.EnableRetryOnFailure()));
```

builder.Services.AddIdentity<IdentityUser, IdentityRole>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddRoles<IdentityRole>() // Only needed when you use roles in your application
    .AddEntityFrameworkStores<DbContext>()
    .AddDefaultTokenProviders();

Configure cookies. You can skip this step if you prefer, as I use the default values.

builder.Services.ConfigureApplicationCookie(options =>
{
    options.Cookie.HttpOnly = true; // This ensures the authentication cookie cannot be accessed via JavaScript (for security against XSS attacks)
    options.ExpireTimeSpan = TimeSpan.FromDays(14);

    options.LoginPath = "/Identity/Account/Login";     //set the login path.  
    options.AccessDeniedPath = "/Identity/Account/AccessDenied";
    options.SlidingExpiration = true;
});

Scaffold items

Use Add > New Scaffolded Item... to override the default ASP.NET Identity views. Even if you don’t plan to use all the features, it’s a good idea to scaffold all the available Identity pages. That way, you maintain full control over the UI and behavior. For any Identity pages you don't need, you can modify the logic to return a 404 Not Found response, effectively disabling those routes.

When you use Manage\EnableAuthenticator.cshtml, be sure to add the two extra JavaScript files necessary for displaying a QR code. When you open the view, you'll see a link to the documentation.

Add a implementation of EmailSender

Of course, a login isn't complete without a email confirmation and the ability to reset your password. When you open the Register.cshtml.cs or the ForgetPassword.cshtml.cs, you will notice that they use an IEmailSender. You only need to add an implementation. I used Microsoft's documentation for this: https://learn.microsoft.com/en-us/aspnet/core/security/authentication/accconfirm. It's a simple interface with only one SendEmailAsync method, so creating your own implementation with your preferred email service should be easy.
As the Microsoft documentation describes, after adding an EmailSender you should update RegisterConfirmation.cshtml.cs. Make sure to set the DisplayConfirmAccountLink to false, or even remove the code block and the EmailConfirmationUrl property entirely.

// Once you add a real email sender, you should remove this code that lets you confirm the account
DisplayConfirmAccountLink = false;
if (DisplayConfirmAccountLink)

I case of OutputCache

I ran into issues with the OutputCache and BasePolicy settings that I had configured. Some Identity pages were cached. This could result in a 400 Bad Request error when submitting a form for to log in, register or reset a password. This occurred because the AntiForgeryToken in the cached result was rejected. Adding a filter condition using the With method to exclude the Identity path resolves this issue. For example:

builder.Services.AddOutputCache(options =>
{
    options.AddBasePolicy(policyBuilder =>
    {
        policyBuilder.Expire(TimeSpan.FromSeconds(3600));

        // Disable caching for Identity paths
        policyBuilder.With(context =>
            !context.HttpContext.Request.Path.StartsWithSegments("/Identity", StringComparison.OrdinalIgnoreCase)
        );
    });

    options.MaximumBodySize = 262_144;
});

What’s Next

This was my first part of adding ASP.NET Identity to my MiniBlog project. In the next two blog posts, I’ll take things further:

Using Fluent Assertions or Shouldly

2025-02-10T18:23:16Z

After the news spread that Fluent Assertions had changed their licence in version 8, a lot of things were unclear. Now, a few weeks later, they have clarified things a bit and have also done a quick release of version 8.0.1 to address a concern that a lot of developers had and was causing a lot of frustration.

Fluent Assertions version 8 is still free for non-commercial use. version 7 is unchanged and still free for commercial use under the Apache licence.

The licence change was frustrating because it was just a version update. If you updated all your packages, you could suddenly use the framework without a licence. After all, who expects a licence change when upgrading a free package. An extra licence check warning when using version 8.0.1 resolve this concern a bit.

If this solves all problems and makes the community happy again, only the future will tell. Here are my thoughts on it.

Should you upgrade to 8?

For my blog, which I do in my spare time, it is not commercial, so I could still use Fluent Assertions 8 for free. I prefer to work with frameworks that I use or can use professionally. A licence that costs $130 per year per developer is too expensive in my opinion. It's the best assertion framework for .NET, just not worth the price.

Update 10 February 2025: Small businesses can now purchase a yearly licence for $50 per developer. This is only for companies with less than $1 million in revenue and a maximum of three developers. I'm unsure if this is an improvement for small businesses. If your team or revenue grows, you must update your licence.

I haven't missed any features in version 7. If you use Fluent Assertions commercially, I would recommend staying on version 7 as long as possible. If a newer version has a feature that you really miss then you could decide if its worth its price.

Lock your NuGet version

Something everybody espacially the first week advised. Lock your NuGet version so that you don't accidental upgrade without a valid license. Also on the Update tab in the NuGet Package Manager it helps so that it doesn't show the unwanted Fluent Assertions update anymore.

The only thing you need to do is to edit you .csproj and add [] around the version. In that case you only allow that specific version.

<PackageReference Include="FluentAssertions" Version="[7.1.0]" />

When you have a older .NET project with still a package.config you can edit it in

<package id="FluentAssertions" version="7.1.0" allowedVersions="[7.1.0]" />

This Microsoft page you gives you all the details and options for how to lock down a version or a range of versions.

Shouldly as alternative

Shouldly is an alternative with many similarities to Fluent Assertions. So should you use it? It depends on how many tests you have and which features of Fluent Assertions you use.

The basics are almost the same, for example on a property level a ShouldBe() instead of a Should().Be(), and all the variants like BeNull, BeGreaterThan, BeLessThan etc.

When testing an exception is thrown its a bit different, but Shouldly is still more then capable of doing this. The biggest difference, and whether Shouldly is the best solution for you, is how Should().BeEquivalentTo() works.

Exception assertion

Testing whether an exception is thrown in Shouldly is done with a Should.Throw<ExceptionType>(function), it returns the exception which you can then use to check if the message has the expected value. For example

// Act
var act = async () => await GetTarget().DoSomething(something);

// Assert Fluent Assertions
await act.Should().ThrowExactlyAsync<ArgumentException>().WithMessage($"Doing something: {something} is not supported");

// Assert Shouldly
var exception = await Should.ThrowAsync<NotSupportedException>(act);
exception.Message.ShouldBe($"Doing something: {something} is not supported");

It has a small advantage if you don't like the async lambda functions, or prefer to combine the call and throw assertion. This can be done like this:

// Act & Assert Shouldly
var exception = await Should.ThrowAsync<NotSupportedException>(GetTarget().DoSomething(something));
exception.Message.ShouldBe($"Doing something: {something} is not supported");

BeEquivalentTo

Finally, the real difference in BeEquivalentTo. Shouldly is stricter and also lacks an EquivalencyAssertionOptions, at some point this are features that are really useful. For some of the examples I've made I used the User class and the Service below:

public interface IUserService
{
    void CreateUser(int code, string firstName, string lastName);
    User GetUser(int code);
}

public class User
{
    public required Guid Id { get; set; }
    public required int Code { get; set; }
    public required string FirstName { get; set; }
    public required string LastName { get; set; }
    public required bool DbContraintField { get; set; }
    public required DateTime CreatedDate { get; set; }
}

For the example above, I might want to do the following, which aren't possible with Shouldly:

Excluding properties. The Id is a Guid. When my UserService creates a user with an Id using Guid.NewGuid(), I just want to ignore it. In Fluent Assertions I used to do it like this:
```
result.Should().BeEquivalentTo(expected, options => options.Excluding(u => u.Id));
```
DateTime tolerance. When my UserService creates a user with a CreatedDate with a DateTime.Now() then I can predict the value, just not to the millisecond. In Fluent Assertions it is also not the easiest part, but there I did check it like:
```
result.Should().BeEquivalentTo(expected, options => options.Using<DateTime>(ctx => ctx.Subject.Should().BeCloseTo(ctx.Expectation, TimeSpan.FromSeconds(1))).WhenTypeIs<DateTime>());
```

Stricter. If I am doing an integration test and my UserService creates the record in the database. I may only want to check the Code, FirstName and LastName. Excluding the fields is one option, sometimes I just want to assert against a anonymous object and only compare the properties that are in the expected object. In Fluent Assertions, I could do this like:
```
result.Should().BeEquivalentTo(new { Code = code, FirstName = firstName, LastName = lastName });
```
Without strict ordering. I don't have an example for this with the User class. If I have async calls that add items to a collection, I don't know the order in which I get the collection. In Fluent Assertions I could do check it like:
```
createdUser.Should().BeEquivalentTo(expected, options => options.WithoutStrictOrdering());
```

Create a Extension method for Shouldly

If you use BeEquivalentTo in many places like the above, then it is probably best to stick with version 7 of Fluent Assertions. Shouldly is aware of the situation due to the licence changes of Fluent Assertions, and is considering adding some missing features. It may be easier to make the move to Shouldly in the future.

Another option is to create your own extension methods to fill the gap for the features you are missing. I've created mine to help me with the 2 things I miss the most.

Excluding properties, like:

result.ShouldBeEquivalentTo(expected, options => options.Exclude(u => u.Id));

DateTime tolerance, i now can do like:

result.ShouldBeEquivalentTo(expected, options => options.UsingDateTimeTolerance(TimeSpan.FromSeconds(1)));

In the future I may extend and improve it, if so I will update the code below.

[ShouldlyMethods]
public static class ShouldlyExtensions
{
    public static void ShouldBeEquivalentTo<T>(this T? actual, T? expected, Action<EquivalencyOptions<T>> options) where T : class
    {
        if (typeof(IEnumerable).IsAssignableFrom(typeof(T)) && typeof(T) != typeof(string))
        {
            throw new InvalidOperationException("This overload is not intended for collection types.");
        }

        var equivalencyOptions = ValidateAndSetupOptions(actual, expected, options);

        CompareObjects(actual, expected, equivalencyOptions, new HashSet<(object, object)>());
    }

    public static void ShouldBeEquivalentTo<T>(this IEnumerable<T?> actual, IEnumerable<T?> expected, Action<EquivalencyOptions<T>> options)
    {
        var equivalencyOptions = ValidateAndSetupOptions(actual, expected, options);
        var actualList = actual.ToList();
        var expectedList = expected.ToList();

        actualList.Count.ShouldBe(expectedList.Count, "Collection counts do not match.");

        for (int i = 0; i < actualList.Count; i++)
        {
            CompareObjects(actualList[i], expectedList[i], equivalencyOptions, new HashSet<(object, object)>());
        }
    }

    private static EquivalencyOptions<T> ValidateAndSetupOptions<T>(object? actual, object? expected, Action<EquivalencyOptions<T>> options)
    {
        if (actual == null && expected != null || actual != null && expected == null)
        {
            throw new ShouldAssertException(@$"Comparing object equivalence:
actual: {actual?.GetType().ToString() ?? "null"}
expected: {expected?.GetType().ToString() ?? "null"}");
        }

        var equivalencyOptions = new EquivalencyOptions<T>();
        options(equivalencyOptions);

        return equivalencyOptions;
    }

    private static void CompareObjects<T>(object? actual, object? expected, EquivalencyOptions<T> options, HashSet<(object, object)> visitedObjects, string parentPath = "")
    {
        if (actual == null && expected == null)
        {
            return;
        }

        if (actual == null || expected == null)
        {
            throw new ShouldAssertException(@$"Comparing object equivalence, at path '{parentPath}':
actual: {actual?.GetType().ToString() ?? "null"}
expected: {expected?.GetType().ToString() ?? "null"}");
        };

        if (visitedObjects.Contains((actual, expected)))
        {
            return;
        }
        visitedObjects.Add((actual, expected));

        var properties = actual.GetType().GetProperties();

        foreach (var property in properties)
        {
            var propertyPath = string.IsNullOrEmpty(parentPath) ? property.Name : $"{parentPath}.{property.Name}";

            if (options.ExcludedProperties.Contains(propertyPath) || property.GetIndexParameters().Length > 0)
            {
                continue;
            }

            ComparePropertyValues(property.GetValue(actual), property.GetValue(expected), property, options, visitedObjects, propertyPath);
        }
    }

    private static void ComparePropertyValues<T>(object? actualValue, object? expectedValue, System.Reflection.PropertyInfo property, EquivalencyOptions<T> options, HashSet<(object, object)> visitedObjects, string propertyPath)
    {
        var hasNull = actualValue == null || expectedValue == null;
        if (!hasNull && property.PropertyType == typeof(DateTime) && options.DateTimeTolerance.HasValue)
        {
            ((DateTime)actualValue!).ShouldBe((DateTime)expectedValue!, options.DateTimeTolerance.Value, $"Property {propertyPath} does not match.");
        }
        else if (!hasNull && property.PropertyType == typeof(DateTimeOffset) && options.DateTimeTolerance.HasValue)
        {
            ((DateTimeOffset)actualValue!).ShouldBe((DateTimeOffset)expectedValue!, options.DateTimeTolerance.Value, $"Property {propertyPath} does not match.");
        }
        else if (!hasNull && IsCollectionType(property.PropertyType))
        {
            CompareCollections(actualValue!, expectedValue!, options, visitedObjects, propertyPath);
        }
        else if (!hasNull && IsComplexType(actualValue!))
        {
            CompareObjects(actualValue, expectedValue, options, visitedObjects, propertyPath);
        }
        else
        {
            actualValue.ShouldBe(expectedValue, $"Property {propertyPath} does not match.");
        }
    }

    private static void CompareCollections<T>(object actual, object expected, EquivalencyOptions<T> options, HashSet<(object, object)> visitedObjects, string parentPath = "")
    {
        var actualList = ((IEnumerable<object>)actual).ToList();
        var expectedList = ((IEnumerable<object>)expected).ToList();

        actualList.Count.ShouldBe(expectedList.Count, "Collection counts do not match.");

        for (int i = 0; i < actualList.Count; i++)
        {
            CompareObjects(actualList[i], expectedList[i], options, visitedObjects, parentPath);
        }
    }

    private static bool IsCollectionType(Type type)
    {
        return typeof(IEnumerable).IsAssignableFrom(type) && type != typeof(string);
    }

    private static bool IsComplexType(object obj)
    {
        var type = obj.GetType();
        return !type.IsPrimitive
            && !type.IsEnum
            && type != typeof(string)
            && type != typeof(decimal)
            && type != typeof(DateTime)
            && type != typeof(DateTimeOffset);
    }
}

public class EquivalencyOptions<T>
{
    public HashSet<string> ExcludedProperties { get; } = new HashSet<string>();
    public TimeSpan? DateTimeTolerance { get; private set; }

    public EquivalencyOptions<T> Exclude(Expression<Func<T, object>> propertyExpression)
    {
        ArgumentNullException.ThrowIfNull(propertyExpression);

        ExcludedProperties.Add(GetPropertyPath(propertyExpression));
        return this;
    }

    public EquivalencyOptions<T> UsingDateTimeTolerance(TimeSpan tolerance)
    {
        DateTimeTolerance = tolerance;
        return this;
    }

    private string GetPropertyPath(Expression expression)
    {
        var propertyNames = new List<string>();
        ExtractPropertyPath(expression, propertyNames);
        propertyNames.Reverse();
        return string.Join(".", propertyNames);
    }

    private void ExtractPropertyPath(Expression expression, List<string> propertyNames)
    {
        switch (expression)
        {
            case MemberExpression memberExpression:
                propertyNames.Add(memberExpression.Member.Name);
                ExtractPropertyPath(memberExpression.Expression!, propertyNames);
                break;
            case MethodCallExpression methodCallExpression:
                foreach (var argument in methodCallExpression.Arguments.Reverse())
                {
                    ExtractPropertyPath(argument, propertyNames);
                }
                break;
            case UnaryExpression unaryExpression:
                ExtractPropertyPath(unaryExpression.Operand, propertyNames);
                break;
            case LambdaExpression lambdaExpression:
                ExtractPropertyPath(lambdaExpression.Body, propertyNames);
                break;
            case ParameterExpression:
                break;
            default:
                throw new ArgumentException("Invalid property expression");
        }
    }
}

Hosting a container with HTTPS

2026-03-14T20:15:03Z

Running a .NET web app locally inside a container using Docker is super easy. Visual Studio does almost everything for you. It is not much more than right-clicking on your project and under Add selecting Docker Support. You get a Dockerfile that is ready to run. By default a self-signed certificate is added to use HTTPS in Docker locally, the only thing you need to do is accept the self-signed certificate.

Deploying to Azure is also easy, you can manage the certificates in your Web App and even use a free certificate. The only catch is that Azure handles the HTTPS, but your container doesn't have the certificate, it's handled by a proxy. Azure calls the container from the proxy using HTTP.

The only issue you may encounter is that your container doesn't know that the request was made over HTTPS. You may notice this if you use, as in my case, a:

Request.Scheme
services.AddHsts (for the strict-transport-security header)
An AddProgressiveWebApp nuget such as WebEssentials.AspNetCore.PWA
External OAuth login provider

All of these won't start or start using HTTP, which we don't want.

The solution for this is super simple. Add the following to your Program.cs or Startup.cs

app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedProto
});

It will pass the value of the original request scheme, HTTP or HTTPS, to your app inside the container.

When I updated my web app to use Sidecar support, I found that it wasn't enough. For this reason, I now use:

app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedHost
});

app.Use(async (context, next) =>
{
    if (context.Request.Headers.TryGetValue("X-Forwarded-Proto", out var proto) &&
        proto.ToString().Equals("https", StringComparison.OrdinalIgnoreCase))
    {
        context.Request.Scheme = "https";
    }

    await next();
});

Upgrade to .NET 9

2026-03-14T20:15:15Z

Just a few days ago .NET 9 was released. I was actually doubted to deploy my blog later and use .NET 9 directly. This time I took the safe way and did it in 2 steps.
I wanted to upgrade even though it is a standard term support instead of a long term support. Mainly because I try to stay on the latest version.

.NET 9 isn't a release with the biggest new features. There are some like System.Text.Json that got some extra features, not that important for my blog project. Also Entity Framework has some nice features, but even more performance improvements. That is actually the biggest difference in .NET 9 at some point they really made a big performance improvement which is nice.

Oat milk

2026-03-14T20:15:25Z

Make your own oat milk

My personal favourite plant-based milk is oat milk. It has a nice creamy texture and a mild, slightly sweet flavour. Oats are also an environmentally friendly crop. It doesn't need much water and can be grown in many places, even locally and in the relatively colder Netherlands.

For years I took the easy way out and just bought oat milk in the shop. A few years ago that all prices went up by 10% or more, even for oat milk. Which was a bit odd because almost 90% of it is water. At the same time, it became impossible to buy organic oat milk with added calcium after the European Court of Justice ruled that lithothamnium couldn't be used as an additive to enrich it with calcium.

So finally I decided to make my own oat milk instead of buying non-organic oat milk or organic oat milk without calcium. It also saves a lot of waste, no more empty drinks cartons.

Ingredients

1 litre of cold water
120 grams of oats
4 grams lithothamnium
1 teaspoon of oil

If you don't want to add extra calcium, you can leave out the lithothamnium. You can also leave out the oil if you prefer, but this will make the milk less creamy. The oil I use is Omage 3-6-9 Oil from EkoPlaza, which is a blend of beetroot oil, sunflower oil, linseed oil, evening primrose oil and tocopherol. You can use a different oil, but it is best to use an oil with a neutral taste.

Steps

Prepare a bowl with a cloth for straining the oat milk. I use 2 cheesecloth cloths and moisten them beforehand so that they filter better.
Put the oats and water in the blender. Often, especially in the summer when it is hot, I add a few ice cubes. I use a kitchen scale to check that I have added 1 litre.
Blend the ingredients for 30/35 seconds on the highest setting of your blender. A high powered blender is recommended, I use a Vitamix A3500. If you think your blender is not powerful enough, you can increase the blend time. In that case you may also want to add extra ice cubes to keep the oat milk cold, as it will turn to oat porridge or it gets slimy as it heats up.
Pour the oat milk into the bowl with the cloths
Gently squeeze the oat milk through the cloth. If you squeeze too hard you will find that it get messy and you will get a less smooth result. Start by squeezing gently with a few fingers, like a stress ball, so that you don't put too much pressure on the cloth. When almost all the moisture is out, you can squeeze a little harder.
Repeat for the second cloth, this is always quick and easy because 99% of the milk has been filtered through the first cloth.

If you want oat milk with as few ingredients as possible, you are done.

Extra steps

If, like me, you want your oat milk a little creamier and with added calcium, there are a few extra steps.

Quickly rinse the blender with water
Pour the oat milk back into the blender
Add 4 grams of lithothamnium.
Add 1 teaspoon of oil
Blend again on medium speed for +/- 5 to 10 seconds. I usually use speed 6 or 6+ (my blender goes up to 10).

You can now pour your oat milk into a bottle and enjoy your fresh glass of oat milk. I drink 1 glass a day, you can leave it in the fridge for a day or 4.

Waste?

What do you do with the filter pulp? Throwing it away would be a real waste. You can use it in different products. I almost always use it in my bread, instead of 500 grams of flour I use 450 + the pulp. It also affects the amount of water needed for the bread, I use between 15 and 20% less water, depending on the type of flour. You can also use it for all kinds of other baking recipes like cookies or pancakes.

What does my blog run on?

2026-03-14T20:15:41Z

The basis

As a starting point for my blog I used Mads Kristensen MiniBlog. It is a nice little C# .NET blog project with all the important things in it. At the moment I'm using it, .NET 8 has already been released the first thing I did was upgrade it, which was quite easy. I also configured it to run in a container, which is helpful when developing with Visual Studio on Windows and debugging and testing with Docker Desktop on Linux.

Things I've removed

The Azure.ImageOptimizer package. I've replaced it with a logic that, when saving a blog, checks the images used in the HTML and makes sure there is an optimised image for it. I'll do a blog about this in the future, I just have some ideas on the roadmap to improve it a bit more.
The WilderMinds.MetaWeblog and therefore the MetaWeblogService. It is my personal blog and I plan only to maintain it only from the site itself. To keep it smaller and simpler I've removed the MetaWeblog API implementation.

Styling

Default SCSS was already used for styling, I've updated the stylesheets to my personal taste. By default it also includes the LigerShark.WebOptimizer and LigerShark.WebOptimizer.Sass libraries for bundling and minifying CSS and JavaScript. The Sass library adds a SCSS to the CSS compiler, making using SCSS just as easy as using CSS.

Scripts

By default it doesn't use any JavaScript frameworks such as Angular, React, Vue and even old school JQuery. This saves a tiny bit of time loading and parsing a large javascript library before rendering the page. When I've added the AspNetCore.Identity for the logins I've got on these default views also JQuery, in the near future I'll fix it so that JQuery isn't needed anymore. There are a few custom JavaScripts in the project, they are only a few kb's big. There are also a few specific libraries are used:

TinyMCE, the WYSIWYG that is used to write the blogs. By default it was using an older version 4.8, I've updated it to a more recent version 7.4. I also customised the add image button. It now has a popup where I can upload, browse and select images.
PrismJS, when you notice a block of source code in a blog, PrismJS highlights the syntax. It's a standard TinyMCE plugin, it was also using an older version 1.15, I've updated it to version 1.29. Also added SQL and PowerShell to the options that can be selected from within TinyMCE.
Cropper, when you create a login you can add a profile picture. Cropper is used to edit your profile picture. Creating an account wasn't possible in the default version. Maintaining a profile picture wasn't possible either, gravatar.com was used instead. I chose to require a login because it is an easier way to block bot comments, and limit the amount of emails to verify the user/comment. I could still use gravatar.com, but using Cropper was more fun for me.

Libraries

A lot of standard .NET libraries of course, its so boring to mention those. A few of the libraries I added extra are:

Html Agility Pack, I use it when saving a blog to update the img tags in the HTML. For example, TinyMCE applied a width and height attribute after scaling the image, then the page wasn't resposive anymore. Now it changes it to a max-width and max-height and applies a CSS class that is used to override the float behavioir with a media query. It also updateds the url to fetch an optimised image for the correct dimensions.
Microsoft.EntityFrameworkCore, not really special and worth mentioning. By default the MiniBlog uses just XML on the disk. I decided to use a database and used EF as the ORM. Its not really my preferred ORM, I like SQL and like having more control over the queries. For a small blog EF generates queries that are more then fine, also nice to keep my knowledge of EF a bit up to date.
PhotoSauce.MagicScaler is used to generate the optimised images. Because my project runs on Linux, I'm using prereleased versions for the supported file types. I like this library because of the performance and the memory consumption. I don't mind the risk of using a prerelease version, I haven't encountered any problems, if I do I will figure it out or work around it.
ZiggyCreatures.FusionCache after seeing the video on the .NET YouTube channel this year I was sold. Things like the protection for cache stampede, fail-safe and more control over timeout makes it a better choich then using standard MemoryCache. It even has a lot of extra nice features that I dont' use.

What is it hosting on?

Its running in Azure and using these services, I use a lowest possible specs to save the costs:

Azure Web App for Containers in a Linux Basic B1 App Service plan.
Azure SQL Database its a single database on the Basic tier
Azure Blob Storage in LRS on the Hot Access tier
Grafana Cloud to monitor for errors and see if the performance isn't that terrible while using the lowest possible specs.