DEV Community: Ricardo

Logging Performance Improvements with Source Generators in C# .NET

Ricardo — Wed, 16 Jul 2025 10:00:00 +0000

In recent .NET releases, source generators have become a game-changer, offering new possibilities for compile-time code generation. One area where source generators have made a significant impact is logging.

In this post, we will explore how to use source generators for logging, the improvements and benefits they bring, and some practical tips to get the most out of this feature.

Logging with Source Generators

Using source generators for logging in .NET can help streamline logging calls, reduce overhead, and provide more efficient, type-safe logging.

The Microsoft.Extensions.Logging namespace has integrated support for source-generated logging, which we will explore in detail.

Setting Up Source-Generated Logging

To get started, you need to ensure you have the necessary packages. Typically, you would include the following in your project:

dotnet add package Microsoft.Extensions.Logging
dotnet add package Microsoft.Extensions.Logging.Abstractions

Next, you need to enable the logging source generator. This is done by defining logging methods in a static partial class with the LoggerMessage attribute.

Here’s an example:

using Microsoft.Extensions.Logging;

public static partial class Log
{
    [LoggerMessage(EventId = 0, Level = LogLevel.Information, Message = "Processing item {ItemId}")]
    public static partial void ProcessingItem(ILogger logger, int itemId);

    [LoggerMessage(EventId = 1, Level = LogLevel.Error, Message = "Failed to process item {ItemId}: {ErrorMessage}")]
    public static partial void ProcessingItemFailed(ILogger logger, int itemId, string errorMessage);
}

Using the Generated Logging Methods

With the logging methods defined, you can use them in your application as follows:

public void ProcessItem(int itemId)
{
    try
    {
        // Processing logic here
        Log.ProcessingItem(_logger, itemId);
    }
    catch (Exception ex)
    {
        Log.ProcessingItemFailed(_logger, itemId, ex.Message);
    }
}

Behind the Scenes: The Generated Code

During the compilation of the project the partial class for Log will generated and compiled along with the source code.

Observe the generated code for the logging methods.

partial class Log
{
    /// <summary>
    /// Logs "Processing item {ItemId}" at "Information" level.
    /// </summary>
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "8.2.0.0")]
    public static partial void ProcessingItem(global::Microsoft.Extensions.Logging.ILogger logger, int itemId)
    {
        if (!logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Information))
        {
            return;
        }

        var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;

        _ = state.ReserveTagSpace(2);
        state.TagArray[1] = new("ItemId", itemId);
        state.TagArray[0] = new("{OriginalFormat}", "Processing item {ItemId}");

        logger.Log(
            global::Microsoft.Extensions.Logging.LogLevel.Information,
            new(0, nameof(ProcessingItem)),
            state,
            null,
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "8.2.0.0")] static string (s, _) =>
            {
                var itemId = s.TagArray[1].Value;
                return global::System.FormattableString.Invariant($"Processing item {itemId}");
            });

        state.Clear();
    }

    /// <summary>
    /// Logs "Failed to process item {ItemId}: {ErrorMessage}" at "Error" level.
    /// </summary>
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "8.2.0.0")]
    public static partial void ProcessingItemFailed(global::Microsoft.Extensions.Logging.ILogger logger, int itemId, string errorMessage)
    {
        var state = global::Microsoft.Extensions.Logging.LoggerMessageHelper.ThreadLocalState;

        _ = state.ReserveTagSpace(3);
        state.TagArray[2] = new("ItemId", itemId);
        state.TagArray[1] = new("ErrorMessage", errorMessage);
        state.TagArray[0] = new("{OriginalFormat}", "Failed to process item {ItemId}: {ErrorMessage}");

        logger.Log(
            global::Microsoft.Extensions.Logging.LogLevel.Error,
            new(1, nameof(ProcessingItemFailed)),
            state,
            null,
            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Gen.Logging", "8.2.0.0")] static string (s, _) =>
            {
                var itemId = s.TagArray[2].Value;
                var errorMessage = s.TagArray[1].Value ?? "(null)";
                return global::System.FormattableString.Invariant($"Failed to process item {itemId}: {errorMessage}");
            });

        state.Clear();
    }
}

Improvements and Benefits

Performance : Source-generated logging methods are more performant than traditional logging methods because the code is generated at compile time, avoiding reflection and dynamic code generation at runtime.
Type Safety : The generated methods provide type-safe logging. If you change the parameters or the message template, you will get compile-time errors instead of runtime issues.
Reduced Boilerplate : You write the logging methods once, and the source generator takes care of the rest, reducing the amount of repetitive code in your project.
Consistency : Ensures that logging messages are consistent across the application, as they are defined in one place.

Practical Tips

Use Descriptive Names : When defining logging methods, use descriptive names and message templates to make it clear what each log entry represents.
Keep It Organized : Group related logging methods in the same partial class to keep your code organized.
Event IDs : Use unique event IDs for each logging method to help with filtering and analyzing logs.
Log Levels : Carefully choose the appropriate log level (e.g., Information, Error, Warning) to avoid cluttering your logs with unnecessary information.
Template Matching : Ensure that the message templates match the method parameters exactly to avoid runtime errors.

Keeping Organized

Group related logging methods in the same partial class to keep your code organized.

using Microsoft.Extensions.Logging;

namespace TodoList;

public static partial class Log
{
    [LoggerMessage(EventId = 0, Level = LogLevel.Information, Message = "Processing item {ItemId}")]
    public static partial void ProcessingItem(ILogger logger, int itemId);

    [LoggerMessage(EventId = 1, Level = LogLevel.Error, Message = "Failed to process item {ItemId}: {ErrorMessage}")]
    public static partial void ProcessingItemFailed(ILogger logger, int itemId, string errorMessage);
}

public class Todo(ILogger<Todo> logger)
{
    public void ProcessItem(int itemId)
    {
        try
        {
            // Processing logic here
            Log.ProcessingItem(logger, itemId);
        }
        catch (Exception ex)
        {
            Log.ProcessingItemFailed(logger, itemId, ex.Message);
        }
    }
}

Conclusion

Source generators provide a powerful way to improve logging in .NET applications.

By generating logging code at compile time, you can achieve better performance, type safety, and consistency. Incorporate source-generated logging into your projects to take advantage of these benefits and streamline your logging implementation.

If you have any questions or would like to see more examples, feel free to reach out. Happy coding!

For more detailed articles and hands-on tutorials on .NET and C#, check out my blog at rmauro.dev. Subscribe to my newsletter, Developers Garage, for weekly updates and curated content.

Make Your Machine Talk: Piper TTS Offline

Ricardo — Tue, 08 Jul 2025 00:26:01 +0000

Want to make your computer talk — using real, natural-sounding voices without needing the cloud?

In this tutorial, we’ll set up Piper TTS on a local system and give it a voice. It’s fast, offline, and perfect for voice assistants, robotics, Raspberry Pi projects, or just impressing your friends.

What You’ll Need

Python 3 installed (recommended: Python 3.8 or newer)
Linux environment (x86_64 or ARM64) - or Windows with WSL
Internet connection (just for setup)
A speaker or headphones
Terminal access

I have tested on Raspberry Pi OS 64-bit (Bookworm), Ubuntu 22.04, and Windows 11 using WSL. Works on most modern 64-bit Linux environments.

Install Piper Using pip

Piper can now be installed easily via pip, but to avoid issues with system-managed Python environments, it’s best to use a virtual environment.

python3 -m venv .venv
source .venv/bin/activate
pip install piper-tts

Add a Voice

Piper uses ONNX-based voice models and needs both the .onnx model and its matching .json config file.

You can browse the full list of supported voices here:

For this example, let's download the English voice "Amy".

# Download the model file
wget "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/amy/medium/en_US-amy-medium.onnx?download=true" \
     -O en_US-amy-medium.onnx

# Download the corresponding config file
wget "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/amy/medium/en_US-amy-medium.onnx.json?download=true" \
     -O en_US-amy-medium.onnx.json

Place both files in the same folder. Piper uses the .json file to determine things like speaking speed, noise level, and phoneme mappings.

Try It Out

Time for the magic. Let’s speak some text. You can generate a WAV file or stream it directly to your speakers.

Option 1: Save to file and play

echo "Hello from your machine!" | piper -m en_US-amy-medium.onnx --output_file hello.wav
aplay hello.wav # or use your system's audio player

Option 2: Stream directly to `aplay`

echo "This sentence is spoken first. This sentence is synthesized while the first sentence is spoken." \
  | piper -m en_US-amy-medium.onnx --output-raw \
  | aplay -r 22050 -f S16_LE -t raw -

This streams raw audio directly to your speakers in real-time. Make sure the sample rate and format match your voice model.

On WSL, use wmplayer hello.wav or powershell -c (New-Object Media.SoundPlayer 'hello.wav').PlaySync().

Use a GPU (Optional)

If you'd like to use a GPU, install the onnxruntime-gpu package inside your virtual environment. Then run Piper with the --cuda flag.

# installs the onnxruntime-gpu package
.venv/bin/pip3 install onnxruntime-gpu

# runs piper using CUDA
echo "Hello from your machine!" | piper -m en_US-amy-medium.onnx --cuda | aplay

You’ll need a working CUDA environment, such as what comes with NVIDIA's PyTorch containers.

Fine-Tune the Voice (Optional)

Too fast or too slow? Edit the en_US-amy-low.onnx.json config file and tweak this value:

"phoneme_duration_scale": 1.2

Or for more fine-tuning:

"inference": {
  "length_scale": 1.2,
  "noise_scale": 0.5,
  "noise_w": 0.6
}

Higher length_scale = slower speech. Try 1.2 to 1.5.

Wrap Up

You now have a fast, local, private TTS engine — no internet, no API keys. Just raw, talking hardware.

Next steps?

Use it in your scripts or Python apps
Hook it into a voice assistant
Clone your own voice (stay tuned for Tutorial #2!)

If this worked, give your machine a high-five — or better yet, have it say "Thank you!"

Run Docker on WSL2 Without Docker Desktop 🐳

Ricardo — Tue, 01 Jul 2025 17:00:24 +0000

In this tutorial let’s install Docker inside a WSL2 Linux distro, configure it to run without sudo, set up auto-start on launch, and enable log rotation to keep things clean—all without the bloated Docker Desktop.

Docker Desktop isn’t just unnecessary—it’s heavy, intrusive, and now comes with licensing restrictions. Running Docker natively inside WSL2 is faster, lighter, and fully under your control. Let’s set it up the right way.

Prerequisites ✅

WSL2 already installed
Ubuntu (or another Linux distro Debian based for this article) running under WSL2

Install Docker (Inside WSL2) 🔧

To install the Docker Community Engine, let's run the following script.

# Update your package lists and upgrade existing packages 
$ sudo apt update && sudo apt upgrade -y

# Install necessary packages to allow apt to use repositories over HTTPS
$ sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

# 🐳 Download and save Docker’s official GPG key
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
    sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 🐳 Add Docker’s stable repository to your APT sources list
$ echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
    sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update package index again, now with Docker packages included
$ sudo apt update

# 🐳 Finally, install the Docker Engine
$ sudo apt install docker-ce -y

🛠️ Running Docker Without SUDO

Nobody want's to type sudo for every command in our development machine.

Here is how set up.

# Create the 'docker' group (if it doesn't already exist)
# This group allows running Docker commands without 'sudo'
$ sudo groupadd docker

# Add your current user to the 'docker' group
$ sudo usermod -aG docker $USER

# Apply the new group membership immediately
# This avoids the need to log out and back in
$ newgrp docker

🚀 Wrapping up

$ sudo service docker start

$ docker run hello-world

That is it. It’s done! Congratulations! Amazing! Yeah!

⚙️ Optional: Auto-Start Docker on WSL Launch

Append this to ~/.bashrc or ~/.profile:

# Check if the current environment is WSL2
if grep -q "\-WSL2" /proc/version > /dev/null 2>&1; then

    # Check if the Docker service is not running
    if service docker status 2>&1 | grep -q "is not running"; then

        # Start the Docker service as root using WSL's built-in mechanism
        # This avoids needing sudo manually each time
        wsl.exe --distribution "${WSL_DISTRO_NAME}" --user root \
            --exec /usr/sbin/service docker start > /dev/null 2>&1
    fi
fi

Checks if the docker service isn't running and start it.

This code runs on the bash startup.

Configuring Docker: Daemon Settings + Log Rotation

To prevent Docker logs from eating up your disk space, configure log rotation:

$ sudo nano /etc/docker/daemon.json

Paste this:

{
  "host": "unix:///var/run/docker.sock",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

max-size: rotates when logs hit 10MB
max-file: keeps 3 files max, older logs get purged

Then restart Docker:

$ sudo service docker restart

You can adjust size or count based on your storage needs.

🛠️ Common Issues

Permission denied on docker → You forgot the group step or didn't apply it (newgrp docker)
Daemon not running → Run sudo service docker start

WSL version issues

→ Check:

$ wsl --list --verbose

✅ Summary

Task	Command
Install Docker	Add repo & install `docker-ce`
Start Docker daemon	`sudo service docker start`
Run as non-root	`usermod -aG docker $USER && newgrp docker`
Test Docker	`docker run hello-world`
Configure log rotation	Edit `/etc/docker/daemon.json` and restart daemon
Auto-start Docker on launch	Add script to `.bashrc` or `.profile`

No Docker Desktop. No junk. Just containers running clean and fast inside WSL2 — with logs under control.

Running llama.cpp in Docker on Raspberry Pi

Ricardo — Sat, 14 Jun 2025 16:47:32 +0000

Running large language models on a Raspberry Pi isn’t just possible—it’s fun. Whether you're a hacker exploring local AI, a developer prototyping LLM workflows, or just curious about how far you can push a Pi, this tutorial is for you.

We’ll show you how to build and run llama.cpp in Docker on an ARM-based Pi to get a full LLM experience in a tiny, reproducible container. No weird dependencies. No system pollution. Just clean, fast, edge-side inference.

If you are looking for a bare metal installation on the Raspberry Pi. Check this https://rmauro.dev/running-llm-llama-cpp-natively-on-raspberry-pi/

Dockerfile

The following Dockerfile builds llama.cpp from source within an Ubuntu 22.04 base image. It includes all required dependencies and sets the container entrypoint to the compiled CLI binary.

FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt update && apt upgrade -y && \
    apt install -y --no-install-recommends \
    ca-certificates git build-essential cmake wget curl \
    libcurl4-openssl-dev && \
    apt clean && rm -rf /var/lib/apt/lists/*

WORKDIR /opt
RUN git clone https://github.com/ggerganov/llama.cpp.git
WORKDIR /opt/llama.cpp

RUN cmake -B build
RUN cmake --build build --config Release -j$(nproc)

WORKDIR /opt/llama.cpp/build/bin
ENTRYPOINT ["./llama-cli"]

Build the Docker Image

Run the following command in the same directory as your Dockerfile to build the image:

docker build -t llama-cpp-pi .

Download a Quantized Model (on Host)

You need a quantized .gguf model to perform inference. Run this command from your host system:

mkdir -p models
wget -O models/tinyllama-1.1b-chat-v1.0.Q4_0.gguf \
  https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q4_0.gguf

This creates a models directory and downloads a compact version of TinyLlama suitable for edge devices.

Run Inference from Docker

Mount the models directory and run the container, specifying the model and prompt:

docker run --rm -it \
  -v $(pwd)/models:/models \
  llama-cpp-pi \
  -m /models/tinyllama-1.1b-chat-v1.0.Q4_0.gguf -p "Hello from Docker!"

To use a different model:

MODEL=your-model-name.gguf

docker run --rm -it \
  -v $(pwd)/models:/models \
  llama-cpp-pi \
  -m /models/$MODEL -p "Hello with custom model!"

Conclusion

This Docker-based setup enables efficient deployment of llama.cpp on ARM-based devices like the Raspberry Pi.

It abstracts away system-level configuration while preserving the flexibility to swap models, test prompts, or integrate with other AI pipelines.

For developers, researchers, and students, this is an ideal workflow to explore the capabilities of local LLM inference.

Running LLM llama.cpp Bare Metal on Raspberry Pi

Ricardo — Sat, 14 Jun 2025 16:33:30 +0000

For developers and hackers who enjoy squeezing maximum potential out of compact machines, getting a large language model like llama.cpp running natively on a Raspberry Pi is a rewarding challenge. This guide walks you through compiling llama.cpp from source, downloading a model, and running inference - all on the Pi itself.

Prerequisites

Hardware

Raspberry Pi 4, 5, or newer
64-bit Raspberry Pi OS
4GB RAM minimum (8GB+ recommended)
Heatsink or fan recommended for cooling

Software

Git
CMake (v3.16+)
GCC or Clang
Python 3 (optional, for Python bindings)

Step-by-Step Guide

Install required tools

sudo apt update && sudo apt upgrade -y

# 👇 install dependencies and tools to build
sudo apt install -y git build-essential cmake python3-pip libcurl4-openssl-dev

Clone and Build llama.cpp

git clone https://github.com/ggerganov/llama.cpp.git

cd llama.cpp

cmake -B build
cmake --build build --config Release -j$(nproc)

This step takes sometime. Here we're compiling llama-cpp software.

Download a Quantized Model

mkdir -p models && cd models

wget https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q4_0.gguf

cd ..

Let's use the model https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF for testing.

4. Run Inference

./build/bin/llama-cli \
  -m ./models/tinyllama-1.1b-chat-v1.0.Q4_0.gguf \
  -p "Hello, Raspberry Pi!"

Optional: Python Bindings

Note: The Python bindings have been moved to a separate repository.

git clone https://github.com/abetlen/llama-cpp-python.git
cd llama-cpp-python
python3 -m pip install -r requirements.txt
python3 -m pip install .

Use in Python:

# Use in Python:

from llama_cpp import Llama
llm = Llama(model_path="./models/tinyllama-1.1b-chat-v1.0.Q4_0.gguf")
print(llm("Hello from Python!"))

Conclusion

Running llama.cpp natively on a Raspberry Pi is a geeky thrill. It teaches you about compiler optimizations, quantized models, and pushing hardware to the edge—literally. Bonus points if you run it headless over SSH.

Building Your Own wc Tool in C# Code Challenge

Ricardo — Mon, 14 Oct 2024 23:51:21 +0000

The Unix wc (word count) tool is a classic command-line utility that counts the number of lines, words, and characters in a text file. In this post, we'll work on a minimalistic version of this tool using C#.

For this project let's focus on clarity over optimization, so even beginners can follow along.

Introduction

The wc tool is quite useful for analyzing text files in the terminal. It provides simple statistics:

Number of lines
Number of words
Number of characters
Number of bytes

This blog post is based on a code challenge where the goal is to recreate the functionality of the wc tool in your language of choice.

Below, we’ll build a minimal version of wc using C#.

Step-by-Step Implementation

First, let's break down what we'll need.

Reading the file : We’ll use a stream to read the contents of the file.
Counting lines, words, and characters : We'll write simple methods to count these.
Handling command-line arguments : We'll add options to count specific things (lines, words, bytes, etc.).

Here’s the code for our minimal wc tool:

using System;
using System.IO;
using System.Linq;
using static System.Console;

if (args.Length == 0)
{
    PrintUsage();
    return;
}

var parsedArgs = ArgumentsParser.Parse(args);

try
{
    using var reader = new StreamReader(parsedArgs.FilePath);
    long lineCount = 0, wordCount = 0, charCount = 0, byteCount = 0;

    string? line;
    while ((line = reader.ReadLine()) != null)
    {
        if (parsedArgs.CountLines) lineCount++;
        if (parsedArgs.CountCharacters) charCount += line.Length + 1; // +1 for newline character
        if (parsedArgs.CountWords) wordCount += CountWords(line);
        if (parsedArgs.CountBytes) byteCount += System.Text.Encoding.UTF8.GetByteCount(line) + 1;
    }

    if (parsedArgs.CountLines) Write($"{lineCount} ");
    if (parsedArgs.CountWords) Write($"{wordCount} ");
    if (parsedArgs.CountBytes) Write($"{byteCount} ");
    if (parsedArgs.CountCharacters) Write($"{charCount} ");
    WriteLine(parsedArgs.FilePath);
}
catch (FileNotFoundException)
{
    WriteLine($"Error: The file '{parsedArgs.FilePath}' does not exist.");
}

static long CountWords(string line)
{
    // Split the line by spaces and count non-empty entries
    var words = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
    return words.Length;
}

static void PrintUsage()
{
    const string usage_helper = @"Usage: ccwc [OPTION]... [FILE]...
  or: ccwc [OPTION]... --files0-from=F
Print newline, word, and byte counts for each FILE, and a total line if
more than one FILE is specified. A word is a non-zero-length sequence of
characters delimited by white space.

With no FILE, or when FILE is -, read standard input.

The options below may be used to select which counts are printed, always in
the following order: newline, word, character, byte, maximum line length.
  -c, --bytes print the byte counts
  -m, --chars print the character counts
  -l, --lines print the newline counts
  -w, --words print the word counts
      --help display this help and exit
      --version output version information and exit

!!!DISCLAIMER: This is a clone of famous wc (Word Count) command line. ";
    WriteLine(usage_helper);
}

A very simple ArgumentsParser.

public record class CWArgument(
    string FilePath, 
    bool CountBytes, 
    bool CountWords, 
    bool CountLines, 
    bool CountCharacters);

public static class ArgumentsParser
{
    /*
     * -c : number of bytes
     * -l : number of lines
     * -w : number of words
     * -m : number of characters
     * Default options - equivalent to -c -l -w
     */
    public static CWArgument Parse(string[] arguments)
    {
        var countB = arguments.Contains("-c") || arguments.Contains("--bytes");
        var countW = arguments.Contains("-w") || arguments.Contains("--words");
        var countL = arguments.Contains("-l") || arguments.Contains("--lines");
        var countM = arguments.Contains("-m") || arguments.Contains("--chars");
        var path = arguments[^1];

        var defaults = !countB && !countW && !countL && !countM;
        if (defaults) return new CWArgument(path, true, true, true, false);

        return new CWArgument(path, countB, countW, countL, countM);
    }
}

How It Works

File Handling : We use a StreamReader to read the file line by line. This is the simplest way to handle file reading in C#.
Counting Options : We handle the different counting options using the CWArgument record and the ArgumentsParser class. The parser processes the command-line arguments to determine what should be counted (bytes, words, lines, or characters). By default, it counts bytes, words, and lines, unless specified otherwise.
Counting Lines, Words, and Characters : Depending on the options provided, we count the number of lines, words, characters, and bytes.
Command-Line Arguments : The file path and options (e.g., -c for bytes) are passed as command-line arguments. The program parses them to determine which statistics to display.

Usage

To run the program, compile it and run it from the command line:

dotnet run -- -l -w -c <path_to_your_file>

For example:

dotnet run -- -l -w example.txt

The output will show the selected statistics based on the arguments passed. For example:

5 15 78 example.txt

This means the file example.txt has 5 lines, 15 words, and 78 characters.

Create an runnable executable

To do so all you need is.

dotnet publish -c Release -o ../output

Check the output folder recently created.

Special Mention

This implementation is a minimalist solution to the Build Your Own wc Tool challenge.

If you'd like to see a more refined version, including optimizations and additional features, check out my GitHub repository: Rmauro.CommandLines.WordCount.

Conclusion

We’ve built a minimalist version of the Unix wc tool in C# using just a few lines of code.

By adding argument parsing, we made the tool customizable based on the user’s needs.

This implementation is a great starting point for building command-line utilities and getting comfortable with file handling and argument parsing in C#.

You can experiment further by adding features or improving performance, but this version should give you a solid foundation.

Happy coding! 😎

C# Enum Bitwise Operations

Ricardo — Tue, 27 Aug 2024 15:43:46 +0000

Enums in C# offer more than just a simple way to define named constants—they can be a powerful tool for handling complex scenarios when combined with bitwise operations.

In this post, we will dive into advanced C# enum usage, focusing on bitwise operations to create powerful and flexible code. By understanding how to effectively use C# enum flags with bitwise AND/OR operations, you can optimize your applications and write more efficient C# code.

Using C# Enums, bitwise operations and C# flags you’ll enhance your ability to write more flexible, maintainable, and scalable code.

🧾 Introduction to Enums

An enum is a special data type that enables a variable to be a set of predefined constants. In practice, enums help create a meaningful representation of data, making it easier to work with instead of using integer literals scattered throughout your code.

Example: Enum to represent different types of animals.

public enum Animal
{
    Dog,
    Cat,
    Fish
}

Why Use Enums?

Readability: Using named constants instead of numeric values makes your code easier to read.
Maintainability: If the underlying value changes, you only need to update it in one place.
Type Safety: Enums prevent invalid values from being assigned to a variable.

💪 Advanced Enum Usage: Bitwise Operations

Enums can represent bit fields by combining values using bitwise operations, which is particularly useful for flags.

Defining Flags Enum

To do this, you should assign powers of two to each member of the enum.

[Flags]
public enum DataVidsFlags
{
    None = 0,
    FlagA = 1, // 0001
    FlagB = 2, // 0010
    FlagC = 4, // 0100
    FlagD = 8 // 1000
}

Using Bitwise Operations in C# Enums

You can leverage bitwise operators to combine and check flags.

// Using combine flags
DataVidsFlags myFlags = DataVidsFlags.FlagA | DataVidsFlags.FlagC;  

// Output: FlagA, FlagC
Console.WriteLine(myFlags);  

// Checking if a specific flag is set
bool hasFlagB = (myFlags & DataVidsFlags.FlagB) == DataVidsFlags.FlagB;

// Output: Has Flag B: False
Console.WriteLine("Has Flag B: " + hasFlagB);

Using HasFlag

The advantage of using the HasFlag method simplifies your code.

if (myFlags.HasFlag(DataVidsFlags.FlagC))
{
    Console.WriteLine("Flag C is set.");
}

Conclusion

Enums in C# serve as a powerful tool for creating more readable, maintainable, and type-safe code. Whether you are using simple enums for clarity or leveraging bitwise operations for complex flag representations, how you implement them can greatly improve your application's code quality.

Tips for Using Enums

Use Descriptive Names: Choose names that accurately describe the values.
Keep Them Organized: Consider placing enums in their own files for better organization.
Avoid Value Confusion: Assign starting points when using bitwise operations for clarity on the intended manipulation.
Utilize Flags: When multiple states can exist, use the [Flags] attribute to enable combined flags.

References

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/bitwise-and-shift-operators

Feel free to leave your thoughts, comments, or examples of how you’re using enums in your own projects! Happy coding! 😎

Publish C# Project to Nuget.org

Ricardo — Mon, 26 Aug 2024 14:39:31 +0000

Using NuGet packages and nuget.org are a great way to share our .NET projects with other developers and also distribute your code across multiple projects.

In this guide, we'll walk through the process of publishing an existing .NET project as a NuGet package on NuGet.org. Let's use the Rmauro.Extensions.Configuration.EnvFiles project as an example, which is hosted on GitHub.

Prepare the Project for Packaging

Let's start by cloning the project or using DevContainers to edit in Github Cloud (as demonstrated here Create and Configure a GitHub Codespace

# clones the project 
> git clone https://github.com/ricardodemauro/Rmauro.Extensions.Configuration.EnvFiles.git
> cd Rmauro.Extensions.Configuration.EnvFiles

Open the Rmauro.Extensions.Configuration.Env.csproj file and include the necessary NuGet package metadata.

<Project Sdk="Microsoft.NET.Sdk">
 <PropertyGroup>
   <TargetFramework>netstandard2.0</TargetFramework>

   <!--Starts here-->
   <PackageId>Rmauro.Extensions.Configuration.EnvFiles</PackageId>
   <PackageVersion>1.0.0</Version>
   <Authors>Ricardo Mauro</Authors>
   <Description>Extension to read .env files in dotnet core projects</Description>
   <RepositoryUrl>https://github.com/ricardodemauro/Rmauro.Extensions.Configuration.EnvFiles.git</RepositoryUrl>

    <PackageIconUrl>rmauro-favico-32.png</PackageIconUrl>
    <PackageIcon>rmauro-favico-32.png</PackageIcon>

   <PackageLicenseExpression>MIT</PackageLicenseExpression>
   <RequireLicenseAcceptance>false</RequireLicenseAcceptance>
   <!--Ends here-->
 </PropertyGroup>

  <!--https://stackoverflow.com/a/76122058/1652594-->
  <ItemGroup>
    <None Include="../../assets/rmauro-favico-32.png" Pack="true" PackagePath=""/>
  </ItemGroup>
</Project>

Properties Definition

PackageId Specifies the name for the resulting package
PackageVersion This is semver compatible, for example 1.0.0, 1.0.0-beta, or 1.0.0-beta-00345. Defaults to Version if not set
Authors A semicolon-separated list of packages authors, matching the profile names on nuget.org. These are displayed in the NuGet Gallery on nuget.org and are used to cross-reference packages by the same authors
Description A long description for the assembly. If PackageDescription is not specified, then this property is also used as the description of the package
RepositoryUrl Repository URL used to clone or retrieve source code.
PackageIconUrl PackageIconUrl is deprecated in favor of PackageIcon. However, for the best downlevel experience, you should specify PackageIconUrl in addition to PackageIcon
PackageIcon Specifies the package icon path, relative to the root of the package
PackageLicenseExpression Corresponds to license expression. Read more
RequireLicenseAcceptance A Boolean value that specifies whether the client must prompt the consumer to accept the package license before installing the package.

For more properties read the Microsoft's Official Docs: https://learn.microsoft.com/en-us/nuget/reference/msbuild-targets#pack-target

Tip: If you need to include Icon, you need to first import into the project by using <ItemGroup> and <None> tags and then use it.

Pack the NuGet Package

All set with our project, let's create the NuGet package.

Navigate to the project directory containing the .csproj file and run the following command.

# build the package and sets the version to 0.0.1
> dotnet build -c Release /p:Version=0.0.1

# packs the package
> dotnet pack --configuration Release

This command will generate a .nupkg file in the bin/Release directory.

Auto Generate the Package on Build

Include the following property to auto generate the package.

<GeneratePackageOnBuild>true</GeneratePackageOnBuild>

Create a NuGet.org Account and Get an API Key

Before you can publish your package, we need a NuGet.org account and an API key.

Go to NuGet.org and click "Sign in" in the top right corner.

Click "Create a new account" if you don't have one. You can sign up using a Microsoft account or create a new account with your email.
Follow the prompts to complete your registration, including email verification.

Generate an API Key

Once logged in, click on your username in the top right corner and select "API Keys".

Click "Create" to generate a new API key.

Provide a name for your key (e.g., "MyAwesomeLibrary Publishing Key").

Choose the scope for the key:

"Push new packages and package versions" if you're only publishing.
"Push and unlist packages" if you also want the ability to unlist packages.

Select the glob pattern for the packages this key can push. Use * for all packages or specify package names. Then click "Create".

Copy the generated API Key.

Remember to keep your API key confidential. Never share it or commit it to source control.

Publish to NuGet.org

Now that you have your API key, you can publish your package:

Use the following command to publish your package, replacing your_api_key with your actual API key:

> dotnet nuget push `
  bin/Release/Rmauro.Extensions.Configuration.EnvFiles.1.0.0.nupkg `
  --api-key your_api_key `
  --source https://api.nuget.org/v3/index.json

NuGet.org will process our package. It usually takes a few minutes to be available.

Here is our package: https://www.nuget.org/packages/Rmauro.Extensions.Configuration.Env/

Updating Your Package

When you make changes to your project and want increment the published version.

Build using the /p:Version=0.0.0.2 parameter or simply increment the <Version> number in your .csproj file
Repackage and publish again

> dotnet build -c Release /p:Version=0.0.0.2

> dotnet pack --configuration Release

> dotnet nuget push `
  bin/Release/Rmauro.Extensions.Configuration.EnvFiles.0.0.2.nupkg `
  --api-key {NUGET_API_KEY} `
  --source https://api.nuget.org/v3/index.json

Best Practices for Maintaining Your NuGet Package

Create/Update the README.md file in the nuget.org website
Use semantic versioning (MAJOR.MINOR.PATCH) to communicate the nature of updates
Regularly check for and update any dependencies in your project
Keep your code updated and secure against know treats
Rotate your API keys periodically for security

Conclusion

Publishing your existing .NET project as a NuGet package is a great way to share your work with the broader .NET community.

By following these steps, you've made your Rmauro.Extensions.Configuration.EnvFiles library easily accessible to other developers.

Happy packaging!!

Create and Configure a GitHub Codespace

Ricardo — Tue, 20 Aug 2024 14:26:20 +0000

GitHub Codespaces provides a powerful, cloud-based development environment that we can start and stop in seconds, tailored specifically to our project’s needs.

In this tutorial, let's go through the process of set up and configure a GitHub Codespace using an existing repository.

Let's dive in and see how you can get started with GitHub Codespaces today!

🚀 Table of Contents

Before You Start - Mind the Costs
Create a GitHub Codespace
Select a Pre-Build Configuration
Save and Push Changes
Stop Current Codespace
The Codespace Dashboard

⌚ Before You Start - Mind the Costs

GitHub Codespaces offers a powerful cloud-based development environment with a free usage cota but it's NOT free. Understanding the pricing structure can help you manage costs effectively.

GitHub Codespaces is paid for either by an organization, an enterprise, or a personal account. The Free and Pro plans for personal accounts include free use of GitHub Codespaces up to a fixed amount of usage every month.

Free of charge today - 08/17/2024

🔨 Step by Step Guide

Let's dive into the step by step guide on Code Spaces.

Step 1: Create a GitHub Codespace

To create the Codespace click on the Code button, then Codespaces, and then select Create codespace on main.

If you have multiple branches, you can choose a specific branch for the Codespace.

A dialog may appear allowing you to choose the machine type (e.g., 2-core, 4-core). Select the appropriate machine based on your development needs.

Once initialized, you’ll see a Visual Studio Code interface within your browser.

Step 2: Select a Pre-Build Configuration

On the Visual Code search bar start typing > Codespaces to see all the available options.

Select "Codespaces: Add Dev Container Configuration File..." to start from scratch. Next select "Create a new configuration" to start from scratch .

Select "C# (.NET) devcontainers" or the best framework for your project.

Moving forward we can include additional features to install, such as ".NET Aspire".

Once completed all the selections click on Rebuild Now to start building the Codespace.

The devcontainer.json file should be created. It contains all configuration for the recently created Codespace.

You can commit and push the devcontainer.json file to the repository for later use.

In the devcontainer.json file you can add more features, change ports, remote user, among other features. D on't forget to "Rebuild" if changes are made.

// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/dotnet
{
    "name": "C# (.NET)",
    // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
    "image": "mcr.microsoft.com/devcontainers/dotnet:1-8.0-bookworm"

    // Features to add to the dev container. More info: https://containers.dev/features.
    // "features": {},

    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    // "forwardPorts": [5000, 5001],
    // "portsAttributes": {
    // "5001": {
    // "protocol": "https"
    // }
    // }

    // Use 'postCreateCommand' to run commands after the container is created.
    // "postCreateCommand": "dotnet restore",

    // Configure tool-specific properties.
    // "customizations": {},

    // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
    // "remoteUser": "root"
}

Step 3: Save and Push Changes

As we make changes in our source code, they will be contained only within the Codespace. Use the Git panel in Visual Studio Code to commit your changes.

Step 4: Stop Current Codespace

When finished let's STOP the Codespace to avoid incurring unnecessary charges.

When no longer need, we can delete it to free up resources.

Simply navigate to the GitHub Codespaces dashboard, find your Codespace, and select Delete.

The Codespace Dashboard

Remember to check the Codespace Dashboard to make sure nothing is running without your knowledge.

Conclusion

The GitHub Codespaces can greatly enhance our development workflow, offering a consistent and accessible environment wherever we work.

Happy coding! 😎

Load .Env file into IConfiguration Provider

Ricardo — Wed, 14 Aug 2024 18:25:27 +0000

Managing environment variables efficiently is crucial for modern .NET applications, especially when configuring environments like development, staging, and production.

.NET Core's IConfiguration interface is a powerful tool for managing application settings, and it can be extended to include environment variables stored in a .env file using a custom configuration provider.

In This Series

Reading .env Files in C#
Loading DotEnv file into IConfiguration (You're here)
Creating NuGet Package for EnvReader (coming soon)

In this post, we’ll demonstrate how to integrate the EnvReader class into IConfiguration, enabling seamless configuration management for your C# applications with support for DotEnv files.

This article is a follow-up to our previous post, Reading a .env File in C#, where we introduced the EnvReader class to load environment variables from a .env file.

Setting Up the Project

Create a new .NET Standard Class Library and add the dependency packages.

# creates class library
dotnet new classlib -o Extensions.Configuration.EnvFile

# add to solution
dotnet sln add Extensions.Configuration.EnvFile/Extensions.Configuration.EnvFile.csproj

#add dependency packages
dotnet add package Microsoft.Extensions.Configuration.Abstractions
dotnet add package Microsoft.Extensions.Configuration.FileExtensions

The .csproj file should look like this.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.1</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="8.0.1" />
  </ItemGroup>

</Project>

Implementing the Configuration reader

To have a fully functional EnvReader integrated with Microsoft.Extensions.Configuration.IConfiguration interface lets us set up 4 different classes.

EnvConfigurationExtensions - Here we will have the AddEnvFile method and overloads
EnvConfigurationProvider - Provider to read the .env file
EnvConfigurationSource - Source of Configuration that integrates with the Provider
EnvReader - The .env file reader/parser

Step 1: Set Up the `EnvReader` Class

For this version of EnvReader let's use Stream instead of file path.

using System.Collections.Generic;
using System.IO;

internal static class EnvReader
{
    public static IEnumerable<KeyValuePair<string, string>> Load(Stream stream)
    {
        StreamReader reader = new StreamReader(stream);

        while (reader.Peek() > -1)
        {
            string line = reader.ReadLine();

            if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
                continue; // Skip empty lines and comments

            var parts = line.Split('=', 2);
            if (parts.Length != 2)
                continue; // Skip lines that are not key-value pairs

            var key = parts[0].Trim();
            var value = parts[1].Trim();

            yield return new KeyValuePair<string, string>(key, value);
        }
    }
}

Step 2: Create a Custom Configuration Provider

To integrate EnvReader into IConfiguration, let's create a custom configuration provider.

This provider will load environment variables from a .env file and make them available through IConfiguration.

using Microsoft.Extensions.Configuration;
using System.IO;

internal class EnvConfigurationProvider : FileConfigurationProvider
{
    public EnvConfigurationProvider(FileConfigurationSource source) : base(source)
    {
    }

    public override void Load(Stream stream)
    {
        foreach (var item in EnvReader.Load(stream))
        {
            Data[item.Key] = item.Value;
        }
    }
}

Step 3: Create a Custom Configuration Source

Next, let's create a custom configuration source that will be used to add our EnvConfigurationProvider to the IConfigurationBuilder.

using Microsoft.Extensions.Configuration;

public class EnvConfigurationSource : FileConfigurationSource
{
    public override IConfigurationProvider Build(IConfigurationBuilder builder)
    {
        EnsureDefaults(builder);

        return new EnvConfigurationProvider(this);
    }
}

Step 4: Add Extension Method to `IConfigurationBuilder`

To make it easy to use our custom configuration provider, create a set of extension methods to register the EnvReader Provider.

To make registering easier, create extension methods in the namespace Microsoft.Extensions.Configuration

using Extensions.Configuration.EnvFile;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.FileProviders.Physical;
using System;

namespace Microsoft.Extensions.Configuration;

public static class EnvConfigurationExtensions
{
    public static IConfigurationBuilder AddEnvFile(
        this IConfigurationBuilder builder,
        string path = ".env",
        bool optional = false,
        bool reloadOnChange = true)
    {
        var fileProvider = new PhysicalFileProvider(AppContext.BaseDirectory, ExclusionFilters.Hidden | ExclusionFilters.System);
        return AddEnvFile(builder, path: path, optional: optional, reloadOnChange: reloadOnChange, provider: fileProvider);
    }

    public static IConfigurationBuilder AddEnvFile(
        this IConfigurationBuilder builder,
        IFileProvider provider,
        string path,
        bool optional,
        bool reloadOnChange)
    {
        if (builder == null)
            throw new ArgumentNullException(nameof(builder));

        if (string.IsNullOrEmpty(path))
            throw new ArgumentException("invalid path", nameof(path));

        return builder.AddEnvFile(s =>
        {
            s.FileProvider = provider;
            s.Path = path;
            s.Optional = optional;
            s.ReloadOnChange = reloadOnChange;
            s.ResolveFileProvider();
        });
    }

    public static IConfigurationBuilder AddEnvFile(
        this IConfigurationBuilder builder,
        Action<EnvConfigurationSource> configureSource)
        => builder.Add(configureSource);
}

Demonstration

Now that everything is set up, let's integrate it into an ASP.NET Core application.

In the Program.cs or Startup.cs, add the following code to include your .env file in the configuration.

var builder = WebApplication.CreateBuilder(args);

builder.Configuration.AddEnvFile();

var app = builder.Build();

app.MapGet("/", (IConfiguration configuration) =>
{
    // Access the environment variables
    string apiKey = configuration["API_KEY"] ?? throw new ArgumentException("Missing API_KEY env variable");
    string databaseUrl = configuration["DATABASE_URL"] ?? throw new ArgumentException("Missing DATABASE_URL env variable");
    string debug = configuration["DEBUG"] ?? throw new ArgumentException("Missing DEBUG env variable");

    // Output the values
    Console.WriteLine($"API Key: {apiKey}");
    Console.WriteLine($"Database URL: {databaseUrl}");
    Console.WriteLine($"Debug Mode: {debug}");

    return new { apiKey, databaseUrl, debug };
});

app.Run();

Run the application and we should see the result below.

Source Code

Source code available on Github repo.

GitHub - ricardodemauro/Rmauro.Extensions.Configuration.EnvFiles: https://github.com/ricardodemauro/Rmauro.Extensions.Configuration.EnvFiles

Conclusion

By extending IConfiguration with a custom configuration provider, you can easily manage environment variables from a .env file in your ASP.NET Core applications.

This approach keeps your configuration clean and organized, making it easier to handle different environments without hardcoding sensitive values.

Again, feel free to enhance this solution by adding features like default values, nested configuration, or more sophisticated parsing logic. Happy coding! 😎

The Strategy Design Pattern in C# Applications

Ricardo — Mon, 12 Aug 2024 17:09:24 +0000

The Strategy design pattern offers a powerful solution for making algorithms interchangeable within your applications. Let's cover C# application and implementation in this article.

By encapsulating related algorithms within a family and allowing them to be swapped seamlessly, this pattern enhances flexibility and maintainability.

In this post, we'll dive into the Strategy pattern, explore its key concepts, and implement a simple example in C#.

Understanding the Strategy Pattern

The Strategy pattern is a behavioral design pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the algorithm to vary independently from the clients that use it.

Key Components

Strategy Interface : A common interface for all supported algorithms.
Concrete Strategies : Implementations of the strategy interface with specific algorithms.
Context : Maintains a reference to a strategy object and allows clients to set or change the strategy at runtime.

Implementing the Strategy Pattern in C

Let's implement the Strategy pattern with a simple example of sorting algorithms.

1. Define the Strategy Interface

First, we define an interface that all sorting strategies will implement:

public interface ISortStrategy
{
    void Sort(List<int> list);
}

2. Implement Concrete Strategies

Next, we create concrete classes that implement the sorting algorithms:

BubbleSortStrategy

public class BubbleSortStrategy : ISortStrategy
{
    public void Sort(List<int> list)
    {
        for (int i = 0; i < list.Count - 1; i++)
        {
            for (int j = 0; j < list.Count - i - 1; j++)
            {
                if (list[j] > list[j + 1])
                {
                    int temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
        }
    }
}

QuickSortStrategy

public class QuickSortStrategy : ISortStrategy
{
    public void Sort(List<int> list)
    {
        QuickSort(list, 0, list.Count - 1);
    }

    private void QuickSort(List<int> list, int low, int high)
    {
        if (low < high)
        {
            int pi = Partition(list, low, high);
            QuickSort(list, low, pi - 1);
            QuickSort(list, pi + 1, high);
        }
    }

    private int Partition(List<int> list, int low, int high)
    {
        int pivot = list[high];
        int i = (low - 1);

        for (int j = low; j < high; j++)
        {
            if (list[j] <= pivot)
            {
                i++;
                int temp = list[i];
                list[i] = list[j];
                list[j] = temp;
            }
        }

        int temp1 = list[i + 1];
        list[i + 1] = list[high];
        list[high] = temp1;

        return i + 1;
    }
}

3. Create the Context Class

The context class maintains a reference to a strategy object and allows clients to change the strategy:

public class SortContext
{
    private ISortStrategy _sortStrategy;

    public SortContext(ISortStrategy sortStrategy)
    {
        _sortStrategy = sortStrategy;
    }

    public void SetStrategy(ISortStrategy sortStrategy)
    {
        _sortStrategy = sortStrategy;
    }

    public void Sort(List<int> list)
    {
        _sortStrategy.Sort(list);
    }
}

4. Using the Strategy Pattern

Finally, we use the context class to apply different sorting strategies:

class Program
{
    static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 34, 7, 23, 32, 5, 62 };

        // Use BubbleSort strategy
        SortContext context = new SortContext(new BubbleSortStrategy());
        context.Sort(numbers);
        Console.WriteLine("Bubble Sorted List: " + string.Join(", ", numbers));

        // Change to QuickSort strategy
        context.SetStrategy(new QuickSortStrategy());
        numbers = new List<int> { 34, 7, 23, 32, 5, 62 }; // Reset the list
        context.Sort(numbers);
        Console.WriteLine("Quick Sorted List: " + string.Join(", ", numbers));
    }
}

Conclusion

The Strategy design pattern in C# provides a robust framework for creating interchangeable algorithms, promoting flexibility and maintainability in your applications.

By encapsulating each algorithm within its own class and using a common interface, the Strategy pattern adheres to the open/closed principle, making it easier to introduce new algorithms without modifying existing code. Embrace the Strategy pattern to enhance your software development practices and build more adaptable systems.

For more detailed articles and hands-on tutorials on .NET and C#, check out my blog at rmauro.dev.

Reading .env Files in C#

Ricardo — Fri, 09 Aug 2024 14:49:06 +0000

In C#, managing application configuration using environment variables stored in a .env file is a best practice, especially for handling different environments like development, staging, and production.

A .env file is a convenient way to store these variables locally during development.

In this post, let's check how to read a .env file in a C# application without relying on any third-party libraries. In Fact it's pretty simple to do.

Why Use a .env File?

A .env file contains key-value pairs representing environment variables.

It helps in keeping configuration separate from the codebase and is especially useful for.

Security: Sensitive information like API keys can be excluded from the codebase.
Consistency: Ensures that configuration is consistent across different environments.
Convenience: Easy to switch between different configurations during development.

Setting Up the Project

Let's start with a simple .NET console application.

dotnet new console -n EnvReaderApp
cd EnvReaderApp

Create a .env file in the root of your project directory.

# .env
API_KEY=12345
DATABASE_URL=localhost:5432
DEBUG=true

Implementing the .env File Reader

Let's implement a simple parser that reads the .env file and sets the variables as environment variables in the application.

using System;
using System.IO;

class EnvReader
{
    public static void Load(string filePath)
    {
        if (!File.Exists(filePath))
            throw new FileNotFoundException($"The file '{filePath}' does not exist.");

        foreach (var line in File.ReadAllLines(filePath))
        {
            if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
                continue; // Skip empty lines and comments

            var parts = line.Split('=', 2);
            if (parts.Length != 2)
                continue; // Skip lines that are not key-value pairs

            var key = parts[0].Trim();
            var value = parts[1].Trim();
            Environment.SetEnvironmentVariable(key, value);
        }
    }
}

Let's use the EnvReader in our project.

static void Main(string[] args)
{
    // Load environment variables from .env file
    EnvReader.Load(".env");

    // Access the environment variables
    string apiKey = Environment.GetEnvironmentVariable("API_KEY");
    string databaseUrl = Environment.GetEnvironmentVariable("DATABASE_URL");
    string debug = Environment.GetEnvironmentVariable("DEBUG");

    // Output the values
    Console.WriteLine($"API Key: {apiKey}");
    Console.WriteLine($"Database URL: {databaseUrl}");
    Console.WriteLine($"Debug Mode: {debug}");

    // Check if debug mode is enabled
    if (bool.TryParse(debug, out bool isDebug) && isDebug)
    {
        Console.WriteLine("Debug mode is enabled.");
    }
    else
    {
        Console.WriteLine("Debug mode is not enabled.");
    }
}

How It Works

Reading the .env File: The Load method reads all lines from the .env file.
Processing Each Line: It skips empty lines and comments, splits the line into key and value, and sets them as environment variables using Environment.SetEnvironmentVariable.
Using Environment Variables: The Main method demonstrates accessing these variables and using them in the application logic.

Best Practices

Security: Add the .env file to your .gitignore file to avoid committing sensitive information.
Template Files: Use a .env.example file with placeholder values to share configuration requirements without exposing sensitive data.
Error Handling: Implement robust error handling for scenarios like missing files or incorrect formats.

Conclusion

Reading a .env file in C# without third-party libraries is straightforward and allows you to manage configuration securely and efficiently.

This approach gives you complete control over how you handle and parse environment variables, which can be tailored to fit specific needs or constraints.

Feel free to enhance this solution by adding features like default values, nested configuration, or more sophisticated parsing logic. Happy coding! 😎

DEV Community: Ricardo

Logging Performance Improvements with Source Generators in C# .NET

Logging with Source Generators

Setting Up Source-Generated Logging

Using the Generated Logging Methods

Behind the Scenes: The Generated Code

Improvements and Benefits

Practical Tips

Keeping Organized

Conclusion

Make Your Machine Talk: Piper TTS Offline

What You’ll Need

Install Piper Using pip

Add a Voice

Try It Out

Option 1: Save to file and play

Option 2: Stream directly to aplay

Use a GPU (Optional)

Fine-Tune the Voice (Optional)

Wrap Up

Run Docker on WSL2 Without Docker Desktop 🐳

Prerequisites ✅

Install Docker (Inside WSL2) 🔧

🛠️ Running Docker Without SUDO

🚀 Wrapping up

⚙️ Optional: Auto-Start Docker on WSL Launch

Configuring Docker: Daemon Settings + Log Rotation

🛠️ Common Issues

✅ Summary

Running llama.cpp in Docker on Raspberry Pi

Dockerfile

Build the Docker Image

Download a Quantized Model (on Host)

Run Inference from Docker

Conclusion

Running LLM llama.cpp Bare Metal on Raspberry Pi

Prerequisites

Hardware

Software

Step-by-Step Guide

Install required tools

Clone and Build llama.cpp

Download a Quantized Model

4. Run Inference

Optional: Python Bindings

Conclusion

Building Your Own wc Tool in C# Code Challenge

Introduction

Step-by-Step Implementation

How It Works

Usage

Create an runnable executable

Special Mention

Conclusion

C# Enum Bitwise Operations

🧾 Introduction to Enums

Why Use Enums?

💪 Advanced Enum Usage: Bitwise Operations

Defining Flags Enum

Using Bitwise Operations in C# Enums

Using HasFlag

Conclusion

Tips for Using Enums

References

Publish C# Project to Nuget.org

Prepare the Project for Packaging

Pack the NuGet Package

Auto Generate the Package on Build

Create a NuGet.org Account and Get an API Key

Generate an API Key

Publish to NuGet.org

Updating Your Package

Best Practices for Maintaining Your NuGet Package

Conclusion

Create and Configure a GitHub Codespace

🚀 Table of Contents

⌚ Before You Start - Mind the Costs

🔨 Step by Step Guide

Step 1: Create a GitHub Codespace

Step 2: Select a Pre-Build Configuration

Option 2: Stream directly to `aplay`

Step 1: Set Up the `EnvReader` Class

Step 4: Add Extension Method to `IConfigurationBuilder`