DEV Community: G.L Solaria

.NET Aspire and WSL Docker

G.L Solaria — Sat, 15 Nov 2025 04:26:10 +0000

So you have probably heard how great .NET Aspire is. If you aren't convinced, take the time to watch this video .NET Aspire Tutorial For Beginners.

Currently, the only supported way to use Aspire on Windows requires either Podman or Docker Desktop to be installed. If, for whatever reason, you can't use either of these 2 options, there is another way to connect .NET Aspire directly to Docker running on WSL. But be warned - setting up this option isn't simple, isn't supported, and has some limitations. If you need something that is simple and supported, use Podman or Docker Desktop.

The solution I have posted below is not ideal and I am keen to hear from anyone who has managed to find a better solution. Creating a docker.cmd file with wsl.exe docker %* no longer works on the latest version of Aspire. Creating a wrapper application that correctly handles the complex argument escaping required to work with Aspire will probably end up blocked by Smart App Control unless you sign the application. So please post a comment if you have found a better solution that doesn't use Docker Desktop or Podman.

Install WSL

If you are not familiar with Windows Subsystem for Linux (WSL) then you have a steep learning curve and this approach may not be right for you. If you want to go ahead any way you can start to learn by going here.

To install WSL, open a powershell command prompt as Administrator and type:

wsl --install -d Ubuntu-24.04

Follow the instructions to create a WSL user/password and reboot Windows.

Install Visual Studio Code

Next install VS Code.

Install Docker in WSL

Start a WSL Session from VS Code

Start VS Code and select Open a Remote Window in the bottom left of the window.

Then select Connect to WSL.

Install Docker on WSL

From a terminal in VS Code connected to WSL, install Docker on your instance of Ubuntu by following these instructions.

Allow Docker Commands to Run as Non-Root User

To be able to run docker commands on WSL without needing to run with sudo you will need to follow these instructions.

Install the Container Tools Microsoft Extension in VS Code

From the Extensions tab in VS Code connected to WSL, search for Container Tools and verify you have the found official Microsoft extension then install it.

Verify the Installation of Docker on WSL

Click on the container icon in VS Code connected to WSL and confirm the Container Tools extension can connect to the Docker daemon. If it is connected you should see No items found in the Images and Containers panel.

From a terminal in VS Code connected to WSL, run:

docker run hello-world

You should now see something like this:

Modify Docker Configuration to Listen on TCP

In a terminal opened in VS Code connected to WSL, run:

sudo nano /etc/docker/daemon.json

Enter the following text and save:

{
  "hosts": [
    "unix:///var/run/docker.sock",
    "tcp://0.0.0.0:2375"
  ]
}

Next override the Docker daemon startup to use this new daemon.json configuration file by:

sudo mkdir -p /etc/systemd/system/docker.service.d
sudo nano /etc/systemd/system/docker.service.d/override.conf

Enter the following text and save:

[Service]
ExecStart=
ExecStart=/usr/bin/dockerd

Reload and restart Docker:

sudo systemctl daemon-reload
sudo systemctl restart docker

Next allow the port through the Ubuntu firewall:

sudo iptables -I INPUT -p tcp --dport 2375 -j ACCEPT

Finally note down the IP address of the WSL Ubuntu instance:

ip addr show eth0

Add DOCKER_HOST Windows Environment Variable

We need to create an environment variable that will be used on the Windows side to communicate with Docker running in WSL.

To do this create a new user environment variable in Windows called DOCKER_HOST and set it to tcp://wslip:2375 where wslip is the IP address you noted down from the WSL command ip addr show eth0.

Download Docker CLI for Windows

Next we need the docker.exe that will run on Windows. The official builds of just the CLI are here. Download the latest and extract the zip file to some location.

Add the path to docker.exe to your Windows PATH environment variable.

Finally, verify you can now run docker commands that connect to your WSL docker engine by opening a powershell prompt and running:

docker image ls

You should see the hello-world image in the output.

Limitations

You should now be able to run your .NET Aspire App Host project that manages containers but there are limitations.

You will need to keep your VS Code window to WSL open while you want to run your Aspire application. This is because Windows will automatically shut WSL down after a period of inactivity.

Also Windows may decide to change the IP address of your WSL instance. If it does, you will need to edit the DOCKER_HOST environment variable and restart your IDE. If this bothers you, you could look in to setting up a static IP address for WSL but this is also not straight forward.

Conclusion

I warned you it wasn't simple! If you know of a better way that does not involve installing another Windows application like Podman or Docker Desktop, then please leave a comment.

Assessing Security Risks of Open Source Repos

G.L Solaria — Mon, 16 Jun 2025 03:20:11 +0000

So you want to use software from a GitHub or GitLab repository. But how can you assess the security risks associated with the repo?

Thankfully there is a utility from OpenSSF called scorecard you can use to help you understand the risks involved with using the software from a public repo.

OpenSSF

The Open Source Security Foundation is part of the Linux Foundation and was formed in 2020 to help improve the security of open source software. The premier members of the foundation include Google, GitHub, Microsoft, Apple, and Intel.

Scorecard viewer

So how can you get a quick overview of the security risks associated with using a GitHub or GitLab repo? Well the repo may already have been indexed by OpenSSF. Simply replace the placeholders in the following URL:

https://scorecard.dev/viewer/?uri=<github_or_gitlab>.com/<user_name_or_org>/<repository_name>

For example, to view a report on the scorecard repo go to https://scorecard.dev/viewer/?uri=github.com/ossf/scorecard and you will see something like this:

Scorecard command line utility

If the GitHub repo isn't already indexed by OpenSSF, you will need to generate a GitHub personal access token to run the utility from the command line. This is because GitHub imposes API rate limits on unauthenticated requests. Instructions on how to set up the token are documented here.

You can install the utility standalone but the easiest way to run it is via a docker container:

docker run -e GITHUB_AUTH_TOKEN=<your_access_token> gcr.io/openssf/scorecard:stable  --repo=<url_of_repo_to_audit>

This will output an ASCII table that looks something like:

Probing for security vulnerabilities

You can also use the command line utility to get more detailed information on the security vulnerabilities.

docker run -e GITHUB_AUTH_TOKEN=<your_access_token> gcr.io/openssf/scorecard:stable  --repo=<url_of_repo_to_audit> --probes=hasOSVVulnerabilities --format=probe

This will output a JSON file with the known security vulnerabilities.

More details

Read the docs for more details on how to use this utility, use it in your CI/CD pipeline, or make use of it as a repo maintainer.

Decompiling and Debugging with Ghidra

G.L Solaria — Sat, 01 Feb 2025 03:55:28 +0000

Ghidra is an open source tool developed by the U.S. National Security Agency (NSA) for reverse engineering binaries when you don't have access to the source code. It can be used to assist in capture the flag cyber security challenges. Among its many features is that it can convert binaries into C code. Ghidra can run headless or through a Java GUI. This post will focus on using the GUI to decompile and debug a C program given just the binary.

Installation

This installation guide assumes you are installing to a Debian based Linux distribution.

Install JDK

Ghidra requires the Java Development Kit (currently uses JDK 21) to run. Eclipse Termurin is a free, open-source JDK provided by the Eclipse Adoptium project. It is a build of OpenJDK that is widely used as an alternative to Oracle JDK. Depending on the Linux distribution, you may be able to install the JDK using the following command:

$ sudo apt install temurin-21-jdk

If your distribution doesn't distribute a Temurin JDK, then you can download the version for your hardware architecture from Adoptium. Follow the installation instructions for archives.

Install GBD

Run the following command to install GDB (the GNU debugger) if you want to be able to use Ghidra's debugging features:

$ sudo apt install gdb

You will need gdb compiled with Python version of at least 3.7. Verify the version of Python supported by GDB by running the following:

$ gdb
(gdb) python import sys
(gdb) python print(sys.version)
(gdb) quit

Make sure the version is 3.7 or higher.

Install psutil and protobuf Python Modules

To use the GDB debugger in Ghidra, you need the psutil and protobuf Python modules to be installed:

$ sudo apt install python3-psutil python3-protobuf

Install Ghidra

Download the appropriate zip file from the GitHub repo. Unzip it to a directory then find the "ghidraRun" script and run it.

Create a Sample C Program

You can skip this step if you already have a binary you want to decompile but when learning I think it is best to start with something where you already know the code being decompiled. This code comes from the leetcode solution for the simple two sum problem. Create a main.c file:

#include <stdlib.h>
#include <stdio.h>

int* twoSum(int* nums, int numsSize, int target, int* returnSize) 
{
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[j] == target - nums[i]) {
                int* result = malloc(sizeof(int) * 2);
                result[0] = i;
                result[1] = j;
                *returnSize = 2;
                return result;
            }
        }
    }

    *returnSize = 0;
    return malloc(sizeof(int) * 0);
}

int main() {
    int nums[5] = { 7, 3, 5, 10, 22 };
    int returnSize = 0;

    int* twoSumResult = twoSum(nums, sizeof(nums) / sizeof(nums[0]), 32, &returnSize);

    if (returnSize > 0){
        for (int i = 0; i < returnSize; ++i){
            printf("twoSumResult[%d]: %d\n", i, twoSumResult[i]);
        }
        free(twoSumResult);
    }
    else{
        printf("No result\n");
    }
}

Compile an executable by running:

$ gcc -o main main.c

Note you may have to install the gcc compiler if you haven't already done so.

Creating a Project in Ghidra

Go to "File" then "New Project" and select "Non-shared Project".
Select the directory and give the project a name (in our case TwoSum).
Drag and drop the main executable from a file explorer window to the newly created project pane.
A pop-up should appear. Have a look around at the options and languages then click "OK" and then "OK" again when the next popup appears.

Browsing the Code

Select "main" in the Active Project pane and drag it to the dragon button (i.e. Code browser) in the Tool Chest set of buttons.
Click "Yes" on the analyze popup then click "Analyze" on the next popup keeping all options set to the defaults.

Finding the TwoSum Function

Select "Search" then "Program Text" from the menu.
Select the "All Fields" button then click "Search All".
A popup should appear. Select "twoSum" and the listing window should auto navigate to the disassembly listing.
Next select "Window" then "Decompiler" from the menu. A pane should appear with the decompiled code.

You can see that the decompiled code differs from the original code we wrote. This is because Ghidra reverse engineers C code from the compiler generated instructions in the binary file.

Debugging the Code

Close the Code Browser window and return to the Ghidra project window.
Select "main" and drag it to the button with a bug on it (the debugger tool).
Click "Yes" to analyze then click "Analyze".
From the "Debugger" menu item click "Configure and Launch main using...".
Then select "gdb" then click "Launch" on the popup keeping the defaults selected.
The launch of GDB should be successful and you should see a message in the GDB pane:

Connected to Ghidra 11.2.1 at 127.0.0.1:36921

Next click on "Window" then "Decompile: main" from the menu. You should see a pane that now shows the decompiled main code.

Setting a Breakpoint

In the decompiled code pane, right click on the line you want to break at and select "Toggle Breakpoint".
Leave the defaults as selected (specifically ensure "SW_EXECUTE" is selected) and click "OK".
Click on the the green arrow button on the main debugger window to start debugging.
You should see the debugger stop at the breakpoint.
You can then step using the arrow buttons on the debugger menu:

Note you can see the values of various variables as you step by hovering over them.

Conclusion

This was a brief introduction to installing and using Ghidra. It has many more features to explore so take your time. Or you could join a capture the flag challenge and see how you go using it on unfamiliar code. There are also lots of YouTube videos showing how it can be used in capture the flag challenges too.

C# devs need to know about sharplab.io

G.L Solaria — Tue, 15 Oct 2024 05:34:14 +0000

It is not just practice that will help you master C#. Using tools to look under the hood will accelerate your understanding of various language features and helps you write better, more efficient code. Sharplab.io is one such tool that will help you to quickly learn and understand certain C# language features. You can use this tool to show you "lowered" C# code.

What is Lowering?

Lowering is where the compiler converts high-level language features into simpler, low-level features. Lowering has the added benefit for compiler writers in that they can implement new language features without needing to change the underlying CIL or Common Intermediate Language (It is the CIL that is executed by the CLR or Common Language Runtime).

String Concatenation Operator

Let's look at a simple example of the use of += on a string to start with.

Below is an image from the sharplab.io site. In the left pane is the code I wrote and the right pane shows the lowered code. As you can see, the += operator is lowered to use string.Concat.

Below is the same code but lowered in release mode. Notice how the compiler has eliminated use of the text variable.

List versus Span Iteration

Let's now look at a more complex example using List and Span.

Below is some code using a List. Notice how the foreach is converted to a while loop using an Enumerator.

Below is similar code using Span. Which do you think will perform faster?

Understanding Records

As an exercise for you, use the site to look at the lowered code for records. Copy the following into the left pane on sharplab.io.

var rec1 = new RecordClass(21, "hello");

// Lowered to use the compiler generated Deconstruct method.
var (num, str) = rec1;  

// Lowered to use the compiler generated Clone method.
var rec2 = rec1 with { Num = 42 }; 

public record RecordClass (int Num, string Str);

When you do you will see all the automatically generated properties and methods you get for free when using records:

It makes the record class immutable by providing read-only/init properties.
It generates Equals() and the equals/not equals operators.
It generates a ToString() implementation.
It generates a GetHashCode() method so you can use the record in hashing data structures like Dictionary.
It generates a Descontruct() method used when deconstructing the record.
It generates a Clone() method which is used in this case when using the with keyword.

More Exercises For You to Try

So keep exploring using this tool and see what you can learn. See how the using statement is lowered. Try some LINQ using the query syntax. Try a switch statement switching on strings. If you are feeling brave, try async methods. You can even start exploring the CIL generated to get a sense of the performance of different implementations.

How to setup a free, self-hosted AI model for use with VS Code

G.L Solaria — Tue, 04 Jun 2024 07:34:31 +0000

You have probably heard about GitHub Co-pilot. It's an AI assistant that helps you code. There are a few AI coding assistants out there but most cost money to access from an IDE. But did you know you can run self-hosted AI models for free on your own hardware? All you need is a machine with a supported GPU.

Before we begin

We are going to use an ollama docker image to host AI models that have been pre-trained for assisting with coding tasks. We are going to use the VS Code extension Continue to integrate with VS Code. If you are running VS Code on the same machine as you are hosting ollama, you could try CodeGPT but I could not get it to work when ollama is self-hosted on a machine remote to where I was running VS Code (well not without modifying the extension files). There are currently open issues on GitHub with CodeGPT which may have fixed the problem now.

System requirements

This guide assumes you have a supported NVIDIA GPU and have installed Ubuntu 22.04 on the machine that will host the ollama docker image. AMD is now supported with ollama but this guide does not cover this type of setup.

Installing the NVIDIA CUDA drivers

The NVIDIA CUDA drivers need to be installed so we can get the best response times when chatting with the AI models. On the machine you want to host the AI models...



sudo apt install nvidia-cuda-toolkit

Now check the status of the CUDA drivers by running ...



nvidia-smi

You should see something like this ...

Next run a check to ensure the CUDA drivers are available to for use ...



nvcc --version

You should see something like this ...

Install Docker and enable Docker images to access the GPU

Follow the instructions to install Docker on Ubuntu.

Now we install and configure the NVIDIA Container Toolkit by following these instructions.

Next we double check that any docker images can access the NVIDI GPU...



docker run --runtime=nvidia --gpus all --rm nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

Note you should select the NVIDIA Docker image that matches your CUDA driver version. Look in the unsupported list if your driver version is older.

Run the ollama Docker image

Now we are ready to start hosting some AI models.

First, download and run the ollama Docker image...



docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Next check ollama is running by...



curl http://localhost:11434

You should see the output "Ollama is running".

We can now download and run any model easily by running ...



docker exec -it ollama ollama run deepseek-coder:6.7b

This version of deepseek-coder is a 6.7 billon parameter model. The model will be automatically downloaded the first time it is used then it will be run. After it has finished downloading you should end up with a chat prompt when you run this command.

While it responds to a prompt, use a command like btop to check if the GPU is being used successfully. Also note if you do not have enough VRAM for the size model you are using, you may find using the model actually ends up using CPU and swap.

Picking a pre-trained coding model

You may have to have a play around with this one. The best model will vary but you can check out the Hugging Face Big Code Models leaderboard for some guidance. You will also need to be careful to pick a model that will be responsive using your GPU and that will depend greatly on the specs of your GPU.

Setting up VS Code

On the machine you want to run VS Code on, check you can see the ollama API address (note x.x.x.x is the IP address of your machine that is hosting the Docker image)...



curl http://x.x.x.x:11434

You should get the output "Ollama is running".

Next Download and install VS Code on your developer machine.

Now we need the Continue VS Code extension.

Make sure you only install the official Continue extension.

Click cancel if it asks you to sign in to GitHub.

Now configure Continue by opening the command palette (you can select "View" from the menu then "Command Palette" if you don't know the keyboard shortcut). Type "Continue: Open config.json"

Open the config file and modify it to be like what I have entered below:

Note again that x.x.x.x is the IP of your machine hosting the ollama docker container.

Save the file and click on the Continue icon in the left side-bar and you should be ready to go. Note you can toggle tab code completion off/on by clicking on the continue text in the lower right status bar. Also note that if the model is too slow, you might want to try a smaller model like "deepseek-coder:latest". Refer to the Continue VS Code page for details on how to use the extension.

C# Async/Await Mistakes: Resuming in the Wrong Context

G.L Solaria — Mon, 06 Nov 2023 03:48:06 +0000

Using async/await in C# is generally straight forward but when you start to use it in more advanced ways, you need to understand a bit more about what is happening to make sure you are not making mistakes.

Let's look at one common mistake: resuming in the wrong context.

The code below implements a class that uses HTTP Client to load some JSON. The LoadToDosAsync method however has a potential problem. Can you spot it?

public static class Getter
{
  private static HttpClient _Client = new()
  {
    BaseAddress = 
      new Uri("https://jsonplaceholder.typicode.com/"),
  };

  public static async Task LoadToDosAsync()
  {
      using var response = await _Client.GetAsync("todos/1");

      response.EnsureSuccessStatusCode();

      var json = await response.Content.ReadAsStringAsync();

      // This is a CPU intensive operation...
      LoadData(json);
  }
}

When LoadToDosAsync is called, the calling thread returns when it hits the first await. A thread from the threadpool will then be selected by the threadpool scheduler and this thread will perform the work to call out over the network to get the data.

If LoadToDosAsync is called from a main UI thread and when GetAsync returns, execution will resume on the main UI thread until it reaches the next await.

If LoadToDosAsync is called from the main of a console application and when GetAsync returns, execution will resume in the context of the threadpool scheduler. The threadpool scheduler will then select a thread from the threadpool that will execute until it hits the next await.

A similar process is then repeated when awaiting ReadAsStringAsync.

So LoadData ends up being executed in the same context as LoadToDosAsync started executing before the first await. The context will be the main UI thread if LoadToDosAsync is called from the main UI thread. The context will be the threadpool scheduler if called from the main of a console application.

What's the potential problem here? The problem shows up when LoadToDosAsync is called from a main UI thread. Execution resumes on the main UI thread when ReadAsStringAsync returns hence LoadData will execute on the main UI thread. LoadData is a CPU intensive call that will block the main UI thread until it completes. This means the UI will freeze until LoadData completes. So the UI will be unresponsive while LoadData is executing.

To fix this problem, you can use ConfigureAwait(false) to indicate that execution can resume in the threadpool scheduler context. The threadpool scheduler will then select a thread from the threadpool to continue execution of LoadData instead of executing it in the main UI thread.

public static class Getter
{
    private static HttpClient _Client = new()
    {
        BaseAddress = 
            new Uri("https://jsonplaceholder.typicode.com/"),
    };

    public static async Task GetToDosAsync()
    {
        using var response = await _Client
          .GetAsync("todos/1")
          .ConfigureAwait(false);

        response.EnsureSuccessStatusCode();

        var json = await response.Content
          .ReadAsStringAsync()
          .ConfigureAwait(false);

        // This is a CPU intensive operation...
        LoadData(json);
    }
}

Using ConfigureAwait(false) is especially important when writing general-purpose libraries. You should get in the habit of using it almost everywhere unless you know you want to resume in the caller's context.

It must be noted that if the calling context is the threadpool scheduler, you may or may not resume on the same calling thread. Take the example of a console application below...

while (true)
{
    int callingThread = Environment.CurrentManagedThreadId;
    await Task.Delay(TimeSpan.FromSeconds(1));
    int resumingThread = Environment.CurrentManagedThreadId;

    Console.WriteLine(
      $"Calling {callingThread}, Resumed {resumingThread}.");
}

Run this console application and you will see that sometimes execution resumes on the calling thread but sometimes it does not.

Calling 1, Resumed 5.
Calling 5, Resumed 5.
Calling 5, Resumed 5.
Calling 5, Resumed 7.
Calling 7, Resumed 7.

It should be noted that the above is a simple explanation of when is going on. To read a technically correct explanation of the behaviour of ConfigureAwait(false) refer to Stephen Toub's article on the subject.

A word of warning when writing C# benchmarks

G.L Solaria — Wed, 21 Sep 2022 21:57:39 +0000

I wrote a post on the free, open source tool BenchmarkDotNet but I wanted to mention a common pitfall that you might fall in to if you are not careful.

The warning is simple: when writing benchmarks, always use the results of your calculations.

Consider these benchmarks ...

[Benchmark(Baseline = true)]
public void Sqrt1()
{
    for (var ii = 0; ii < N; ++ii)
        Math.Sqrt(ii);
}

[Benchmark]
public double Sqrt2()
{
    double result = 0;
    for (var ii = 0; ii < N; ++ii)
        result = Math.Sqrt(ii);
    return result;
}

If we look at the results of the above benchmarks ...

Method	N	Mean	Error	StdDev	Ratio	RatioSD	Rank
Sqrt1	1000000	291.8 us	5.79 us	6.66 us	1.00	0.00	1
Sqrt2	1000000	4,006.9 us	55.00 us	51.45 us	13.64	0.29	2

How can Sqrt2 be almost 14 times slower than Sqrt1? The answer lies with the JIT compiler ...

SharpLab is another great tool that will show you what the JIT compiler will do initially. In the case of Sqrt1, it will compile out dead code because the result of the square root isn't used so it doesn't need to run the instructions to perform the square root.

So be careful with how you write your benchmarks otherwise you may not be measuring what you think you are measuring!

You need to know about BenchmarkDotNet

G.L Solaria — Tue, 20 Sep 2022 10:10:05 +0000

BenchmarkDotNet is one of those free, open source tools that all .NET developers need to know how to use. This tool is useful if you want to:

compare the performance of multiple ways of doing the same thing,
decide which 3rd party library provides the fastest and most memory efficient implementation,
compare the performance of code running on different versions of the .NET platform,
monitor changes to your code base for changes that degrade performance.

What is a benchmark?

A benchmark is a program that measures the performance characteristics of some code (or hardware though this is not the focus of this article). Benchmarking is often used to compare the performance of different implementations but can also be used to show that you have achieved some performance goal (e.g. processing 1,000,000 operations per second).

Why use BenchmarkDotNet?

Don't use DateTime.Now

Hopefully you know not to use DateTime.Now for measuring the execution time of code. It isn't good for measuring sub-millisecond execution time and it can sometimes be affected by time synchronisation activities.

The pitfalls of using Stopwatch

You have probably used Stopwatch to measure execution times. However, taking a one shot value of one implementation and comparing it to another one shot value is unreliable. You will probably observe that if you do 5 runs of the same code, you will get 5 different results that vary wildly. So how can you compare multiple implementations that do the same thing? Using only the arithmetic mean might not be meaningful if there are outliers.

The JIT compiler can cause problems

Have you considered that the JIT compiler can dynamically re-compile code over time? It can do this to optimise hot paths of execution. The JIT compiler can also vary its optimisations based on the code it executed before the code you want to benchmark. How can you ensure the JIT compiler has done its optimisations and ensure isolation of the benchmarked code?

The overhead of running the benchmark can also cause problems

If you do realise that you need to do many iterations and perform some sort of statistical analysis, have you discounted the overhead in executing the benchmark? How many iterations do you need to do to get a stable result?

Enter BenchmarkDotNet

BenchmarkDotNet is a project supported by the .NET Foundation. It is used by many .NET projects (including those run by Microsoft) to analyse the performance of various libraries and detect regressions in performance as modifications are made.

It takes care of handling common pitfalls for you. It will:

run your code multiple times and automatically detect when the results have stabilised,
take into consideration the overhead used to run the benchmark and ensure the overhead does not interfere with the results,
calculate all the statistics for you,
produce nice graphs to help you visualise the results,
warn you of potential issues when trying to reach conclusions based on the statistics (e.g. if it detects a bi-modal distribution, or if it detects and eliminates outliers).

Installing BenchmarkDotNet

Installation is simple ...

$ dotnet add package BenchmarkDotNet

C# Example

The main that runs the benchmark in this example is simple too ...

BenchmarkRunner.Run<MyBenchmark>();

Now let's look at the code to be benchmarked. Let's compare which is faster to look through a list - LINQ or a "for each" loop ...

[RankColumn]
[Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.FastestToSlowest)]
public class MyBenchmark
{
  [Params(10_000, 100_000, 1_000_000)]
  public int N { get; set; }

  private List<int> _list;

  [GlobalSetup]
  public void Setup() => _list = Enumerable.Range(0, N).ToList();        

  [Benchmark]
  public int LinqQuery() => _list.First(ii => ii == N - 1);

  [Benchmark(Baseline = true)]
  public int ForEachLoop()
  {
    foreach (var ii in _list)
    {
      if (ii == N - 1)
      {
        return ii;
      }
    }
    throw new Exception("Not found");
  }
}

The [RankColumn] and [Orderer] will rank and order the code according to what you configure in your Orderer.

The [Params] attribute will instruct the benchmarker to perform a benchmark run with (in this case) N set to that value. It will run the [GlobalSetup] once for each value of N before it runs a number of iterations of each of the benchmarks.

Using the Baseline attribute parameter will more clearly show how many times faster/slower the code is compared to a baseline.

The result summary from this example console application is shown below. Note that 1us is 1 microsecond. Also note that the Error is half of the 99.9% confidence interval (Note that I am not a statistician but I think of it as highly likely that the real mean is within the interval defined by the sampled Mean ± Error) ...

Method	N	Mean	Error	StdDev	Ratio	RatioSD	Rank
ForEachLoop	10000	11.80 us	0.229 us	0.225 us	1.00	0.00	1
LinqQuery	10000	86.12 us	1.568 us	1.466 us	7.30	0.13	2

ForEachLoop	100000	114.91 us	1.628 us	1.444 us	1.00	0.00	1
LinqQuery	100000	835.23 us	11.179 us	9.910 us	7.27	0.14	2

ForEachLoop	1000000	1,172.17 us	20.658 us	19.323 us	1.00	0.00	1
LinqQuery	1000000	8,446.51 us	166.337 us	163.366 us	7.21	0.16	2

So we can see that on my machine, LinqQuery is around 7 times slower (looking at the Ratio column) than the baseline ForEachLoop.

Other useful attributes

The attribute [RPlotExplorer] will create nice plots for you but you will need R and the rplotengine package installed on the machine running the benchmark.

The attribute [MemoryDiagnoser] will show the allocated memory so it can be useful for showing code that may be fast but uses more memory.

The attribute [SimpleJob(runtimeMoniker: RuntimeMoniker.Net70] will run each of the benchmarks with .NET 7. You can specify multiple platforms if you want to compare performance against other versions of .NET.

Where to start with regular expressions?

G.L Solaria — Sat, 07 May 2022 02:11:24 +0000

Recently I was asked where a novice would start learning how to read and write regular expressions. Below are two sites that I think would be useful.

Reading regular expressions

I think RegExr is a good site for explaining regular expressions.

Writing regular expressions

Learning to write regular expressions is quite hard. RegexOne provides a very good beginners tutorial to help people learn how to write regular expressions.

What resources have helped you to learn how to read/write regular expressions?

Fail-fast Programming?

G.L Solaria — Sat, 26 Mar 2022 06:33:33 +0000

I have an existing code base for which I need to replace a low-level layer and I want to think about an error handling strategy for this new layer.

For handling interfaces to external systems, it makes sense to reject unexpected inputs and carry on. I think it also makes sense that errors in inputs from a high-layer to a lower layer are thrown as exceptions upward from the lower layer. But what about internal inputs/outputs that are passed between code within a layer?

Before I go into what I think fail-fast programming is, I need to cover design by contract.

Design by Contract

Design by contract is an approach to reducing the number of bugs in code. The idea is to specify pre-conditions, post-conditions, and invariants that must hold for the code to execute correctly. Below I define these terms and give a code example. Note that the code examples are a bit silly and certainly don't represent best coding practices but hopefully explain the concept simply.

Pre-conditions

A pre-condition is a condition that must be true before executing a code block. The code block won't execute as expected if the pre-conditions are false. A pre-condition can express what is required of the inputs or expectations about the internal state of a class.

class Haystack {
    private enum Objects {
        Needle = 0, Pen = 1, Pencil = 2
    }

    private List<Objects> _buried;

    internal Haystack() {
        _buried = new List<Objects> {Objects.Needle};
    }

    internal int FindAndRemove(int obj) {
        // Pre-condition: obj must be 0, 1, 2        
        int found = -1;

        for (int ii = 0; ii < _buried.Count; ++ii) {
            if ((int) _buried[ii] == obj) {
                found = 1;
                break;
            }
        }

        // Needles are too dangerous to remove!
        if (found == 1 && obj != (int) Objects.Needle) {
            _buried.Remove((Objects) obj);
        }

        return found;
    }
}

Post-conditions

A post-condition is something that must be true once a code block has executed.

class Haystack {
    private enum Objects {
        Needle = 0, Pen = 1, Pencil = 2
    }

    private List<Objects> _buried;

    internal Haystack() {
        _buried = new List<Objects> {Objects.Needle};
    }

    internal int FindAndRemove(int obj) {
        int found = -1;

        for (int ii = 0; ii < _buried.Count; ++ii) {
            if ((int) _buried[ii] == obj) {
                found = 1;
                break;
            }
        }

        // Needles are too dangerous to remove!
        if (found == 1 && obj != (int) Objects.Needle) {
            _buried.Remove((Objects) obj);
        }

        // Post-condition: found is either 1 or -1
        return found;
    }
}

Invariants

An invariant always holds true after a certain point in the code (typically after initialisation code is executed).

class Haystack {
    private enum Objects {
        Needle = 0, Pen = 1, Pencil = 2
    }

    private List<Objects> _buried;

    internal Haystack() {
        _buried = new List<Objects> {Objects.Needle};
        // Invariant: _buried is not null
        // Invariant: a needle is always buried
    }

    internal int FindAndRemove(int obj) {
        int found = -1;

        // Invariant: _buried is not null
        for (int ii = 0; ii < _buried.Count; ++ii) {
            // Invariant: ii is less than the length of _buried
            if ((int) _buried[ii] == obj) {
                found = 1;
                break;
            }
        }

        // Needles are too dangerous to remove!
        if (found == 1 && obj != (int) Objects.Needle) {
            _buried.Remove((Objects) obj);
        }
        // Invariant: a needle is always buried

        return found;
    }
}

Fail-fast Strategy

A fail-fast strategy means the program crashes immediately when a pre-condition, post-condition or invariant is false. Instead of using comments to document the condition, "asserts" are used to crash the program. For example, a condition can be tested ...

Trace.Assert(_buried != null);
Trace.Assert(obj >= 0, $"obj is {obj}");
Trace.Assert(obj <= 2, $"obj is {obj}");

... which crashes the program with a stack trace and a helpful line number. If a message is included, the message is output.

I have seen this strategy create very reliable code in a very large code base that has run 24/7 for over 10 years.

There are some pretty big commitments that need to be made for this to result in reliable code - namely extensive testing. Automated test cases are the ideal but they need to be of a good quality and properly maintained. Code coverage metrics must be collected and analysed to ensure adequate code coverage.

Pros

It's hard to ignore a crash.

Developers implicitly become testers of all fail-fast code. A sufficiently trained developer with adequate time will at least raise a bug, if not investigate it.

Traces of crashes help developers zero in as close as possible to the cause of the crash.

Code is simpler because the code to check conditions is often less verbose than using try/catch blocks.

Code is better documented and actively enforced. The documentation can't become out of date because if it does, it crashes the program.

Code that has pre-conditions, post-conditions, and invariants leads to less bugs getting introduced when code is later modified. This is especially true when developers only read a fragment of code before making a change.

There is no error recovery code. Ideally if the system is critical, there is a fault-tolerance mechanism at the system level that triggers to recover from the fault.

Cons

It's hard to ignore a crash.

Under pressure, developers may choose to remove pre-conditions, post-conditions, and invariants if a root cause for a crash cannot be found.

Testing may be inadequate leading to more bugs getting through to production. This is obviously a very big con because crashes in production are generally considered bad!

Catch-all Strategy

A catch-all strategy tries to continue on in the face of fault conditions. This usually involves surrounding all code blocks with try/catch statements.

Pros

The system is unlikely to crash in production.

Error conditions can be recovered if exceptions are handled and do more than simply log an error message.

Cons

The system can silently malfunction in production. When the system silently malfunctions in test and in development environments, it is a lost opportunity to catch and fix bugs.

It is harder to track down the cause of a malfunction without good log messages. If the bugs cannot be re-produced, turning on tracing will not help.

Most developers will only look at their own log messages and not look for other error messages. Unless developers are very disciplined, log files become very noisy with lots of errors even though the system looks like it is behaving leading to what I like to call "log-error-blindness".

Testing error recovery code littered throughout the code base is difficult.

Optional Fail-Fast

Another possibility is that fail-fast can be optionally switched on or off either at build time or at runtime.

Pros

Fail-fast can be disabled in critical production environments.

Fail-fast can be enabled in internal or external test environments and developer environments.

Most of the benefits of fail-fast can be realised without risking stability in production.

Cons

Running different code in production compared to test and development potentially introduces the risk of error conditions emerging in production that don't occur in development and test. For example, side-effects in condition testing could lead to faults when condition testing is turned off.

Fail-fast with Error Recovery

Fail-fast can be implemented with special exceptions thrown up to a level that can handle and try to recover from the error. Helper methods can be implemented to more succinctly document and enforce detection of internal error conditions.

Pros

The dream is that you get the best of all strategies.

Cons

Testing error recovery in code is difficult. The system could become even more unreliable if a fault occurs in the error recovery code.

Testing error recovery code at the system level can be difficult unless an error can be triggered in some way. This con can be mitigated if there is a system-level fault-tolerance mechanism (rather than trying to handle the error in code) that is easily testable. But this can also become a con again if the error condition persists leading frequent engagement of the fault-tolerance mechanism which itself can cause instability.

Discussion

There are probably other approaches. If you can think of any others, please let me know in the comments.

I don't think there is a one-size-fits-all implementation strategy for design by contract. I think in my case, the new layer will use a strategy of throwing exceptions up to higher layers when pre-conditions, post-conditions and invariants are violated. It will then be up to the higher layers to decide what to do.

How to Create a .NET 6.0 SDK Linux Docker Container

G.L Solaria — Fri, 12 Nov 2021 23:58:18 +0000

This post describes the steps I took to create a .NET 6.0 SDK Docker container running Ubuntu 20.04. I should note that my host machine is also running Ubuntu 20.04. Here is a more detailed explanation on how to setup Docker .NET images on GitHub.

Install Docker on Ubuntu 20.04

I quite like the Docker documentation on how to install Docker on Ubuntu so I am not going to repeat the steps here.

Note the .NET 6.0 Dockerhub Image Tag

Dockerhub is the biggest and most well-known repository of pre-built docker images. It hosts the .NET 6.0 runtime and SDK images built by Microsoft.

Say you want to install the .NET 6.0 SDK on Ubuntu 20.04.

First you need to know the path. If you look at the "Featured Tag" section of the page, you will see something like the following ...

More information on the featured tag can be found on the samples page ...

The sdk:6.0 and runtime:6.0 tags are both multi-arch tags that will result in an image that is compatible for the given chip and OS. These simple tags (only contain a version number) are great to get started with Docker because they adapt to your environment.
They do mention that for production systems, you should specify an OS-specific tag. So we need to extract the image path from the tag. In this case, the path is "mcr.microsoft.com/dotnet/sdk".

Now if you navigate to the "Full Tag Listing" on the .NET SDK dockerhub page, you will see something like the following ...

Say I want the latest Ubuntu 20.04 image, then the tag will be "6.0-focal" and the full path will be "mcr.microsoft.com/dotnet/sdk:6.0-focal". But you can use any Linux image tag. For example to build an Alpine image, use "mcr.microsoft.com/dotnet/sdk:6.0-alpine".

Create a Dockerfile

So now we know the path and tag of the image we want to base our image on, we can create a a file called "Dockerfile" in an empty directory ...



FROM mcr.microsoft.com/dotnet/sdk:6.0-focal AS build

Build the Docker Image

To create the image we run the following command in the same directory as the "Dockerfile" ...



sudo docker build -t example-image .

The "-t" option specifies a tag name and the "." tells it which directory to find the "Dockerfile".

To see that the image has been successfully created, run ...



sudo docker image ls

Create and Run a Command in a Container

To create and run a command in a new container based on the image we just built, we run the following command ...



$ sudo docker run --name example-server -it --rm example-image bash

The "-it" will run the bash command interactively and allocates a pseudo TTY to allow us to effectively run a bash shell in our current shell. The "--rm" will automatically remove the container that gets created. If we did not use the "--rm" option, each time we run the command, a new container would be created. From the bash terminal running in the container, list out the supported SDKs and exit ...



root@2dc636974d10:/# dotnet --list-sdks
6.0.100 [/usr/share/dotnet/sdk]
root@2dc636974d10:/# exit

The "exit" command will exit the bash shell running in the container and the container will get deleted because of the "--rm" option we specified in the run command.

What's new in C# 10.0

G.L Solaria — Sat, 06 Nov 2021 03:35:42 +0000

C# was first released around 20 years ago and recently the pace of releases has increased with new releases being unveiled every year for the past 4 years.

C# 10.0 is likely to be launched with .NET 6.0 at .NET Conf 2021 coming up on November 9 (with the conference concluding on November 11). So I thought I would summarise some of the new features introduced in C# 10.0. But first a bit of history ...

Language Evolution

Initially C# was released every few years. Each release typically included a signature feature that required significant thought in how to use it. For example, C# 2.0 introduced Generics, C# 3.0 introduced LINQ, C# 5.0 introduced async/await for asynchronous programming.

With the latest releases now happening every year, they are focusing more on code simplification with smaller updates. Big new features, however, are now likely to evolve over a few releases. For example, pattern matching continues to evolve now spanning 4 releases. Records is another example of this evolutionary approach.

The C# language design also moved from a closed, secret development model to an open development model around 2013. Now you can even contribute to the C# language design forum hosted on GitHub to help further evolve the language. Design meetings and road-maps are published on the site publicly to enable open discussions and feedback.

New Features

I have chosen not to describe all proposed features of C# 10.0 because this would be a very long post (it's very long already!). If you are interested in the full list of proposals, see the C# Language Version History.

File scoped namespace declarations which is a dispenses with the wasteful indentation and braces that comes with namespace declarations thereby removing one level of indentation and braces for all C# files.
Global using directives which allow you to define using directives centrally so that they do not need to be defined in every file.
Constant interpolated strings which allows interpolated strings to be able to be declared constant where possible.
Extended property patterns which simplifies the use of nested properties in pattern matching statements.
Lambda improvements which include the ability for attributes to be defined on lambdas, ability to use var when defining lambdas, and the ability to specify the return type of a lambda.
Caller argument expression which adds a new attribute to help identify expression information at compile time.
Record structs which evolves the C# 9.0 record class reference-type to add a new record struct value-type to manipulate small records efficiently.
Incremental generators which takes source code generators to the next level allowing for generation of not just source code. It also allows for improved generation performance.
Improved definite assignment analysis which fixes a few obscure cases where the compiler would complain that a variable had not been initialised.

File scoped namespace declarations

Instead of ...

namespace WhatsNew10
{
    public class Foo
    {
    }
}

... you can dispense with the top level braces by declaring the namespace using the following ...

namespace WhatsNew10;

public class Foo
{
}

Global using directives

The using directive imports all types from the specified namespace.

Adding the keyword "global" to the directive in any code file will import those namespace types and make the types available to all code in the project.

global using System;

Implicit global using directives are also created by the compiler depending on the .NET 6.0 project SDK type. The implicit usings for 2 of the major project types are shown below ...

Project SDK Type	Implicit Global Usings
Microsoft.NET.Sdk	System
	System
	System.IO
	System.Net.Linq
	System.Net.Http
	System.Threading
	System.Threading.Tasks
Microsoft.NET.Sdk.Web	System
	System.Net.Http.Json
	Microsoft.AspNetCore.Builder
	Microsoft.AspNetCore.Hosting
	Microsoft.AspNetCore.Http
	Microsoft.AspNetCore.Routing
	Microsoft.Extensions.Configuration
	Microsoft.Extensions.DependencyInjection
	Microsoft.Extensions.Hosting
	Microsoft.Extensions.Logging

So together with the C# 9.0 Top Level Statements feature, the complete code file for a Program.cs can look like this ...

Console.WriteLine("Hello, World!");

Constant interpolated strings

The following use of the constant keyword is now permitted for interpolated strings where previously a compile error would be generated ...

const string s1 = $"Hello world";
const string s3 = $"{s1} C#10";

Extended property patterns

Consider the following ...

var aa = new A { Property1 = "foo" };
var bb = new B { Property2 = aa };

public class A
{
    public string Property1 { get; set; }
}

public class B
{
     public A Property2 { get; set; }
}

To use pattern matching on an instance of B you previously had to ...

bool isFoo = bb switch
{
    { Property2 : { Property1: "foo"} } => true,
    _ => false
};

... but you can do this more simply now by ...

bool now = bb switch
{
    { Property2.Property1 : "foo" } => true,
    _ => false
};

Lambda improvements

Automatic inference of the type of a lambda is a nice simplification introduced in C# 10.0.

Func<string, bool> isFooInC9 = ss => ss == "foo"; // C# 9.0
var isFooIn10 = (string ss) => ss == "foo";       // C# 10.0

Lambdas can also have attributes defined on them so instead of ...

[HttpGet("/")] Foo GetFoo() => new(Id: 0, Name: "Name");
app.MapAction((Func<Foo>)GetFoo);

... you can now write ...

app.MapAction([HttpGet("/")] () => new Foo(Id: 0, Name: "Name"));

The return type of a lambda can also now be explicitly specified ...

var foo = () => 1;        // foo is type Func<Int32>
var bar = () => (long) 1; // bar is type Func<Int64>

There are a few other improvements including direct lambda invocation and enhanced overload resolution that can be reviewed in the proposal for lambda improvements.

Caller Argument Expression

You can now get an expression as a string by ...

// Writes "(1 == 2 ? true : false) is False" to the console.
Print((1 == 2 ? true : false)); 

static void Print(
    bool result, 
    [CallerArgumentExpression("result")] string expr = default
    )
{
    Console.WriteLine($"({expr}) is {result}"); 
}

Record Structs

Record classes introduced in C# 9.0 are useful because it makes it easier to create immutable objects that are thread-safe (by using the init keyword instead of the set keyword). Record classes are also helpful because the compiler creates some nice value-like built-in methods like:

equality operators,
a numeric hash code based on the property values (so you can use the record in a hash-based collections for fast look-ups), and
a way to convert the values of the record properties to a string.

Record structs also provide those compiler generated record built-ins (unlike plain structs which only generate getters and setters). Record classes, however, are reference types so instances of the type are allocated within the heap. Record structs, on the other hand, are value types so they are allocated on the stack. This means record structs can be manipulated efficiently.

So now we can create an immutable record struct in one nice line of code ...

public readonly record struct Foo(string Fiz, string Faz);

... and use it ...

var foo1 = new Foo { Fiz = "Fizzy", Faz = "Fazzy" };
var foo2 = new Foo { Fiz = "Fizzy", Faz = "Fazzy" };
var foo3 = foo1 with { Faz = "Zazzy" };

Console.WriteLine($"{foo1}"); // Foo { Fiz = Fizzy, Faz = Fazzy }
Console.WriteLine($"{foo2}"); // Foo { Fiz = Fizzy, Faz = Fazzy }
Console.WriteLine($"{foo3}"); // Foo { Fiz = Fizzy, Faz = Zazzy }
Console.WriteLine($"{foo1.GetHashCode()}"); // 129686175
Console.WriteLine($"{foo2.GetHashCode()}"); // 129686175
Console.WriteLine($"{foo3.GetHashCode()}"); // 784730341
Console.WriteLine($"{(foo1 == foo2)}"); // True
Console.WriteLine($"{(foo1 == foo3)}"); // False

Incremental generators

Source generators were introduced in .NET 5 which 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. (Introducing C# Source Generators)

Incremental generators are a new feature that allows for the generation of source code, artefacts and embedded files. Pipelines can be implemented that use cached data to perform further transformations thereby improving performance.

I admit I don't fully understand how to use this feature and I will be looking forward to .NET Conf for some simple explanations and examples.

Improved definite assignment analysis

Definite assignment analysis is the static analysis done by the compiler to ensure that variables are assigned before they are used. C and C++ don't have this feature although Java does.

There were a few interesting cases that previously gave an error and are now okay with C# 10.0. The cases are obscure but if you are really interested, you can delve into the cases.

Conclusion

So there have been some nice simplifications proposed for C# 10.0. They are continuing to evolve features such as pattern matching and records in response to developer feedback which I think is good to see. C# might even survive another 20 years!