Forem: Mariem Moalla

Understanding Span in C#

Mariem Moalla — Thu, 13 Nov 2025 07:32:06 +0000

If you have ever worked with strings, or arrays in C#, you have probably seen code that copies data more times than needed.

Extra copying increases memory usage and hurts performance. Modern applications handle large data streams, buffers, network packets, and processing pipelines, so controlling allocations matters.

Spans, gives you a safe view over existing memory without allocating new memory.

What Is Span?

Span, is a value type that enables the representation of contiguous regions of arbitrary memory.

It does not allocate memory.
It is stack-only
It works with arrays, strings, stack memory, and unmanaged memory.
It supports slicing without copying data.

A Simple Example

Without Span (Traditional Approach)

If you wanted elements 3, 4, 5 from the array before Span existed, you would usually write:

int[] numbers = { 1, 2, 3, 4, 5, 6 };

// We want { 3, 4, 5 }
int[] slice = new int[3];

for (int i = 0; i < 3; i++)
    slice[i] = numbers[i + 2];

foreach (var x in slice)
    Console.WriteLine(x);

What happens here?

A new array is created.

The values {3, 4, 5} are copied into it.

That means extra memory + extra CPU work.

This is called allocation, and allocations in .NET always go to the managed heap, which:

Takes space, thus increases memory usage.

Causes garbage collection to run more often, thus affects performance.

With Span (Zero Allocation Approach)

int[] numbers = { 1, 2, 3, 4, 5, 6 };

// Create a span over the array
Span<int> span = numbers;

// Slice the span (no copying)
Span<int> slice = span.Slice(2, 3);

foreach (var x in slice)
    Console.WriteLine(x);

What happens now?

Slice does not create a new array.
It points directly to part of the existing array.
No integers are copied.
No new memory is allocated.

But be careful, any changes made to Span slice it will be also made in created array since we are pointing to it in the first place.

Visually

slice is simply a window over the existing data.

Working With Strings Using ReadOnlySpan
Strings are immutable. If you split or substring, you usually create new strings.

Example

string text = "HelloWorld";
string part = text.Substring(5); // Allocates a new string
Using spans

ReadOnlySpan<char> span = text;
ReadOnlySpan<char> partSpan = span.Slice(5);

No allocation. Very helpful when parsing large text.

Real Use Case: Parsing Numbers

string input = "12345";
ReadOnlySpan<char> span = input;

int result = int.Parse(span); // Works directly with ReadOnlySpan
Console.WriteLine(result); // 12345

No intermediate string allocations.

Important Constraint: Span Is Stack Only

You cannot do this:

class Test
{
    private Span<int> field; // Not allowed
}

Because Span may refer to stack memory which would be unsafe if stored beyond the current scope. This is a deliberate safety guarantee.

If you need something similar that can live on the heap, use Memory or ReadOnlyMemory.

What you need to know about Extension Members in C#

Mariem Moalla — Tue, 11 Nov 2025 11:11:14 +0000

Extension methods have been around in C# for a long time. They allow you to add new methods to existing types without modifying their source code. This is very useful when working with types from frameworks or libraries you do not own.

However, extension methods have one annoyance: every method must be defined in a static class, and each method must declare the first parameter with the this modifier. When you write several extension methods for the same type, your code starts to feel repetitive.

Extension Members, were introduced to solve this problem by allowing you to group extension methods inside an extension block tied to a specific type.

What Are Extension Members?

Extension members let you define an extension scope like this:

extension System.String
{
    // instance extension
    int WordCount() => this.Split(' ').Length;

    // static extension
    static bool IsNullOrEmpty(string? value) => string.IsNullOrEmpty(value);
}

Before vs After

Before(Classic Extension Methods)

public static class StringExtensions
{
    public static int WordCount(this string text)
    {
        return text.Split(' ').Length;
    }
}

After(Extension Block)

extension System.String
{
    int WordCount() => this.Split(' ').Length;
}

Example

extension System.String
{
    bool IsLong() => this.Length > 20;
    static string? EmptyIfNull(string? value) => value ?? string.Empty;
}

Usage

string message = "Hello World";
bool isLong = message.IsLong();
string result = string.EmptyIfNull(null);

Extension Members Priority Rule

Extension members are always lower priority than the type's existing members. Meaning: if the type already defines a method with the same name, the type's method is used.

Example

extension System.String
{
    string ToUpper() => "Extension ToUpper called";
}

var text = "hello";
Console.WriteLine(text.ToUpper());

Output

HELLO
=> The built-in string.ToUpper() wins.

Extension Members in C# 14 – What Changed?

C# 13 introduced the extension block, which allows you to define methods and static helpers on existing types more naturally. C# 14 takes this further by allowing you to define more kinds of members, not just methods.

Example: Extension Property (C# 14)

extension System.String
{
    int WordCount => this.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
}

Usage

string text = "Hello world from C#";
Console.WriteLine(text.WordCount); // 4

No parentheses. It behaves exactly like a read-only property.

Example: Extension Indexer (C# 14)

extension System.String
{
    char this[Index index] => this[index];
}

Usage

string s = "Hello";
Console.WriteLine(s[^1]); // o

This allows idiomatic slicing without writing your own helper code.

C# tips: string.IsNullOrEmpty vs string.IsNullOrWhiteSpace

Mariem Moalla — Fri, 03 Oct 2025 10:45:37 +0000

When working with text in .NET, one of the most common checks we perform is:
“Does this string have a meaningful value, or is it just empty/null?”

Two helpers exist for this purpose:

string.IsNullOrEmpty
string.IsNullOrWhiteSpace At first glance, they may seem similar, but there’s an important distinction that can save you from getting bugs.

Using string.IsNullOrEmpty

This method checks if a string is either:

null
"" (an empty string)

Console.WriteLine(string.IsNullOrEmpty(null));   // true
Console.WriteLine(string.IsNullOrEmpty(""));     // true
Console.WriteLine(string.IsNullOrEmpty("   "));  // false
Console.WriteLine(string.IsNullOrEmpty("abc"));  // false

Notice that " " (spaces only) returns false.
This means IsNullOrEmpty only guards against null or empty strings, not whitespace.

Using string.IsNullOrWhiteSpace

This method goes one step further: it considers whitespace-only strings as invalid.

Console.WriteLine(string.IsNullOrWhiteSpace(null));   // true
Console.WriteLine(string.IsNullOrWhiteSpace(""));     // true
Console.WriteLine(string.IsNullOrWhiteSpace("   "));  // true
Console.WriteLine(string.IsNullOrWhiteSpace("abc"));  // false

Here, " " returns true because the method trims out whitespace and checks for emptiness.

Performance Consideration

Both methods are O(n) because they may scan characters (especially IsNullOrWhiteSpace).

IsNullOrEmpty is slightly faster since it only checks length.
IsNullOrWhiteSpace is marginally slower but usually negligible in real-world apps.

For example:

var str = new string(' ', 1000); // 1000 spaces

Console.WriteLine(string.IsNullOrEmpty(str));     // false
Console.WriteLine(string.IsNullOrWhiteSpace(str)); // true

The performance difference only matters when doing millions of checks per second, which is rare in typical business applications.

C# Tip: Use Stack, Not List

Mariem Moalla — Thu, 02 Oct 2025 08:25:15 +0000

When working with collections in C#, it’s tempting to use a List for everything. After all, it’s flexible, efficient, and familiar.

But when your use case revolves around pushing and popping elements (Last-In, First-Out behavior), Stack is the better choice.

The Common Misuse of List

Many developers implement stack-like behavior with a List :

var list = new List<int>();
// Push
list.Add(10);
list.Add(20);
// Peek             
int value = list[^1];
// Pop
list.RemoveAt(list.Count - 1);

It works, but it’s not optimal:

You’re relying on RemoveAt, which isn’t semantically clear.
There’s more room for mistakes (like forgetting to use the last index).
List is optimized for random access, not stack-like behavior.

A better example if we have the following code

var value = list[^1];          
list.RemoveAt(list.Count - 1);

If you accidentally do list.RemoveAt(0) , you just killed the wrong element (and it’s O(n) because it shifts the entire array).

The element at List[0] is discarded. But now, everything after it must shift left by one to fill the gap

Before: [ A, B, C, D ]
RemoveAt(0)
After:  [ B, C, D, _ ]

The Right Tool Stack

What is a stack ?

A Stack in C# is a Last-In, First-Out (LIFO) collection.
Think of it like a stack of plates:

You add a plate on top (push)
You look at the top plate (Peek)
You remove the top plate (Pop)

The last item you put in is the first one that comes out.

var stack = new Stack<int>();
// Push
tack.Push(10);   
stack.Push(20);   
// Peek
int value = stack.Peek(); 
// Pop
stack.Pop();

Time Complexity of Operations

Push → O(1)
Adds an item on top of the stack.

Peek → O(1)
Reads the top item without removing it.

Pop → O(1)
Removes the top item.

All these are O(1) operations, unlike List where removing at the wrong index can be O(n) because of shifting.

All you need to know about switch expression and Modern Pattern Matching

Mariem Moalla — Mon, 22 Sep 2025 09:10:35 +0000

The switch statement has been part of C# since day one.

But over time, it has evolved into a powerful tool for pattern matching.

In this article, we'll look at how the switch statement has changed, and see why the modern switch is more useful.

The Traditional switch

The classic switch has been around since C# 1.0 .
It only worked on constants (int, char, enums, strings).
Each case needed a break (or return).

Example:

public string GetColor(Color c)
{
    switch (c)
    {
        case Color.Red:
        case Color.Blue:
        case Color.Yellow:
            return "Primary Colors";

        default:
            return "Other";
    }
}

Modern switch with Pattern Matching

Starting with C# 7.0, the switch statement gained pattern matching. Later releases expanded it:

Type patterns, constant patterns, when clauses.
Switch expressions + property/tuple patterns.
Relational (>, <, >=, <=) and logical (and, or, not) patterns.

Type patterns

Example:

object value = 42;

string result = value switch
{
    int n => $"Integer: {n}",
    string s => $"String: {s}",
    null => "Null value",
    _ => "Unknown type"
};

Relational Patterns:

This switch expression is used to compare an expression result with a constant, as the following example shows:

int score = 85;

string grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};
In a relational pattern we can use the relational operators <, >, <=, or >=.

Positional pattern:

Can be used to deconstruct a result and match it vales as the following example:

(int x, int y) point = (5, -3);

string position = point switch
{
    (0, 0) => "Origin",
    ( > 0, > 0) => "Quadrant I",
    ( < 0, > 0) => "Quadrant II",
    ( < 0, < 0) => "Quadrant III",
    ( > 0, < 0) => "Quadrant IV",
    _ => "On axis"
};

There still exists many other patterns present in the documentation, each can be served and used in a specific situation, more specific than the general cases we encounter.

C# Performance Hack: Use record struct for Small, Immutable Models

Mariem Moalla — Wed, 17 Sep 2025 06:51:45 +0000

When designing data models in C#, the choice between class, struct, and record, can significantly impact performance, and memory usage.

But what makes record struct such a good fit for lightweight models compared to classes?

Classes: The Default Choice

By default, most developers reach for class. Classes are reference types:

They live on the heap.
Variables hold references (pointers) to objects.
Garbage Collection (GC) must clean them up when no longer used.

Advantage: Good for large, complex objects that are shared or mutated.
Disadvantage: Overkill for small, short-lived, immutable data models.

Structs

A struct is a value type:

Allocated on the stack.
Copied by value, not reference.
Faster for small, short-lived objects.
No GC overhead for stack allocations.

Advantage: Ideal for lightweight data carriers.
Disadvantage: But normal struct lacks the immutability and equality benefits of record.

Records

A reference type.
Record classes behave similarly to regular classes in terms of memory allocation (on the heap) and assignment (reference copying).
Value-based equality (== compares properties, not references).

public record Point(int X, int Y);

var p1 = new Point(5, 10);
var p2 = new Point(5, 10);
var p3 = new Point(10, 20);

Console.WriteLine(p1 == p2); // True (same values)
Console.WriteLine(p1 == p3); // False (different values)

// For classes:
public class PointClass
{
    public int X { get; init; }
    public int Y { get; init; }
}

var c1 = new PointClass { X = 5, Y = 10 };
var c2 = new PointClass { X = 5, Y = 10 };

Console.WriteLine(c1 == c2); // False (different references)
Record Struct : The Best of Both Worlds
Combines the performance of a struct (stack-allocated, lightweight).
With the features of a record (immutability, value equality, with expressions).
public readonly record struct Point(int X, int Y);

var p1 = new Point(10, 20);
var p2 = new Point(10, 20);

// Value equality
Console.WriteLine(p1 == p2); // True

// With-expression works
var p3 = p1 with { X = 30 };

Console.WriteLine(p3); // Point { X = 30, Y = 20 }

This makes record struct perfect for lightweight models.

When to Use Record Struct

Use record struct when:

You need small, immutable, value-like models.
You care about low memory and avoiding heap/GC overhead.

Stick to class when:

Objects are large, complex, or mutable.
You need shared instances.

How Async/Await Really Works in C# : A Beginner-Friendly Guide

Mariem Moalla — Tue, 09 Sep 2025 08:01:43 +0000

If you’re new to C#, you’ve probably seen async and await in modern code and asked along the way:

What do they actually do?
Do they create new threads?
Why do we even need them?

Let’s break it down in simple terms.

What is Asynchronous Programming?

Normally, C# code runs synchronously => one line after another.

var data = GetData();
ProcessData(data);
ShowResult();

If GetData() takes 5 seconds, everything else waits until it finishes, which can make your app feel frozen.

Asynchronous programming lets you say => Finish this work in the background, and when you’re done, come back and tell me.

That way, the app can keep responding while waiting for slow operations (like API calls, file I/O, or database queries).

What is a Task?

In C#, a Task is like a promise of a future operation.

A Task means “I’ll give you an integer… later.”
A Task (without type) means “I’ll finish some work… later.”

Example

public Task<int> GetNumberAsync()
{
    return Task.Run(() =>
    {
        Thread.Sleep(1000);
        return 42;
    });
}

=> When you call getNumberAsync(), you don’t immediately get 42. You get a Task that will eventually hold 42.

What does `async` Do in this case?

The async keyword marks a method as asynchronous. It allows you to use the await keyword inside it, in other word it let you call asynchronous methods inside the code in case some results are needed to continue proceeding.

public async Task<int> GetNumberAsync()
{
    await Task.Delay(1000);
    return 42;
}

Here, await task.Delay(1000) says: “Pause here, let other code run, and come back after 1 second.”

What Does `await` Do?

await is the magic word. It tells C#: “Stop here until the Task finishes, but don’t block the thread. Let other work continue in the meantime.”

public async Task RunAsync()
{
    Console.WriteLine("Starting...");
    var result = await GetNumberAsync();
    Console.WriteLine($"Result: {result}");
}

// #output#
// Starting...
// (1-second pause)
// Result: 42

=> Without await, you’d just get a Task object, not the result.

Async/Await and Threads

This is where many beginners get stuck:

Does async / await create new threads?
Is it multithreading?

=> The short answer: No, not directly.

async / await is about asynchronous work, not about creating threads.

Most async operations (like reading a file, calling a web API, or writing to a database) use OS features that don’t need a dedicated thread while waiting.

If you really want a new thread, you use for example Task.Run().

Example

public async Task FetchAndShowDataAsync()
{
    Console.WriteLine("Fetching...");
    var data = await GetDataFromApiAsync(); // does not block
    Console.WriteLine($"Got: {data}");
}

Even if the API takes 2 seconds, your app doesn’t block; it can still handle user input, process other tasks, or serve requests.

Why ValueTask Can Save You from Async Overhead

Mariem Moalla — Thu, 04 Sep 2025 12:51:59 +0000

Asynchronous programming in C# is built on top of the Task and async/await model. For most scenarios, using Task is perfectly fine. But if you’re writing high-performance code, you’ve probably heard about ValueTask.

So, when should you use ValueTask instead of Task? Let’s break it down.

This is highly related to memory allocation so lets always try to see it from this perspective.

What is Task?

Tasks represent a promise of an operation that will eventually complete.It encapsulate the operation that can be executed independently on a different thread from the one that initialized it.
Let’s understand how tasks works with allocation.

Case 1 : Task Synchronous Completion

If your method completes synchronously (returns immediately without awaiting anything), the compiler/runtime still has to return a Task object.

(Usually, it uses a cached instance like Task.FromResult(value))

Note: This still creates or reuses a heap-allocated Task object.

public Task<int> GetNumberTask(bool cached)
{
    if (cached)
        return Task.FromResult(42); // allocation (cached instance but still a heap object)
    return DoRealWorkAsync();
}

So Even if the value is already known (42), you pay the allocation cost for a Task object. even though int is value type.

And even if the result is already known immediately, the runtime must return a Task instance.

Case 2 : Task Asynchronous Completion

When the method awaits something:

The compiler generates an async struct that tracks the execution.
An it is boxed and tied to a an object to represent the ongoing work.
A new heap-allocated Task is created for the async result.

public async Task<int> GetNumberTaskAsync() 
{     
await Task.Delay(100);  // async suspension point     
return 42; 
}

=> Async completion always involves allocations. synchronous may not.

What is ValueTask?

This is where ValueTask saves the day.Introduced in .NET Core 2.0 to reduce allocation overhead.A struct is designed to optimize asynchronous operations.

Unlike Tasks, Value tasks is a value type meaning we can avoid heap allocation when operation complete synchronously

Case 1 : Synchronous Completion

If you already know the result, the value is stored directly in the ValueTask struct.
No heap allocation occurs.

public ValueTask<int> GetNumberValueTaskSync()
{
    return new ValueTask<int>(42); // Value stored inline, no heap
}

Case 2 : Asynchronous Completion:

If the method actually awaits something:

ValueTask internally wraps a Task.
That means you still get heap allocations, just like with Task.

public async ValueTask<int> GetNumberValueTaskAsync()
{
    await Task.Delay(100);   // async suspension point
    return 42;
}

Here the benchmarking results can show clearly the difference between using ValueTask and Task in Synchronous completion.

Why this really matter as a .NET developper?

Understanding the difference between Task and ValueTask is crucial when writing high-performance asynchronous code in C#.

Task is simple and reliable, but even for synchronous completions, it may incur heap allocations. This overhead is usually negligible, but in tight loops or performance-critical paths, it can add up.
ValueTask shines in scenarios where the result is often already available synchronously. Since it’s a struct, it can store the result inline and avoid heap allocations, reducing GC pressure.

However, when an operation truly requires asynchronous execution, ValueTask internally wraps a Task anyway, so the allocation difference disappears.

By carefully choosing between Task and ValueTask, you can write cleaner, faster, and more memory-efficient async code especially in performance-critical applications.

SQL Server Index Fragmentation: What It Is and How to Fix

Mariem Moalla — Wed, 20 Aug 2025 08:00:00 +0000

Many developers and DBAs encounter the term index fragmentation, and some have struggled with its consequences while building and maintaining databases throughout an application's lifecycle.

In this article, we'll go step-by-step to understand:

What index fragmentation is
When and why it happens
The different types (internal vs external)
How to avoid it, and fix it

1 - Quick Recap: What is an Index?

An index is a data structure that helps locate specific rows quickly.

It works by storing sorted values from one or more columns of a table, along with pointers to the corresponding rows.

In SQL Server, data is stored in pages, fixed-size blocks (typically 8KB each).

When the database needs to read data, it loads an entire page into memory.

This is more efficient than fetching single rows, as it reduces disk I/O.

When a query is executed:

SQL Server checks if an index exists for the queried columns.
If it exists, SQL Server uses it to locate the relevant pages.
Only those specific pages are read, instead of scanning the whole table.

2 - What is Index Fragmentation?

Index fragmentation occurs when the logical order of data in an index does not match the physical storage order.

Logical Order: An index is designed to provide a quick lookup for data based on specific key values. Ideally, the data within the index pages should be stored in a contiguous, ordered manner based on these key values.
Physical Order: How pages are actually stored on disk.

When these orders are out of sync, SQL Server has to jump around more, increasing I/O and slowing queries.

Example scenario:

You insert new rows into a table with a clustered index.
SQL Server tries to keep them in order by key.
If the target page is full, SQL Server splits the page into two, moving some rows to the new page.
Now the physical page order may no longer match the logical order.

Internal vs External Fragmentation

There are two main types of fragmentation:

Internal Fragmentation

Occurs inside pages.
Pages are only partially filled, leaving empty space.
Often happens after deletes or updates that shrink data.
Leads to wasted space and more pages to scan.

External Fragmentation

Occurs when the order of pages no longer matches their logical sequence.
Caused by page splits that scatter data across the file.
Leads to more random I/O.

Example:

- Logical Order: `Page 100 → Page 101 → Page 102`
- Physical Order: `Page 100 → Page 300 → Page 101 → Page 500 → Page 102`

Why Does It Matter?

Fragmentation increases:

I/O operations (more pages read)
CPU usage (more pointer lookups)
Query execution time

Especially in large datasets, even small increases in page reads can cause significant slowdowns.

4 - How to Fix Fragmentation

REORGANIZE

Defragments the index by physically reordering leaf pages. Lightweight, online.

ALTER INDEX IndexName ON TableName REORGANIZE;

REBUILD

Drops and recreates the index. Removes all fragmentation. Can be offline or online (Enterprise Edition).

ALTER INDEX IndexName ON TableName REBUILD WITH (FILLFACTOR = 80);

*Important Note
*
Microsoft recommends:

<5% fragmentation → No action needed.
5–30% fragmentation → REORGANIZE.
>30% fragmentation → REBUILD.

By following these guidelines, you can keep your SQL Server indexes healthy and your queries fast.

When to Use Generic vs Non-Generic Collections in C#

Mariem Moalla — Sat, 16 Aug 2025 15:10:28 +0000

Collections are a fundamental part of any application that manages data. In C#, you have two primary options for working with collections: generic and non-generic.
But what exactly are they, and when should you use one over the other?
In this article, we'll break down the key differences between the two, highlight their impact on performance and usability.

What Are Collections in C#?

Collections are classes used to store, manage, and manipulate groups of related objects.
These collections fall into two categories:

Generic Collections
Non-Generic Collections

Generic Collections

Type-Safe by Design
Generic collections require you to define the type of data they will hold. For example, List will only accept integers.
This ensures:

No accidental data type mismatches
No need for casting

Better Performance
Since there's no need for boxing/unboxing (converting value types to/from object), generic collections perform faster and use memory more efficiently.

Common Generic Collections

List<string> names = new List<string>(); 
Dictionary<int, string> studentMap = new Dictionary<int, string>();
Queue<double> prices = new Queue<double>(); 
HashSet<Guid> uniqueIds = new HashSet<Guid>();

Non-Generic Collections

Object-Based Storage
Non-generic collections store data as object, which leads to the need for casting when retrieving data.
This can result in:

Runtime errors if the cast is incorrect
Lower performance due to boxing/unboxing

Common Non-Generic Collections

ArrayList items = new ArrayList();
items.Add(42);
items.Add("hello"); // Works, but can cause issues later
Hashtable map = new Hashtable();
map["id"] = 1;
map["name"] = "Alice";

Performance Comparison

When you work with large amounts of data, the cost of boxing/unboxing and casting becomes significant.
Example:

ArrayList list = new ArrayList();
// Value type is boxed
list.Add(1); 
// Unboxed and cast manually
int number = (int)list[0];

List<int> list = new List<int>();
// No boxing required
list.Add(1); 
// Clean and safe
int number = list[0];

Benchmarking

These are benchmarking result of adding, and iterate throw elements for both type of collections.

Conclusion

Generic collections are the default choice for modern .NET development providing type safety, clarity, and performance. Non-generic collections still exist for backward compatibility but are largely obsolete for most use cases.
Choose wisely and your application will thank you with fewer bugs and better performance.

Structured Logging in .NET: Why You Should Avoid String Interpolation

Mariem Moalla — Wed, 13 Aug 2025 06:12:00 +0000

It's easy to overlook how small differences in logging syntax can affect performance, log structure, and searchability.

Take this innocent-looking log:

// Logging with String Concatenation
logger.LogInformation("Hello " + name);
// Logging with String Interpolation
logger.LogInformation($"Hello {name}");
// Structured Logging
logger.LogInformation("Hello {Name}", name);

They all seem to do the same thing, right?

Well… not quite. Let's dive into what really sets them apart and why you should care.

1. Logging with String Concatenation:

This method involves building log messages by explicitly joining strings and variable values using concatenation operators.

string user = "Alice";
int id = 123;
logger.LogInformation("User " + user + " with ID " + id + " logged in.");

Drawbacks:

You lose the ability to parse or query name as a separate field in structured log systems.
Performance hit, even if logging is disabled at Information level, the string is still evaluated in memory.

2. Logging with String Interpolation:

String interpolation provides a more concise and readable syntax for embedding expressions.

string user = "Bob";
int id = 456;
logger.LogInformation($"User {user} with ID {id} logged in.");

Drawbacks: while more readable than concatenation,

The interpolated message is still passed as a single string.
The string is formatted in memory regardless of the logging level.

3. Structured Logging:

Structured logging involves emitting log data in a predefined, machine-readable format like JSON, key-value pairs, rather than plain text.

It separates the log message template from the dynamic data, allowing for richer querying and analysis. example.

string user = "Charlie";
int id = 789;
logger.LogInformation("User {UserName} with ID {UserId} logged in.", user, id);

Advantages:

Log data can be easily queried and filtered based on specific fields.
Enables efficient ingestion and processing by log aggregation and analysis tools like Serilog and Seq will extract {Name} as a named field.
Parameters are only processed if the log level is enabled.

Benchmarking results:

Modern .NET logging is more than just writing strings to the console. If you're using tools like Seq, structured logging unlocks their full power, better filtering, alerting, and dashboards.
So the next time you're tempted to log like this:

logger.LogInformation("User logged in: " + userId);

…try this instead:

logger.LogInformation("User logged in: {UserId}", userId);

Your future self , and your DevOps team, will thank you

Everything You Need to Know About Minimal APIs in .NET

Mariem Moalla — Mon, 11 Aug 2025 06:29:00 +0000

Minimal APIs are a lightweight way to build HTTP APIs in .NET with minimal ceremony. Introduced in .NET 6, they focus on simplicity, and performance.
Minimal APIs eliminate the complexity of traditional ASP.NET Core MVC. No controllers, no heavy configuration.

Why Choose Minimal APIs?

Efficiency: Achieve more with less code .
High Performance: Lightweight and optimized for fast execution.
Beginner-Friendly: Minimal APIs are easy to learn and implement, especially for those new to .NET.
Flexible & Scalable: Don't be fooled by the name, Minimal APIs can power everything from microservices to enterprise-grade systems.

Build a Minimal API Project from Scratch

Let's walk through creating a Minimal API using the .NET CLI or Visual Studio.

Step 1: Create the Project

dotnet new web -n MinimalApiDemo
cd MinimalApiDemo
start MinimalApiDemo.sln

Step 2: Add Your First Endpoint

A typical start can be as always, a hello world project

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello from Minimal API!");

app.Run();

Run the app:

dotnet run

Navigate to https://localhost:5001/ and you'll see the response:
"Hello from Minimal API!"

Step 3: Adding models and services

Now let's go ahead and make our project more like a real project starting by
Create the Product model Models/Product.cs

namespace ProductApi.Models;

public class Product
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

Create a file: Services/IProductService.cs

using ProductApi.Models;

namespace ProductApi.Services;

public interface IProductService
{
    IEnumerable<Product> GetAll();
    Product? GetById(Guid id);
    Product Create(Product product);
    bool Delete(Guid id);
    Product? Update(Guid id, Product updatedProduct);
}

Now create the implementation in Services/ProductService.cs:

using ProductApi.Models;

namespace ProductApi.Services;

public class ProductService : IProductService
{
    private readonly List<Product> _products = new();

    public IEnumerable<Product> GetAll() => _products;

    public Product? GetById(Guid id) =>
        _products.FirstOrDefault(p => p.Id == id);

    public Product Create(Product product)
    {
        _products.Add(product);
        return product;
    }

    public bool Delete(Guid id)
    {
        var product = GetById(id);
        if (product == null) return false;
        _products.Remove(product);
        return true;
    }

    public Product? Update(Guid id, Product updatedProduct)
    {
        var product = GetById(id);
        if (product == null) return null;

        product.Name = updatedProduct.Name;
        product.Price = updatedProduct.Price;
        return product;
    }
}

This project is too simple just to demonstrate the usage of minimal APIs thus no database configured.
Update your Program.csand register the service:

using ProductApi.Models;
using ProductApi.Services;

var builder = WebApplication.CreateBuilder(args);

// Add Swagger
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddSingleton<IProductService, ProductService>();

var app = builder.Build();

app.UseSwagger();
app.UseSwaggerUI();

// Routes
app.MapGet("/", () => "Product Minimal API Example");

app.MapGet("/products", (IProductService service) =>
{
    return Results.Ok(service.GetAll());
});

app.MapGet("/products/{id}", (Guid id, IProductService service) =>
{
    var product = service.GetById(id);
    return product is null ? Results.NotFound() : Results.Ok(product);
});

app.MapPost("/products", (Product product, IProductService service) =>
{
    var created = service.Create(product);
    return Results.Created($"/products/{created.Id}", created);
});

app.MapPut("/products/{id}", (Guid id, Product updated, IProductService service) =>
{
    var product = service.Update(id, updated);
    return product is null ? Results.NotFound() : Results.Ok(product);
});

app.MapDelete("/products/{id}", (Guid id, IProductService service) =>
{
    return service.Delete(id) ? Results.NoContent() : Results.NotFound();
});

app.Run();

Run the app

dotnet run

Now open your browser and go to: http://localhost:5000/swagger
You'll see a full Swagger UI with your Minimal API CRUD for Product.

Now seeing that the example is simple showing how we basically create a minimal API, a question may be asked here *How do Minimal APIs fit into a more complex, real-world architecture like DDD or Clean Architecture?
*
Great question, and yes, Minimal APIs can absolutely scale into complex, maintainable solutions. The trick is separating responsibilities properly and treating Minimal APIs purely as the transport layer, not the place for business logic.
Example: Clean Architecture + Minimal APIs
Here's a quick breakdown of how you could structure a real application using Clean Architecture with Minimal APIs:

/ProductApi
│── Program.cs
│── Endpoints (Minimal API endpoints)
│ └── ProductsEndpoint.cs
│── Application (Services / DTOs)
│ └── Interfaces
│ └── Services
│── Domain (Domain models, enums)
│ └── Entities
│── Infrastructure (DB context, repositories, external APIs)

Key Takeaways

Minimal APIs are not just for simple apps, they're flexible enough for complex architectures.
The key is to apply SOLID principles, layer separation, and dependency injection wisely.

Improved in .NET 7 and .NET 87
With newer versions of .NET, minimal APIs now support:

Request validation
OpenAPI/Swagger generation
Dependency injection
Route groups and filters
Authorization policies

Forem: Mariem Moalla

Understanding Span in C#

What Is Span?

Without Span (Traditional Approach)

With Span (Zero Allocation Approach)

What you need to know about Extension Members in C#

What Are Extension Members?

Before vs After

Extension Members Priority Rule

Extension Members in C# 14 – What Changed?

C# tips: string.IsNullOrEmpty vs string.IsNullOrWhiteSpace

Using string.IsNullOrEmpty

Using string.IsNullOrWhiteSpace

Performance Consideration

C# Tip: Use Stack, Not List

The Common Misuse of List

The Right Tool Stack

What is a stack ?

Time Complexity of Operations

All you need to know about switch expression and Modern Pattern Matching

The Traditional switch

Modern switch with Pattern Matching

Type patterns

Relational Patterns:

Positional pattern:

C# Performance Hack: Use record struct for Small, Immutable Models

Classes: The Default Choice

Structs

Records

How Async/Await Really Works in C# : A Beginner-Friendly Guide

What is Asynchronous Programming?

What is a Task?

What does async Do in this case?

What Does await Do?

Async/Await and Threads

Why ValueTask Can Save You from Async Overhead

What is Task?

Case 1 : Task Synchronous Completion

Case 2 : Task Asynchronous Completion

What is ValueTask?

Case 1 : Synchronous Completion

Case 2 : Asynchronous Completion:

Why this really matter as a .NET developper?

SQL Server Index Fragmentation: What It Is and How to Fix

1 - Quick Recap: What is an Index?

2 - What is Index Fragmentation?

Internal vs External Fragmentation

Internal Fragmentation

External Fragmentation

Why Does It Matter?

4 - How to Fix Fragmentation

REORGANIZE

REBUILD

When to Use Generic vs Non-Generic Collections in C#

What Are Collections in C#?

Generic Collections

Non-Generic Collections

Performance Comparison

Benchmarking

Conclusion

Structured Logging in .NET: Why You Should Avoid String Interpolation

1. Logging with String Concatenation:

2. Logging with String Interpolation:

3. Structured Logging:

Everything You Need to Know About Minimal APIs in .NET

Why Choose Minimal APIs?

Build a Minimal API Project from Scratch

Step 1: Create the Project

Step 2: Add Your First Endpoint

Step 3: Adding models and services

What does `async` Do in this case?

What Does `await` Do?