This article focuses exclusively on:

✅ String enums (or string-based enum patterns)
✅ How to retrieve their string values
✅ Compile-time vs runtime behavior

C# and “String Enums”

Important clarification: C# does not support true string-backed enums. All C# enums are backed by numeric types.

When we discuss “string enums” in C#, we’re actually referring to:

• Getting the enum name as a string
• Mapping enum values to custom string representations

1. Getting the Enum Name as a String

enum Status
{
    Pending,
    Approved,
    Rejected
}

Status status = Status.Approved;
string value = status.ToString();

Result: "Approved"

What happens:

• Compile time → Type safety enforced
• Runtime → String generated from enum metadata

This is the simplest and most common approach.

2. Getting the Name at Compile Time with nameof

When referencing a specific member directly:

string value = nameof(Status.Approved);

Result: "Approved"

Why this is powerful:

• Fully resolved at compile time
• Refactor-safe
• Zero runtime cost
• No reflection required

Important: nameof only works when referencing a known member—not with variables.

3. Custom String Values (Display Pattern)

Sometimes your API requires "waiting_for_approval" instead of "Pending".

Implementation using attributes:

using System.ComponentModel.DataAnnotations;

enum Status
{
    [Display(Name = "waiting_for_approval")]
    Pending,
    [Display(Name = "approved")]
    Approved
}

Extension method:

using System.Reflection;

public static class EnumExtensions
{
    public static string GetDisplayName(this Enum value)
    {
        var field = value.GetType().GetField(value.ToString());
        var attribute = field?.GetCustomAttribute<DisplayAttribute>();
        return attribute?.Name ?? value.ToString();
    }
}

Usage:

string value = status.GetDisplayName();

What happens:

• Compile time → Attribute defined
• Runtime → Reflection lookup

Use this when:

• API responses need controlled string formats
• Localization is required
• Internal naming differs from external representation

Caution: Avoid in performance-critical loops due to reflection overhead.

TypeScript: Real String Enums

Unlike C#, TypeScript supports true string-backed enums.

1. String Enum Definition

enum Status {
  Pending = "PENDING",
  Approved = "APPROVED",
  Rejected = "REJECTED"
}

This is a genuine string-backed enum.

2. Getting the Value

const status = Status.Approved;
console.log(status);

Output: "APPROVED"

No conversion needed — the value is already a string.

What Happens Internally

TypeScript compiles this to:

var Status;
(function (Status) {
  Status["Pending"] = "PENDING";
  Status["Approved"] = "APPROVED";
  Status["Rejected"] = "REJECTED";
})(Status || (Status = {}));

At runtime:

• Status is a JavaScript object
• Each member is a string property
• Access is simple property lookup

Compile Time vs Runtime (TypeScript)

Stage What Happens Compile time Type checking Build time Enum emitted as JS object Runtime Property access returns string

Key point: There’s no conversion happening. You’re simply retrieving a string property from an object.

Modern Alternative in TypeScript

Many teams now prefer this pattern:

const Status = {
  Pending: "PENDING",
  Approved: "APPROVED",
  Rejected: "REJECTED"
} as const;

type Status = typeof Status[keyof typeof Status];

Getting the value:

const status = Status.Approved;

Why this is popular:

• No special enum emission
• Cleaner JavaScript output
• Better tree shaking
• Fully type-safe

At runtime, this is simply a plain object.

C# vs TypeScript: String Behavior Comparison

Feature C# TypeScript True string-backed enum ❌ No ✅ Yes .ToString() needed ✅ Yes ❌ No Compile-time constant option nameof Direct member Runtime reflection needed For custom strings No Runtime overhead Minimal Object property lookup

Best Practice Summary

In C#

• Use .ToString() for simple string names
• Use nameof() when referencing known members at compile time
• Use attributes + extension methods for controlled API output
• Remember: C# enums are numeric under the hood

In TypeScript

• Use string enums when modeling domain values
• No conversion required — the value is already a string
• Prefer as const objects in modern frontend projects for better JavaScript output

Thanks for reading! 👏 If this helped clarify string enums for you, feel free to share it with your team. 🚀

The problem

Alright so at this point, I’m sure all of us know that NodeJS is single threaded but yet somehow it manages to handle hundreds of requests without using threads like Java or Python. How does it stay non-blocking while still doing so much in parallel? It’s because of the event loop.

How nodeJS handles concurrency

So normally Java would handle concurrency using multiple threads where each request might even spin up its own thread. But nodeJS takes a different route. It’s built on a single-threaded event loop. And yet, it still manages to handle I/O-heavy workloads efficiently. This event loop is the core mechanism that lets Node.js do async stuff in a synchronous-looking way. When you run setTimeout() or make a DB call, Node doesn’t wait around. It offloads that task, continues running other code, and comes back to your result later. This is what the normal flow would look like.

• So call stack will execute your code line by line.
• Node APIs like http, setTimeout or even filesystem APIs like reading or writing to a file, all of these are offloaded.
• Now comes the game changer. NodeJS internally uses this library called libuv, a C library, that manages a thread pool and handles things like file I/O or TCP. But I just said, NodeJS is single thread. What is this thread pool that libuv manages? I’ll come to that.
• Then there’s the callback queue. The async tasks would have a callback that runs after that task is complete. These callbacks are queued inside this callback queue.
• Event Loop — constantly checks if the stack is empty and pulls the next thing from the queue.

libuv

Okay let’s get back to libuv now. This library handles the lower-level async operations using a thread pool — but abstracted away from you. Think of it as the behind-the-scenes engine that powers most of Node.js’s non-blocking behavior. For example, when you do fs.readFile, Node doesn’t directly know how to access the file system asynchronously. Instead, it delegates this task to libuv. libuv spins up a thread from its internal pool to do the file reading, and then calls you back when it’s done. If you look at libuv’s github documentation, you’ll see all of these features.

Press enter or click to view image in full size

It’s all mostly non-blocking async operational features. You’ll also see child processes and thread pool in this list. So you do have options to spawn child processes and a pool of threads with libuv.

Child processes and threads are different in their own sense and I’ve a separate video series covering both. You can check it out. But for now, let’s see the thread action with in an example.

I have a simple node.js script here.

const crypto = require('crypto');
const start = Date.now();
for (let i = 0; i < 6; i++) {
  crypto.pbkdf2('password', 'salt', 100000, 512, 'sha512', () => {
    console.log(`Done in: ${Date.now() - start}ms`);
  });
}

• I’m using the native, crypto module to do some heavy cryptographic work, specifically pbkdf2, a password-based key derivation function — it’s CPU-intensive.
• I’m saving the current timestamp which I’ll later subtract to calculate how long the operation actually took.
• There’s a for loop that’ll run 6 times. So technically, I’ll be kicking off 6 pbkdf2 operations.

Now pbkdf2 is asynchronous and just like DNS resolution or file system operations, behind the scenes these encryption operations are also offloaded to a thread pool that’s managed by libuv and not the main thread. When each of these operations finish, the event loop that’s also part of libuv and not the v8 engine, moves the callback for these operations to the callstack inside the v8 engine. V8 engine is then responsible to actually execute the callback function.

If you run this, you’ll see 4 of the 6 operations take almost equal time, but the remaining 2 will take way more than that. That’s because by default, there are 4 threads in this thread pool. So in our case 6 tasks were launched but only 4 can run in parallel. The remaining 2 had to wait in a queue and that’s why you’ll see some finish quickly, and the rest later, once a thread becomes available.

We can also increase the number of threads. So instead of 4, let’s say I want 6. I can use this env variable before running the script.

UV_THREADPOOL_SIZE=6 node your-script.js

And now, you’ll see all the tasks run in parallel and take more or less the same amount of time. That’s because all 6 tasks have been assigned to individual threads without any wait time. This does not mean you can just increase the number of threads to solve your scaling problem. Threads do share memory so too many can cause crashes in your application.

Node.js since v10.5.0 has native support for worker threads where you can control what runs in parallel but they’re not commonly used in typical Node.js apps unless you’re doing CPU-intensive work. To understand why though, we need to look at Node’s design philosophy.

NodeJS’s design philosphy

Node.js was originally built for handling lots of concurrent I/O — what I mean by that is:

• Serving HTTP requests
• Reading/writing to disk
• Talking to databases
• Streaming files and so on

All of these operations are I/O-bound, not CPU-bound. That means:

• The bottleneck is waiting for things, not computing things.
• So, instead of spinning up new threads, Node just says: “I’ll handle something else while I wait.”

This event-driven, single-threaded model is perfect for that.

Worker Threads are for CPU-bound Tasks

Now, where worker threads shine is with CPU-intensive tasks, like:

• Image processing
• Compression
• Complex math or algorithms
• Synchronous crypto operations

These things block the main thread and can freeze your app if not handled off the main event loop. In those cases, you can spin up a worker thread like in Java, and do the heavy lifting in parallel. But here’s the thing: Most backend apps written in Node don’t do this kind of CPU-heavy work. They delegate it to services, CDNs, databases, etc.

What I mean by that is let’s say your app gets a request like: “Send me the latest 10 posts from the database.”

What happens?

1. Your server receives the request (network I/O)
2. You query the database (database I/O)
3. You format the result (small CPU task)
4. You send the response (network I/O)

See how most of the work is waiting on I/O, not doing hard CPU computations? You’re not doing the heavy lifting — you’re asking other services to do it, then just handling the data.

In contrast, CPU-heavy apps would be things like:

• Image filters or compression
• Running an AI model locally
• Converting videos
• Big data analytics

These aren’t common in your typical web backend — and when they are needed, people usually offload them to a service written in a lower-level language or deployed as a background job (e.g., in Python, Rust, Go, etc.).

Conclusion

So I hope this made sense and I was able to get my point across. You can literally achieve the same kind of multi threading in NodeJS as you see in Java. It’s just that node was built for heavy I/O scenarios since it’s designed around the event loop and Java on the other hand has a lot more native multi threading features baked in because it was built with the intention of handling more CPU intensive work along with basic I/O work. That’s why you’d see CPU intensive operations being delegated from a node service to a Java service or any other language built for that purpose.

If you have any other doubts or suggestions, do put them in the comments or you can get in touch with me on any one of my socials. Cheers!

How to Use Asynchronous Task Aggregator Task.WhenAny

I’m sure you’ve worked with asynchronous code in .NET. The easiest way to organize it is to use keywords async/await and write your code the same way as synchronous code would. But sometimes, you need to run several independent tasks in a row. Is it the best solution to write this code like a synchronous one? Answers to this question and much more you can find in this article.

Introduction

When you need to launch several independent tasks, all you need to do is to create the first task, do not wait for its completion, launch the second task, and so on. In the end, you can wait for every task result like this:

// collect all async tasks in the list
List<Task<TResult>> allTasks = new()
{
    Task1(),
    Task2(),
    Task3()
};

await allTasks[0];
await allTasks[1];
await allTasks[2];
// ... proceed

But is it a good option? What if you need to launch more asynchronous tasks? The more tasks you have — the more await statements you’re going to write. Sometimes this is the only option you have, but that’s not our case.

There is a task aggregator available in .NET — Task.WhenAny. It creates a single task from a bunch of tasks that will complete when any of the supplied tasks have been completed. It can help to handle task results immediately it finished and not even wait for other tasks’ completion.

So to handle the result of the asynchronous task just as soon as it finished you can write the next code:

// collect all async tasks in the list
List<Task<TResult>> allTasks = new()
{
    Task1(),
    Task2(),
    Task3()
};

while (allTasks.Count > 0)
{
    // the code below will return Task<Task<TResult>> - task that wraps your completed task
    var finished = await Task.WhenAny(allTasks);    
    
    // to get the result you can do next
    var result = await finished;    
    
    // ... handle result
    // and repeat until allTasks has at least single task
    allTasks.Remove(finished);
}

All you need to do is to collect all your tasks to the collection and pass it as an argument to Task.WhenAny, wait until it returns the very first finished task. You can instantly handle the result, remove the completed task from the collection and repeat these steps for other tasks.

Task.WhenAny always returns a wrapper around your asynchronous task. So if you need to receive the result of the asynchronous task, you must await the wrapper.

Task cancellation with Task.WhenAny

Now let’s see how to use Task.WhenAny in real-world use cases.

It happens sometimes you need to cancel the execution of asynchronous code. The common practice is to use CancellationToken. But not all methods have an overload that accepts it.

Let’s check the next example:

static Task Task1()
{
    return Task.Delay(2000);
}

try
{
    Console.WriteLine("started");    
    
    CancellationTokenSource cts = new(500);
    CancellationToken token = cts.Token;    
    
    await Task.Run(Task1, token);
    
    Console.WriteLine("finished wo cancellation");
}
catch (Exception)
{
    Console.WriteLine("finished with cancellation");
}

As you can see, Task1 does not have an overload that accepts CancellationToken. I’ve tried to use Task.Run that accepts CancellationToken. But execution result was next:

started
finished wo cancellation

As you can understand from the code above — the task was not canceled. Let’s see how Task.WhenAny can help to resolve it:

static Task Task1()
{
    return Task.Delay(2000);
}

static async Task WithCancellation(Task task, TimeSpan delay)
{
    Task finished = await Task.WhenAny(task, Task.Delay(delay));
    if (finished != task)
    {
        throw new TaskCanceledException();
    }
    await finished;
}

try
{
    Console.WriteLine("started");
    await WithCancellation(Task1(), TimeSpan.FromMilliseconds(500));
    Console.WriteLine("finished wo cancellation");
}
catch (Exception)
{
    Console.WriteLine("finished with cancellation");
}

Method WithCancellation accepts asynchronous task and delay before the cancellation. Based on the delay, another asynchronous task Task.Delay created. If the finished task is not an argument task — delay task finished first. It means you need to raise an exception.

It’s a little tricky solution because your task will continue to execute in the background and consume resources even after you handle exception. But sometimes, switching context on other stuff is a good option.

If you need to do the same, but based on CancellationToken, you can create the next overload:

static async Task WithCancellation(Task task, CancellationToken cancellationToken)
{
    Task finished = await Task.WhenAny(task, Task.Delay(Timeout.Infinite, cancellationToken));
    if (finished != task)
    {
        throw new TaskCanceledException();
    }
    
    await finished;
}

The second task passed to Task.WhenAny is an infinite delay, that would be finished only because the token is cancelled. Based on the methods above, you can create overloads for Task<TResult>.

Asynchronous enumerable with Task.WhenAny

You can move forward and even create an asynchronous iterator that will return tasks immediately they finish:

internal class AsyncTaskEnumerable<TResult> : IAsyncEnumerable<TResult>
{
    private readonly IEnumerable<Task<TResult>> _tasks;

    public AsyncTaskEnumerable(IEnumerable<Task<TResult>> tasks)
    {
        _tasks = tasks;
    }

    public IAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
    {
        return new AsyncTaskEnumerator(_tasks);
    }

    private class AsyncTaskEnumerator : IAsyncEnumerator<TResult>
    {
        private readonly List<Task<TResult>> _tasks;

        public AsyncTaskEnumerator(IEnumerable<Task<TResult>> tasks)
        {
            _tasks = tasks.ToList();
        }

        public TResult Current { get; private set; }

        public ValueTask DisposeAsync()
        {
            return new ValueTask();
        }

        public async ValueTask<bool> MoveNextAsync()
        {
            if (_tasks.Count == 0)
            {
                return false;
            }
            Task<TResult> finished = await Task.WhenAny(_tasks);
            Current = await finished;
            _ = _tasks.Remove(finished);
            return true;
        }
    }
}

public static class AsyncTaskEnumerableExtensions
{
    public static IAsyncEnumerable<TResult> ToAsyncEnumerable<TResult>(this IEnumerable<Task<TResult>> tasks)
    {
        return new AsyncTaskEnumerable<TResult>(tasks);
    }
}

The code below declares async enumerable AsyncTaskEnumerable that accepts a collection of launched tasks. MoveNextAsync method passes all the tasks to Task.WhenAny, waits for any to finish and returns it as a result. You can iterate through finished tasks like this:

static async Task<int> Task1()
{
    await Task.Delay(2000);
    return 1;
}

static async Task<int> Task2()
{
    await Task.Delay(1000);
    return 2;
}

static async Task<int> Task3()
{
    await Task.Delay(500);
    return 3;
}

Task<int>[] tasks = new[] { Task1(), Task2(), Task3() };

await foreach (int result in tasks.ToAsyncEnumerable())
{
    Console.WriteLine(result);
}

All you need to do is create a collection of tasks, convert it to asynchronous enumerable using the ToAsyncEnumerable extension method and iterate through it using await foreach. As a result, you will get task results immediately after they finish.

But be careful! The bigger number of asynchronous tasks launched — the more resources you need to handle them all. So limit the number of launched tasks to some reasonable number.

Conclussion

Task.WhenAny helps you to launch several tasks at the same time and get a result immediately after any are finished. You can use this method to handle the result as soon as it is ready.

Thanks for reading. I’d love to get your feedback!

Have you used Task.WhenAny before? What alternatives to Task.WhenAny you use?🤔

Please share your thoughts. Happy to discuss it with you 😉

Resources

Task.WhenAny Method (System.Threading.Tasks) | Microsoft Learn

Lodash is a popular JavaScript library that provides utility functions for simplifying and streamlining common programming tasks. It offers a wide range of methods to manipulate and work with arrays, objects, functions, and more. In this article, we will explore 20 useful Lodash methods that can enhance your everyday coding experience and improve code efficiency.

1. _.get()

The _.get() method retrieves the value of a nested property in an object.

const user = { name: { first: 'John', last: 'Doe' } };
const firstName = _.get(user, 'name.first');
// firstName: 'John'

2. _.isEmpty()

_.isEmpty() checks if a value is an empty object, array, map, or set.

const emptyArray = [];
const isEmpty = _.isEmpty(emptyArray);
// isEmpty: true

3. _.map()

The _.map() method allows you to iterate over each element in an array or object and apply a function to transform the elements based on the given criteria.

const doubledNumbers = _.map([1, 2, 3], num => num * 2);
// doubledNumbers: [2, 4, 6]

4. _.filter()

The _.filter() method lets you create a new array with elements that pass a certain condition or criteria.

const evenNumbers = _.filter([1, 2, 3, 4], num => num % 2 === 0);
// evenNumbers: [2, 4]

5. _.reduce()

_.reduce() allows you to reduce an array or object to a single value by applying an accumulating function.

const sum = _.reduce([1, 2, 3], (acc, num) => acc + num, 0);
// sum: 6

6. _.merge()

The _.merge() method merges two or more objects by deeply combining their properties.

const obj1 = { a: 1 };
const obj2 = { b: 2 };
const mergedObj = _.merge(obj1, obj2);
// mergedObj: { a: 1, b: 2 }

7. _.debounce()

_.debounce() is useful for delaying a function’s execution until after a specified amount of time has passed since the last invocation. This is particularly helpful for handling events like resizing or scrolling.

const debouncedFunction = _.debounce(() => console.log('Function debounced'), 300);

8. _.throttle()

Similar to _.debounce(), _.throttle() limits the number of times a function can be called over a specified time interval.

const throttledFunction = _.throttle(() => console.log('Function throttled'), 300);

9. _.flatten()

The _.flatten() method flattens a nested array into a single array.

const nestedArray = [1, [2, [3, [4]], 5]];
const flattenedArray = _.flatten(nestedArray);
// flattenedArray: [1, 2, 3, 4, 5]

10. _.orderBy()

_.orderBy() allows you to sort an array of objects based on specified properties and order.

const users = [
  { name: 'John', age: 30 },
  { name: 'Alice', age: 25 },
];
const sortedUsers = _.orderBy(users, ['age'], ['desc']);
// sortedUsers: [{ name: 'John', age: 30 }, { name: 'Alice', age: 25 }]

11. _.uniq()

The _.uniq() method creates a new array with unique elements.

const arrayWithDuplicates = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = _.uniq(arrayWithDuplicates);
// uniqueArray: [1, 2, 3, 4, 5]

12. _.isEqual()

_.isEqual() compares two values to determine if they are equivalent.

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: 1, b: { c: 2 } };
const isEqual = _.isEqual(obj1, obj2);
// isEqual: true

13. _.startsWith()

The _.startsWith() method checks if a string starts with a specified prefix.

const str = 'Hello, world!';
const startsWithHello = _.startsWith(str, 'Hello');
// startsWithHello: true

14. _.endsWith()

Similar to _.startsWith(), _.endsWith() checks if a string ends with a specified suffix.

const str = 'Hello, world!';
const endsWithWorld = _.endsWith(str, 'world!');
// endsWithWorld: true

15. _.groupBy()

The _.groupBy() method groups elements of an array based on a given criterion.

const numbers = [6.1, 4.2, 6.3];
const groupedByFloor = _.groupBy(numbers, Math.floor);
// groupedByFloor: { '4': [4.2], '6': [6.1, 6.3] }

16. _.pick()

_.pick() allows you to create a new object by picking specific properties from an existing object.

const user = { name: 'Alice', age: 30, email: 'alice@example.com' };
const selectedProperties = _.pick(user, ['name', 'age']);
// selectedProperties: { name: 'Alice', age: 30 }

17. _.omit()

The _.omit() method creates a new object with properties omitted from an existing object.

const user = { name: 'Alice', age: 30, email: 'alice@example.com' };
const omittedProperties = _.omit(user, ['email']);
// omittedProperties: { name: 'Alice', age: 30 }

18. _.isEqual()

_.isEqual() compares two values to determine if they are equivalent.

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: 1, b: { c: 2 } };
const isEqual = _.isEqual(obj1, obj2);
// isEqual: true

19. _.sample()

The _.sample() method returns a random element from an array.

const numbers = [1, 2, 3, 4, 5];
const randomElement = _.sample(numbers);
// randomElement: e.g., 3

20. _.zip()

_.zip() groups the elements of several arrays into a single array of tuples.

const names = ['Alice', 'Bob', 'Charlie'];
const ages = [30, 35, 25];
const zipped = _.zip(names, ages);
// zipped: [['Alice', 30], ['Bob

', 35], ['Charlie', 25]]

In conclusion, Lodash provides a wide array of utility functions that can greatly simplify and enhance everyday coding in JavaScript. By leveraging these methods, developers can write cleaner, more efficient, and maintainable code. Understanding and utilizing these Lodash methods can significantly improve your programming workflow and productivity. Happy coding!

Thread.Barrier is a synchronization primitive that enables multiple threads to synchronize their actions. It allows a set of threads to wait for each other to reach a certain point of execution before any of them proceeds.

Here’s an example demonstrating Thread.Barrier:

using System;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
    private static Barrier _barrier = new Barrier(3); // 3 participants

    public static void Main()
    {
        Console.WriteLine("Starting Barrier Demonstration");

        Task task1 = Task.Run(() => DoWork("Task 1"));
        Task task2 = Task.Run(() => DoWork("Task 2"));
        Task task3 = Task.Run(() => DoWork("Task 3"));

        Task.WaitAll(task1, task2, task3);

        Console.WriteLine("Barrier Demonstration Completed");
    }

    public static void DoWork(string taskName)
    {
        Console.WriteLine($"{taskName} started");
        Thread.Sleep(new Random().Next(1000, 3000)); // Simulate work
        Console.WriteLine($"{taskName} waiting at barrier");
        
        _barrier.SignalAndWait(); // Wait for other threads

        Console.WriteLine($"{taskName} passed barrier");
        Thread.Sleep(new Random().Next(1000, 3000)); // More work
        Console.WriteLine($"{taskName} completed");
    }
}

Output:

Starting Barrier Demonstration
Task 1 started
Task 2 started
Task 3 started
Task 2 waiting at barrier
Task 1 waiting at barrier
Task 3 waiting at barrier
Task 2 passed barrier
Task 1 passed barrier
Task 3 passed barrier
Task 1 completed
Task 3 completed
Task 2 completed
Barrier Demonstration Completed

In this example:

1. We create a Barrier with 3 participants, corresponding to our three tasks.
2. Each task performs some initial work (simulated by a random sleep).
3. All tasks then call _barrier.SignalAndWait(). This method does two things:

• It signals that the task has reached the barrier.
• It makes the task wait until all other participants have also reached the barrier.

4. Once all three tasks have reached the barrier, they are all released simultaneously.

5. The tasks then perform some final work before completing.

The key point here is that Thread.Barrier ensures that all participating threads reach a certain point in their execution before any of them are allowed to proceed further. This is useful in scenarios where you need to synchronize multiple threads at specific points in their execution.

“ReadWriteLockSlim”: Concurrent reads, exclusive writes synchronization.

ReadWriteLockSlim is a lightweight synchronization primitive that’s particularly useful when you have a resource that’s frequently read but infrequently written. It allows for concurrent read operations while ensuring exclusive access for write operations. This makes it particularly useful for implementing thread-safe classes with multiple methods that need to access shared data.

Key features of ReadWriteLockSlim for multi-method thread safety:

1. Granular locking: You can apply different lock modes (read, upgradeable read, or write) to different methods based on their access patterns.
2. Performance optimization: It allows multiple threads to read simultaneously, improving performance in read-heavy scenarios.
3. Upgrade capability: You can upgrade from a read lock to a write lock, which is useful for methods that may need to write based on certain conditions.
4. Reentrance: Supports recursive locking, allowing a thread to enter the same lock multiple times.
5. Timeout options: Provides methods to attempt acquiring locks with timeouts, preventing deadlocks.

When implementing a thread-safe class with multiple methods:

• Use EnterReadLock() for methods that only read shared data.
• Use EnterWriteLock() for methods that modify shared data.
• Use EnterUpgradeableReadLock() for methods that mostly read but may need to write.

By consistently applying these locks across all methods that access shared data, you can ensure thread safety for the entire class, preventing race conditions and data corruption in multi-threaded environments.

Example: Using ReadWriteLockSlim

Let’s create an example that demonstrates the use of ReadWriteLockSlim in a scenario where we will showcase multiple concurrent reads while ensuring exclusive access for writes, making it efficient for scenarios with frequent reads and occasional writes.

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
    static int sharedResource = 0;

    static void Main()
    {
        Task[] tasks = new Task[5];
        for (int i = 0; i < 5; i++)
        {
            tasks[i] = i % 2 == 0 ? Task.Run(ReadResource) : Task.Run(WriteResource);
        }

        Task.WaitAll(tasks);
    }

    static void ReadResource()
    {
        rwLock.EnterReadLock();
        try
        {
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} reading: {sharedResource}");
            Thread.Sleep(100); // Simulate some work
        }
        finally
        {
            rwLock.ExitReadLock();
        }
    }

    static void WriteResource()
    {
        rwLock.EnterWriteLock();
        try
        {
            sharedResource++;
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} writing: {sharedResource}");
            Thread.Sleep(100); // Simulate some work
        }
        finally
        {
            rwLock.ExitWriteLock();
        }
    }
}

Output:

Thread 4 reading: 0
Thread 5 reading: 0
Thread 6 writing: 1
Thread 7 reading: 1
Thread 8 writing: 2

Explanation of the output:

• The output may vary due to the nature of concurrent execution, but it demonstrates key behaviors of ReadWriteLockSlim.
• Multiple threads can read simultaneously (threads 4 and 5 both read 0).
• Write operations are exclusive (threads 6 and 8 write sequentially).
• Read operations see the updated value after a write (thread 7 reads 1 after it was incremented).

This example showcases how ReadWriteLockSlim allows multiple concurrent reads while ensuring exclusive access for writes, making it efficient for scenarios with frequent reads and occasional writes.

1. StackFrame

• Represents a single frame in the call stack.
• Contains information about a method invocation, including the method name, file name, line number, and column number (if debugging symbols are available).
• Can be used to inspect specific details about a method at a particular level of the call stack.

Key Properties and Methods

• GetMethod(): Gets the method associated with the stack frame.
• GetFileName(): Gets the file name containing the method (if debugging symbols are available).
• GetFileLineNumber(): Gets the line number in the source file where the method is defined.
• GetFileColumnNumber(): Gets the column number in the source file.

Usage Example

using System.Diagnostics;

class Program
{
    static void Main()
    {
        TestMethod();
    }    
    
    static void TestMethod()
    {
        StackFrame frame = new StackFrame(1, true); // Get the previous frame (1 level up) with file and line info
        var method = frame.GetMethod();
        Console.WriteLine($"Method: {method.Name}");
        Console.WriteLine($"File: {frame.GetFileName()}");
        Console.WriteLine($"Line: {frame.GetFileLineNumber()}");
    }
}

2. StackTrace

• Represents the entire stack trace of the program at a particular point in time.
• A stack trace is a collection of StackFrame objects, one for each method call in the call stack.
• Typically used to analyze the complete path leading to an exception or to debug the flow of method calls.

Key Properties and Methods

• FrameCount: Gets the number of frames in the stack trace.
• GetFrame(int index): Gets a specific frame from the stack trace.
• ToString(): Provides a string representation of the entire stack trace.

Usage Example

using System.Diagnostics;

class Program
{
    static void Main()
    {
        TestMethod();
    }    
    
    static void TestMethod()
    {
        StackTrace trace = new StackTrace(true); // Capture stack trace with file and line info
        foreach (StackFrame frame in trace.GetFrames())
        {
            Console.WriteLine($"Method: {frame.GetMethod().Name}, File: {frame.GetFileName()}, Line: {frame.GetFileLineNumber()}");
        }
    }
}

Key Differences

When to Use

• Use StackFrame when you need details about a specific method in the stack.
• Use StackTrace when you need an overview of the entire call stack or want to analyze the execution flow.

Happy Coding 🎉🎉 .

Tap the 👏 button if you found this article useful!

Welcome to my blog! Today, we’re diving into the exciting new features of C# 13. With the release of Visual Studio 2022 and its various previews, C# 13 has introduced several enhancements that improve functionality and developer experience. Let’s explore these features in detail.

Enhanced Params Collections

The first major feature in C# 13 is the enhanced params collections. This allows you to pass a variety of collection types — beyond just arrays — using the params keyword. You can now use lists, spans, and enumerables seamlessly.

What Are Param Collections?

The params keyword in C# allows a method to accept a variable number of arguments, which must be a single-dimensional array. This parameter must be the last in the method signature, and only one params parameter is allowed per method.

How Is It Used?

Example of a method to calculate the sum of integers:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int results = CalculateSum(numbers.ToArray());

Console.WriteLine(results);

int CalculateSum(params int[] numbers)
{
    return numbers.Sum();

}

Limitations and Performance Considerations

Using params involves creating an array, which can affect performance, especially in loops or performance-critical code. Additionally, only one params parameter is allowed per method, and it must be the last parameter.

Changes in C# 13

C# 13 enhances the params keyword with:

• Support for Multi-Dimensional Arrays: Simplifies method calls and improves readability.
• Improved Type Inference: Better integration with generic methods and complex types.
• Performance Optimizations: Reduced overhead and improved performance for high-frequency method calls.

Examples

Enhanced CalculateSum method in C# 13:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int results = CalculateSum(numbers);

Console.WriteLine(results);

int CalculateSum(params List<int> numbers)
{
    return numbers.Sum();

}

Benchmarking the Performance

To evaluate the performance enhancements, we can set up a benchmark using BenchmarkDotNet:

using BenchmarkDotNet.Attributes;
using System;
using System.Collections.Generic;
using System.Linq;[MemoryDiagnoser]
public class ParamsBenchmark
{
    private List<int> numbers;    [GlobalSetup]
    public void Setup()
    {
        numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    }    
    [Benchmark]
    public int CalculateSumWithList()
    {
        return CalculateSum(numbers);
    }    
    [Benchmark]
    public int CalculateSumWithArray()
    {
        return CalculateSum(numbers.ToArray());
    }    
    public int CalculateSum(params List<int> numbers)
    {
        return numbers.Sum();
    }    
    public int CalculateSum(params int[] numbers)
    {
        return numbers.Sum();
    }
}

Output:

The benchmark results indicate that the new enhanced params implementation in C# 13 offers better performance with no additional memory overhead. The enhancements in C# 13 make params collections more powerful and efficient, catering to more complex use cases and improving overall performance.

New Lock Object

Next up is the new lock object, introduced in C# 13 with .NET 9. This feature offers a more efficient mechanism for thread synchronization, improving performance compared to traditional locks.

Using the new lock object, you can ensure that locks are properly released even if exceptions occur, thanks to the implementation of the dispose pattern. This makes your code safer and more efficient.

New Escape Sequence

C# 13 also introduces a new escape sequence character, simplifying the process of including escape characters in strings. This new character allows developers to represent escape sequences more intuitively.

This feature is particularly useful when sending control sequences to terminals or devices that interpret escape sequences, enabling more colorful outputs in your applications.

Implicit Index Access

Another exciting feature is implicit index access. This allows you to use the XOR operator for indexing directly in object initializers, making your code more readable and easier to maintain.

With this feature, you can initialize arrays in a more expressive manner, enhancing the clarity of your code when dealing with reverse indexing.

Method Group Natural Type

The method group natural type feature is designed to improve overload resolution. It helps the compiler better infer the appropriate method to invoke based on the context of the method group.

This makes it easier to work with method groups, especially when assigning them to delegates or variables, streamlining your coding process.

Ref and Unsafe in Async Methods

C# 13 enhances the flexibility and performance of async methods and iterators with the introduction of ref and unsafe context. This allows for more efficient memory management and processing within asynchronous operations.

With this new feature, you can declare reference local variables that retain their references across async boundaries, improving the performance of your applications.

Extension Types

Last but not least, C# 13 introduces extension types, which allow you to add new methods, properties, and even indexes to existing types without modifying the original class.

This feature simplifies the way you extend functionality, making it easier to enhance existing types while maintaining clean and manageable code.

Conclusion

In conclusion, C# 13 brings a host of new features that enhance the language’s functionality and improve the developer experience. From enhanced params collections to extension types, these updates are designed to make coding more intuitive and efficient.

Thank you for joining me on this exploration of C# 13 features. If you’re interested in more tutorials and in-depth explanations, please let me know in comments!

Stay tuned for more updates and happy coding!

Simple Strings

Every language needs a type for storing text, that’s the String class/string keyword. It’s what is used mainly in C# and has been there since day 1:

var text = "I thought we had literal strings";
WriteLine(text);

We could use embedded quotes, but we needed to escape them (or other things like tabs, line breaks):

text = "John \"Quincy\" Adams";

We didn’t have a good solution for multi-line, so we ended up with monstrosities (or using a StringBuilder):

text = "First Line\n";
text += "Second Line\n";
text += "Third Line";

String Interpolation

Some time, later C# introduced a way to have strings just use interpolation (instead of the dreaded string.Format(…)):

text = $"This is an interpolated string: {someName} - {someName.Length}";

The dollar sign said that it should expect C# code inside brackets.

But this introduced a need to double bracket if you needed a bracket in string:

text = $"This is an interpolated string: {{ {someName} }}";

A compromise to support this better way of building strings. Of course, that made JSON in strings pretty ugly:

text = $"{{ \"name\": \"Shawn\" }}";

Interpolated strings support all the capabilities of the string composite formatting feature. That makes them a more readable alternative to the use of the String.Format method.

How to specify a format string for an interpolation expression

To specify a format string that is supported by the type of the expression result, follow the interpolation expression with a colon (“:”) and the format string:

{<interpolationExpression>:<formatString>}

The following example shows how to specify standard and custom format strings for expressions that produce date and time or numeric results:

var date = new DateTime(1731, 11, 25);
Console.WriteLine($"On {date:dddd, MMMM dd, yyyy} L. Euler introduced the letter e to denote {Math.E:F5}.");
// Output:
// On Sunday, November 25, 1731 L. Euler introduced the letter e to denote 2.71828.

For more information, see the Format string component section of the Composite formatting article.

How to control the field width and alignment of the formatted interpolation expression

To specify the minimum field width and the alignment of the formatted expression result, follow the interpolation expression with a comma (“,”) and the constant expression:

{<interpolationExpression>,<alignment>}

If the alignment value is positive, the formatted expression result is right-aligned; if negative, it’s left-aligned.

If you need to specify both alignment and a format string, start with the alignment component:

{<interpolationExpression>,<alignment>:<formatString>}

The following example shows how to specify alignment and uses pipe characters (“|”) to delimit text fields:

const int NameAlignment = -9;
const int ValueAlignment = 7;
double a = 3;
double b = 4;
Console.WriteLine($"Three classical Pythagorean means of {a} and {b}:");
Console.WriteLine($"|{"Arithmetic",NameAlignment}|{0.5 * (a + b),ValueAlignment:F3}|");
Console.WriteLine($"|{"Geometric",NameAlignment}|{Math.Sqrt(a * b),ValueAlignment:F3}|");
Console.WriteLine($"|{"Harmonic",NameAlignment}|{2 / (1 / a + 1 / b),ValueAlignment:F3}|");
// Output:
// Three classical Pythagorean means of 3 and 4:
// |Arithmetic|  3.500|
// |Geometric|  3.464|
// |Harmonic |  3.429|

As the example output shows, if the length of the formatted expression result exceeds specified field width, the alignment value is ignored.

For more information, see the Alignment component section of the Composite formatting article.

How to use escape sequences in an interpolated string

Interpolated strings support all escape sequences that can be used in ordinary string literals. For more information, see String escape sequences.

To interpret escape sequences literally, use a verbatim string literal. An interpolated verbatim string starts with the both $ and @ characters. You can use $ and @ in any order: both $@"..." and @$"..." are valid interpolated verbatim strings.

To include a brace, “{“ or “}”, in a result string, use two braces, “{{“ or “}}”. For more information, see the Escaping braces section of the Composite formatting article.

The following example shows how to include braces in a result string and construct a verbatim interpolated string:

var xs = new int[] { 1, 2, 7, 9 };
var ys = new int[] { 7, 9, 12 };
Console.WriteLine($"Find the intersection of the {{{string.Join(", ",xs)}}} and {{{string.Join(", ",ys)}}} sets.");
// Output:
// Find the intersection of the {1, 2, 7, 9} and {7, 9, 12} sets.
var userName = "Jane";
var stringWithEscapes = $"C:\\Users\\{userName}\\Documents";
var verbatimInterpolated = $@"C:\Users\{userName}\Documents";
Console.WriteLine(stringWithEscapes);
Console.WriteLine(verbatimInterpolated);
// Output:
// C:\Users\Jane\Documents
// C:\Users\Jane\Documents

Interpolated string also allow you to include special characters inside it. They are indicated by a backslash followed by a character. Some of the most common escape sequences are “\n” for a new line, “\t” for a tab, and “\” for a literal backslash.

For example:

string message = $"This is a message with a\nnew line and a\ttab.";
Console.WriteLine(message);

The output of this code will be:

This is a message with a
new line and a    tab.

How to use a ternary conditional operator ?: in an interpolation expression

As the colon (“:”) has special meaning in an item with an interpolation expression, in order to use a conditional operator in an expression, enclose it in parentheses, as the following example shows:

var rand = new Random();
for (int i = 0; i < 7; i++)
{
    Console.WriteLine($"Coin flip: {(rand.NextDouble() < 0.5 ? "heads" : "tails")}");
}

How to create a culture-specific result string with string interpolation

By default, an interpolated string uses the current culture defined by the CultureInfo.CurrentCulture property for all formatting operations.

Beginning with .NET 6, you can use the String.Create(IFormatProvider, DefaultInterpolatedStringHandler) method to resolve an interpolated string to a culture-specific result string, as the following example shows:

var cultures = new System.Globalization.CultureInfo[]
{
    System.Globalization.CultureInfo.GetCultureInfo("en-US"),
    System.Globalization.CultureInfo.GetCultureInfo("en-GB"),
    System.Globalization.CultureInfo.GetCultureInfo("nl-NL"),
    System.Globalization.CultureInfo.InvariantCulture
};
var date = DateTime.Now;
var number = 31_415_926.536;
foreach (var culture in cultures)
{
    var cultureSpecificMessage = string.Create(culture, $"{date,23}{number,20:N3}");
    Console.WriteLine($"{culture.Name,-10}{cultureSpecificMessage}");
}
// Output is similar to:
// en-US       8/27/2023 12:35:31 PM      31,415,926.536
// en-GB         27/08/2023 12:35:31      31,415,926.536
// nl-NL         27-08-2023 12:35:31      31.415.926,536
//               08/27/2023 12:35:31      31,415,926.536

In earlier versions of .NET, use implicit conversion of an interpolated string to a System.FormattableString instance and call its ToString(IFormatProvider) method to create a culture-specific result string. The following example shows how to do that:

var cultures = new System.Globalization.CultureInfo[]
{
    System.Globalization.CultureInfo.GetCultureInfo("en-US"),
    System.Globalization.CultureInfo.GetCultureInfo("en-GB"),
    System.Globalization.CultureInfo.GetCultureInfo("nl-NL"),
    System.Globalization.CultureInfo.InvariantCulture
};
var date = DateTime.Now;
var number = 31_415_926.536;
FormattableString message = $"{date,23}{number,20:N3}";
foreach (var culture in cultures)
{
    var cultureSpecificMessage = message.ToString(culture);
    Console.WriteLine($"{culture.Name,-10}{cultureSpecificMessage}");
}
// Output is similar to:
// en-US       8/27/2023 12:35:31 PM      31,415,926.536
// en-GB         27/08/2023 12:35:31      31,415,926.536
// nl-NL         27-08-2023 12:35:31      31.415.926,536
//               08/27/2023 12:35:31      31,415,926.536

As the example shows, you can use one FormattableString instance to generate multiple result strings for various cultures.

How to create a result string using the invariant culture

Beginning with .NET 6, use the String.Create(IFormatProvider, DefaultInterpolatedStringHandler) method to resolve an interpolated string to a result string for the InvariantCulture, as the following example shows:

string message = string.Create(CultureInfo.InvariantCulture, $"Date and time in invariant culture: {DateTime.Now}");
Console.WriteLine(message);
// Output is similar to:
// Date and time in invariant culture: 05/17/2018 15:46:24

In earlier versions of .NET, along with the FormattableString.ToString(IFormatProvider) method, you can use the static FormattableString.Invariant method, as the following example shows:

string message = FormattableString.Invariant($"Date and time in invariant culture: {DateTime.Now}");
Console.WriteLine(message);
// Output is similar to:
// Date and time in invariant culture: 05/17/2018 15:46:24

Verbatim Strings

In came Verbatim strings. This allowed you to have line breaks and look simpler:

text = @"This is a verbatim string.

This means you can have line breaks 
and use double ""'s to output quotes.";

While many things didn’t need to be escaped, you still needed something special for double-quotes. If you needed double-quotes you had to double them to get:

This is a verbatim string.

This means you can have line breaks
and use double "'s to output quotes.

Not perfect, but worked in a lot of situations, but if you wanted to use a format like XML or JSON, it ended up with this ugliness:

text = @
{
  ""name"": ""Shawn"
}
";

Verbatim Strings with Interpolation

But you could mix verbatim and interpolation:

text = $@"This is a verbatim 
interpolated string: {someName}";

This worked, unless you needed brackets as text:

// Doesn't work, as it thinks that the whole thing is interpolated
text = $@"
{ 
  ""name"": ""{someName}"" 
}";

So, now we need to double-quote as well as double curly-brace:

// Works
text = $@"
{{ 
  ""name"": ""{someName}"" 
}}";

Hrmph…

Ok, Raw String Literals?

Here’s where Raw String Literals come in. The idea is to allow anything between a set of delimiters. That delimiter is a triple-quote (yes, seriously, but it does make sense).

When you triple-quote, everything is a literal, No magic here:

text = """This is pure text, which includes " and ' and other literals""";

This works, but the rules are a tad different for multi-line, in that case the triple-quotes must be on their own lines:

text = """
Everything between the quotes is literally interpreted, 
There is no need for escaping of anything.

Really!
  You can use "Whatever you Like"
""";

What’s important here is that the triple-quoted lines are not included in the string. The string starts on the first line after the triple-quote. This solves a lot of the messiness with commonly used things like JSON:

text = """
{
  "name": "Shawn"
}
""";

Whew, that’s easy…almost.

Interpolated Raw String Literals?

If you add interpolation to a raw string, you find an odd situation where the compiler must know what is an interpolated section (Raw String Literals assume everything is just text). Like the other types of strings, you start interpolated strings with a dollar sign:

text = $"""<name>{someName}</name>""";

Simple, sure. But what if you need brackets?

// Doesn't work, as it's expecting the brace
// to be part of the interpolation
text = $""" 
{
  "name": "{someName}"
}
""";

The solution? To do interpolation with brackets, the number of dollar-signs represents the number of brackets to indicate an interpolation:

// Add number of $ for the depth of the braces needed
text = $$"""
{
  "name": "{{someName}}"
}
""";

This isn’t a typo, this is valid C# 11. Solves a ton of situations, but still requires you to remember some stuff (I actually wish that had used the back-tick like JavaScript as it reads easier IMO). Raw string literals can also be combined with interpolated strings to embed the { and } characters in the output string. You use multiple $ characters in an interpolated raw string literal to embed { and } characters in the output string without escaping them.

You may need to create a raw string literal that has three or more consecutive double-quote characters. Raw string literals can start and end with a sequence of at least three double-quote characters. When your string literal contains three consecutive double-quotes, you start and end the raw string literal with four double quote characters:

var moreQuotes = """" As you can see,"""Raw string literals""" can start and end with more than three double-quotes when needed."""";

Output:

As you can see,"""Raw string literals""" can start and end with more than three double-quotes when needed.

If you need to start or end a raw string literal with quote characters, use the multi-line format:

var MultiLineQuotes = """"
               """Raw string literals""" can start and end with more than three double-quotes when needed.
               """";

Output:

"""Raw string literals""" can start and end with more than three double-quotes when needed.

What do you think of new new syntax (and do you think you’ll be using it?) Tell me in the comments!

Severity levels

In Visual Studio 2019 version 16.3 and later, you can configure the severity of analyzer rules in an EditorConfig file, from the light bulb menu, and from the Error List window.

The following table shows the different severity options that you can configure for a diagnostic:

View rule violations

If an analyzer finds any analyzer rule violations, it reports them in the Error List window and in the code editor.

The following screenshot shows rule violations reported in the Error List window. The analyzer violations reported in the error list match the severity level setting of the rule:

The analyzer rule violations also appear in the code editor as squiggle lines under the offending code. For example, the following screenshot shows three violations: one error (red squiggle line), one warning (green squiggle line), and one suggestion (three gray dots):

Many diagnostics have one or more associated code fixes that you can apply to correct the rule violation. Code fixes are shown in the light bulb icon menu along with other types of Quick Actions. For more information about code fixes, see Common Quick Actions.

Configure severity levels

You can set the rule severity using any of the following methods:

• EditorConfig
• Light bulb menu
• Error List window
• Solution Explorer

Silent vs. None severity

Silent severity rules that are enabled by default differ from disabled or None severity rules:

• If a code fix is registered for a Silent severity rule, Visual Studio offers the code fix as a light bulb code-refactoring action even if the hidden diagnostic isn't visible to the user. If the severity rule is disabled as None, the code fix isn't offered.
• Entries that set the severity of multiple analyzer rules at once in an EditorConfig file can bulk configure Silent severity rules. None severity rules can't be configured this way. Instead, they must be configured through entries that set the severity in an EditorConfig file for each rule ID.

Set rule severity in an EditorConfig file

EditorConfig files are available in Visual Studio 2019 version 16.3 and later.

Setting a rule’s severity in an EditorConfig file takes precedence over any severity set in a rule set or in Solution Explorer. You can configure severity either manually in an EditorConfig file or automatically through the light bulb that appears next to a violation.

Manually configure rule severity in an EditorConfig file

To configure rule severity, follow these steps:

1. Add an EditorConfig file to your project, if you don’t already have one.
2. Add an entry for each rule you want to configure under the corresponding file extension.

For example, the entry to set the severity for CA1822 to error for C# files is as follows:

[*.cs]
dotnet_diagnostic.CA1822.severity = error

3. You can set the rule severity for each diagnostic rule ID in an EditorConfig file with the following syntax

[*.cs]
dotnet_diagnostic.<rule ID>.severity = <severity>

4. For IDE code-style analyzers, you can also configure them in an EditorConfig file by using a different syntax.

For example, dotnet_style_qualification_for_field = false:suggestion. However, if you set a severity using the dotnet_diagnostic syntax, it takes precedence. For more information, see Language conventions for EditorConfig.

Set the severity of multiple analyzer rules at once in an EditorConfig file

The ability to set multiple analyzer rules at once in an EditorConfig file is available in Visual Studio 2019 version 16.5 and later.

You can set the severity for a specific category of analyzer rules or for all analyzer rules with a single entry in an EditorConfig file:

• Set the rule severity for a category of analyzer rules:

dotnet_analyzer_diagnostic.category-<rule category>.severity = <severity>

• Set the rule severity for all analyzer rules:

dotnet_analyzer_diagnostic.severity = <severity>

Entries that configure multiple analyzer rules at once apply only to rules that are enabled by default. Analyzer rules that are marked as disabled by default in the analyzer package must be enabled through explicit dotnet_diagnostic.<rule ID>.severity = <severity> entries.

If you have multiple entries that are applicable to a specific rule ID, the order of precedence for the applicable entry is as follows:

• A severity entry for an individual rule by ID takes precedence over a severity entry for a category.
• A severity entry for a category takes precedence over a severity entry for all analyzer rules.

Consider the following EditorConfig example, where CA1822 is a performance rule:

[*.cs]
dotnet_diagnostic.CA1822.severity = error
dotnet_analyzer_diagnostic.category-performance.severity = warning
dotnet_analyzer_diagnostic.severity = suggestion

In this example, all three entries apply to the performance rule CA1822. However, using the specified precedence rules, the first rule ID-based severity entry takes precedence over the next entries. In this example, CA1822 has an effective severity of error. The remaining performance rules have a severity of warning. The analyzer rules that aren't performance rules have a severity of suggestion.

Set rule severity from the light bulb menu

Visual Studio provides a convenient way to configure a rule’s severity from the Quick Actions light bulb menu. Follow these steps:

1. After a violation occurs, hover over the violation squiggle line in the editor and choose Show potential fixes to open the light bulb menu. Or, place your cursor on the line and press Ctrl+. (period).
2. From the light bulb menu, hover over a severity level for a preview of the change, and then configure the severity according to the following options:

• Configure <rule ID> severity. Set the severity for the specific rule.
• Configure severity for all <style> analyzers. Set the severity for all rules in the specific rule category.
• Configure severity for all analyzers. Set the severity for all categories of analyzer rules.

In the following example, select Suppress or configure issues > Configure <rule ID> severity.

3. Choose one of the severity options.

Visual Studio adds an entry to the EditorConfig file to configure the rule to the requested severity level, as shown in the preview box.

If you don’t already have an EditorConfig file in the project, Visual Studio creates one for you.

Set rule severity from the Error List window

Visual Studio also provides a convenient way to configure a rule’s severity from the error list context menu. Follow these steps:

1. After a violation occurs, right-click the diagnostic entry in the error list.
2. From the context menu, select Set severity, and then select one of the severity options.

Visual Studio adds an entry to the EditorConfig file to configure the rule to the requested level.

If you don’t already have an EditorConfig file in the project, Visual Studio creates one for you.

Set rule severity from Solution Explorer

To set rule severity from Solution Explorer, follow these steps:

1. In Solution Explorer, expand References > Analyzers (or Dependencies > Analyzers for .NET Core projects).
2. Expand the assembly that contains the rule you want to set the severity for.
3. Right-click the rule and select Set severity. In the context menu, choose one of the severity options.

Visual Studio adds an entry to the EditorConfig file to configure the rule to the requested level. If your project uses a rule set file instead of an EditorConfig file, the severity entry is added to the rule set file.

If you don’t already have an EditorConfig file or rule set file in the project, Visual Studio creates a new EditorConfig file for you.

View analyzers and diagnostics from Solution Explorer

You can do much of the customization of analyzer diagnostics from Solution Explorer. If you install an analyzer as a NuGet package, an Analyzers node appears under the References node (or Dependencies node for .NET Core projects) in Solution Explorer. Follow these steps to view the analyzers and diagnostics:

1. In Solution Explorer, expand your project, expand References or Dependencies, and then expand Analyzers. Expand one of the analyzer assemblies to see the diagnostics in the assembly.

The icon next to each diagnostic indicates its severity level:

• x in a circle indicates a severity of Error
• ! in a triangle indicates a severity of Warning
• i in a solid circle indicates a severity of Suggestion
• i in a dotted circle indicates a severity of Silent
• Downward-pointing arrow in a solid circle indicates a severity of None

2. To view the properties of a diagnostic, including its description and default severity, right-click the diagnostic, and then select Properties. Or, select the diagnostic, and then press Alt+Enter.

The Properties window appears.

3. To view properties for code style rules (IDE prefix) in the Properties window, such as default severity, set the EnforceCodeStyleInBuild property to true.

4. For online documentation for a diagnostic, right-click the diagnostic, and then select View Help.

Sample Editor Config

# Rules for ConsoleApp
# Description: Code analysis rules for ConsoleApp.csproj.
# Code files
[*.{cs,vb}]
dotnet_diagnostic.CA1001.severity = warning
dotnet_diagnostic.CA1821.severity = warning
dotnet_diagnostic.CA2213.severity = warning
dotnet_diagnostic.CA2231.severity = warning

Dependent projects

In a .NET Core project, if you add a reference to a project that has NuGet analyzers, Visual Studio automatically adds those analyzers to the dependent project. To disable this behavior (for example, if the dependent project is a unit test project), mark the NuGet package as private by setting the PrivateAssets attribute in the .csproj or .vbproj file of the referenced project:

<PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="5.0.0" PrivateAssets="all" />

In React development, efficiently managing props is crucial, especially when utilizing TypeScript for type safety. This post will explore the children prop—how to correctly define and use it in your React components, and the importance of using the right type definitions for your components. We will explore practical examples that illustrate these concepts, ensuring clarity and ease of understanding.

What is the Children Prop?

The children prop is a unique feature in React components. It allows developers to pass JSX elements as children to a component, enabling more flexible and reusable code. This capability means that any component can act as a wrapper for other components or elements, seamlessly integrating them into its layout.

However, when defining props in TypeScript, the children prop is often overlooked. This oversight can lead to errors, particularly when attempting to access children within a component without having defined it in the props type. Understanding how to properly include and type the children prop is essential for building robust React applications.

Defining Props Without Children

Consider a simple component that requires a title but does not use children. In such cases, you might define the props like this:

type Props = {
  title: string;
};

While this definition works perfectly for components that do not utilize the children prop, it becomes problematic when you attempt to access children. If you try to extract children from this props type, TypeScript will throw an error indicating that the property does not exist.

Updating the Props Type to Include children

To utilize the children prop, adjustments to the props type must be made. Instead of using a traditional prop like description, you can redefine your props to include children using a more appropriate setup.

The recommended type for children is ReactNode. This type is designed to encompass anything that can be rendered, including strings, numbers, and JSX elements. To implement this, you will need to import ReactNode from the appropriate types package.

It’s also a good practice to include the type ReactNode decorator in the import statement. This special decorator is useful in TypeScript projects as it signals to the build tool that this import can be removed in the final code that runs in the browser. This is important because the browser cannot process TypeScript types.

import { type ReactNode } from 'react';

interface MyComponentProps {
  title: string;
  children: ReactNode;
}

With ReactNode defined, you can extract and use the children prop effectively within your component.

Alternative Approach: Using PropsWithChildren

Another approach to manage props with the children property is to utilize the PropsWithChildren type provided by React. This generic type simplifies the definition of props that include children.

import { PropsWithChildren } from 'react';

interface MyComponentProps {
  title: string;
}
const MyComponent: React.FC<PropsWithChildren<MyComponentProps>> 
                                      = ({ title, children }: MyComponentProps) => {
  return (
    <div>
      <h1>{title}</h1>
      <div>{children}</div>
    </div>
  );
};

Using PropsWithChildren allows you to automatically include the children prop without needing to specify it manually in the props interface.

Comparing Both Approaches

Choosing between defining the children prop manually or using PropsWithChildren depends on your coding style and preferences. Here’s a quick comparison:

1. Manual Definition: Offers more control over prop types but requires more lines of code.
2. PropsWithChildren: Cleaner and easier to read, automatically includes children but might obscure the explicit definition of props.

Ultimately, both methods achieve the same result. It’s up to the developer to decide which approach aligns better with their coding practices.

Handling Optional Children

In some cases, you may want to make the children prop optional. To do this, simply append a question mark to the children property in your props definition:

type Props = {
  title: string;
  children?: React.ReactNode;
};

This adjustment allows the component to function even if no children are provided, adding another layer of flexibility to your components.

Conclusion

Defining types for props with children in React is a fundamental aspect of building robust applications. Understanding how to correctly handle the children prop in React can prevent errors and enhance the overall quality of your code. By defining the type as ReactNode or using PropsWithChildren, developers can avoid errors and ensure their components function correctly when wrapped around other JSX elements. Whether you choose to define props manually or use PropsWithChildren, the key takeaway is to ensure that your components are flexible and maintainable.

By mastering these concepts, you will be better equipped to create reusable components that can adapt to various needs, ultimately leading to more efficient and effective React applications.

As you continue your journey in React development, remember to keep these principles in mind. Happy coding!