DEV Community: Sajad Jalilian

C# Concurrency in a nutshell

Sajad Jalilian — Fri, 16 May 2025 10:16:14 +0000

In this article, I will briefly discuss the most important aspects of concurrency in C#.

Concurrency vs. Parallelism

A system is said to be concurrent if it can support two or more actions in progress at the same time. A system is said to be parallel if it can support two or more actions executing simultaneously. — The Art of Concurrency book

To make breakfast, one person can boil eggs, make tea, and toast bread at the same time. However, they cannot drive to the grocery store and come back simultaneously. To make breakfast and buy groceries in parallel, you need at least two people.

A computer with a single CPU and a single thread can perform multiple tasks by quickly switching between them. However, to work on multiple jobs simultaneously, multiple threads are required. Each thread acts as a separate worker, allowing the CPU to allocate resources and process data more efficiently. By utilizing multiple threads, a computer can perform jobs in parallel, resulting in faster and more efficient processing.

Concurrency in C

To achieve concurrency in C#, you need to understand operating systems, threads, and the C# Asynchronous Pattern.

Multithreading

I won’t dive into how to work with threads in this article because we rarely deal with threads in day-to-day code in modern C#. Most of the time, we use the latest C# asynchronous pattern, TAP.

I recommend an excellent series of articles on csharptutorial.net:

Asynchronous Patterns

C# introduced three asynchronous patterns over its lifetime. First, in C# 1.0, there was the Asynchronous Programming Model (APM) pattern.

C# 2.0 introduced the Event-based Asynchronous Pattern (EAP).

Finally, in C# 5.0, we got the latest and greatest of them all: the Task Asynchronous Programming Model, or TAP.

Each pattern simplifies asynchronous programming compared to its predecessors. For those interested in the details, I recommend reading this comprehensive article from the .NET blog; it’s worth your time: How Async/Await Really Works in C#.

TAP consists of the following key components:

The Task class — represents an asynchronous operation.
The async / await keywords — define asynchronous methods and wait for the completion of asynchronous operations.
Task-based APIs — a set of classes that work seamlessly with the Task class and async/await keywords.

What You Should Know About TAP

State Machine

When you add the “async” keyword to a method, the compiler creates a state machine in the background. This handles concurrency and frees you from worrying about thread management. However, creating a state machine can be expensive, as the compiler generates a lot of code behind the scenes. Therefore, it’s essential to avoid creating unnecessary state machines.

Here are some best practices to keep in mind:

Only use “async” in a method when you have an “await” in the method body.
Don’t use “await” if you don’t need a value returned from a call to an asynchronous method. Just return the “Task” to the upstream caller.
If you need to use “async” but don’t need to use “await” to get a required value and want to return from the method, use “Task.FromResult”.
If you don’t want to return any value from the method, use “Task.CompletedTask”.
Avoid using “async void” methods.

Thread Synchronization

Thread synchronization in C# refers to the coordination and control of multiple threads to ensure their safe and orderly execution in a multi-threaded environment. It helps to prevent race conditions, data corruption, and other concurrency-related issues that can occur when multiple threads access shared resources concurrently.

Lock

In C#, the lock keyword is used to ensure mutual exclusion or thread synchronization in a multi-threaded environment. When multiple threads access a shared resource concurrently, using the lock keyword helps prevent race conditions and ensures that only one thread can access the critical section at a time.

The lock keyword is used in conjunction with a synchronization object, typically an instance of an object. When a thread encounters a lock statement, it attempts to acquire the lock on the specified object. If the lock is already held by another thread, the current thread waits until the lock is released before proceeding.

Deadlock

A deadlock is a situation where two or more threads are unable to proceed because each is waiting for a resource held by another thread in the deadlock group. This results in a circular dependency, causing all threads involved to be blocked indefinitely.

InterLocked

The Interlocked class provides atomic operations for variables shared among multiple threads. It offers thread-safe and atomic operations without the need for explicit locking mechanisms, such as lock or Monitor.

ReaderWriterLockSlim

The ReaderWriterLockSlim class provides a synchronization mechanism that allows multiple threads to read a shared resource simultaneously while ensuring exclusive access for writing. It is a more efficient alternative to the older ReaderWriterLock class, reducing the overhead associated with acquiring and releasing locks by using lightweight synchronization primitives.

SemaphoreSlim

The SemaphoreSlim class provides a synchronization primitive that controls access to a limited number of resources among multiple threads. It is a lightweight alternative to the Semaphore class and is useful in scenarios where you need to limit concurrent access to a shared resource.

Thread Signaling

Thread signaling in C# refers to the mechanism of communication and coordination between multiple threads to ensure synchronized execution or to notify each other about specific events or conditions.

In multi-threaded scenarios, it is often necessary for threads to wait for certain conditions before proceeding or for one thread to notify another about a particular event. This is where thread signaling comes into play.

AutoResetEvent

The AutoResetEvent class is a synchronization primitive that allows threads to wait until a signal is received and then automatically resets itself. It is a thread-signaling mechanism used for one-to-one thread coordination.

ManualResetEventSlim

The ManualResetEventSlim class is a lightweight synchronization primitive that provides thread-signaling functionality similar to ManualResetEvent. It allows threads to wait until a signal is received and remains in the signaled state until manually reset.

CountdownEvent

The CountdownEvent class is a synchronization primitive that allows one or more threads to wait until a specified number of signals or operations have been completed. It provides a way to synchronize the execution of multiple threads and coordinate their completion.

My take on distributed caching

Sajad Jalilian — Fri, 16 May 2025 10:12:37 +0000

Should I Use Distributed Caching?

Don’t

The best strategy for distributed caching is often not to use it!

It’s challenging to implement and adds complexity to your system. As we all know, complexity is the root of most problems in software development.

So, avoid it if possible.

Before considering distributed caching, focus on optimizing your application, database, connection, network, or even hardware. Use in-memory caching instead.

Use In-Memory Caching

At some point, you’ll need to consider caching to improve performance. Start by leveraging the internal in-memory caching mechanisms provided by your back-end framework, database caching, etc.

Believe it or not, most tools have built-in caching providers you can utilize.

In many cases, these simple optimizations can significantly improve your application's performance without the added complexity of distributed caching.

Distributed Caching Strategies

When to Use Distributed Caching

However, as your user base grows, you might need to take caching more seriously. This could mean adding a dedicated caching server or implementing a more complex distributed caching system.

Understand Your Workload

To implement caching effectively, you must thoroughly understand your application’s responsibilities and requirements.

Choosing the right caching pattern depends on your workload. For example, is your application write-heavy, read-heavy, or real-time?

Common Caching Strategies

Cache Aside

This is the most common caching strategy. Here, the cache works alongside the database to reduce database hits. Data is lazy loaded into the cache.

When a user requests specific data, the system first checks the cache. If the data is present, it’s returned directly. If not, the system fetches the data from the database, updates the cache, and returns the data to the user.

This strategy works well with read-heavy workloads, such as user profile data (e.g., name, account number) that isn’t frequently updated.

However, this approach can lead to inconsistencies between the cache and the database. To mitigate this, cached data is assigned a TTL (Time to Live), after which it’s invalidated.

Read-Through

This strategy is similar to Cache Aside but with one key difference: in Read-Through, the cache always stays consistent with the database. The cache library ensures consistency with the back-end.

Like Cache Aside, data is lazy loaded into the cache when first requested. Developers can also pre-load the cache with frequently requested data to reduce cache misses.

Write-Through

In this strategy, all data written to the database goes through the cache. When data is written to the database, the cache is updated simultaneously.

This ensures a high level of consistency between the cache and the database but adds some latency during write operations. This strategy is well-suited for write-heavy workloads, such as online multiplayer games.

Write-Back

Write-Back caching optimizes costs by writing data directly to the cache instead of the database. After a delay (based on business logic), the cache writes the data to the database.

This approach is ideal for applications with heavy write operations, as it reduces the frequency of database writes and associated costs.

However, if the cache fails before the database is updated, data loss can occur. This strategy is often combined with other caching strategies for optimal performance.

How to Implement Caching

Implementing caching depends on your chosen strategy. For example, when working with a database, you can create a unique key and cache data in Redis.

Here’s an example of caching in a service:

public async Task<int> CountByFilterAsync(ContentFilter filter)
{
    // Get cache
    var cacheKey = _prefixKey + "-CountByFilterAsync-" + filter;
    if (CacheHelper.IsEnabled(_cacheRepositoryOptions))
    {
        var cached = await _redisCacheEngine.GetAsync<int>(cacheKey);
        if (cached != null && cached != 0) return cached;
    }
    var query = _queryableDbSet;
    query = query.ApplyFilter(filter);
    var count = await query.CountAsync();
    // Set cache
    if (CacheHelper.IsEnabled(_cacheRepositoryOptions))
        await _redisCacheEngine.SetAsync(cacheKey, count, _ttlFromMinutes);
    return count;
}

Best Practices

Use the CQRS pipeline to set cache for Query requests and invalidate it for Command requests.
Implement the Cached Repository Pattern.
Use Event Sourcing to raise events after Commands and asynchronously handle them to invalidate the cache.

Nondeterministic Problem

Definition

Nondeterministic functions produce different outputs each time they’re called with the same input values (e.g., the _GETDATE() function).

For deterministic data that doesn’t change frequently, you can cache it and update or invalidate it when the database is updated.

For nondeterministic data (e.g., a list of contents), caching becomes more complex. For instance, if you cache the first page of content, it might no longer be accurate as data is added, updated, or deleted in the database.

The best approach for nondeterministic data is to use a TTL. Start with the shortest TTL you can afford and adjust it based on user behavior and requirements.

Redis and StackExchange.Redis

Redis allows you to search for keys with specific prefixes and invalidate them. However, this operation has a time complexity of O(n), which might not be ideal for large datasets. Fortunately, Redis is extremely fast.

As Redis docs state:

While the time complexity for this operation is O(N), the constant times are fairly low. For example, Redis running on an entry-level laptop can scan a 1 million key database in 40 milliseconds.

Key Invalidation

With StackExchange.Redis, you can invalidate keys by using the Keys method, which uses SCAN under the hood.

The _SCAN_ command allows incremental iteration, returning only a small number of elements per call. This makes it usable in production without the downsides of blocking commands like _KEYS_ or _SMEMBERS_.

You must iterate over all keys using a cursor, match the desired pattern, and delete the matched keys one by one.

Optimizing Performance

To improve performance, store all associated keys in a set and clear the set to invalidate everything at once.

The Problem with Aggressive Invalidation

Invalidating all keys matching a pattern can be inefficient. For example, updating one piece of content might result in deleting all keys associated with the content entity.

Instead, use TTL for nondeterministic data to avoid these issues. With this approach, unused query keys automatically expire after a short time, eliminating the need to find and invalidate associated keys manually. Calibrate the TTL for each endpoint to achieve optimal results.

Conclusion

Be cautious when implementing caching. Use a combination of these strategies to find a solution that works for your specific needs.

There are only two hard things in Computer Science: cache invalidation and naming things. — Phil Karlton

My Journey Through Python Virtual Environments

Sajad Jalilian — Fri, 16 May 2025 10:04:12 +0000

Since I started programming in Python, I was perfectly fine using its standard library tool, venv, for all my work. You can create a virtual environment using venv like this:

python -m venv <venv_name>

In the Python ecosystem, there are four well-known tools for creating virtual environments:

I won’t dive deep into the differences between these tools, as you can find excellent comparison articles elsewhere. For instance, this StackOverflow thread is quite useful.

A while ago, I started working on a project that required three different Python versions: 2.7, 3.3, and 3.8.

My main concern was finding a straightforward way to use, install, switch between, and create virtual environments for different Python versions.

Unfortunately, my favorite tool, venv, does not support specifying the Python version for a virtual environment. To use different Python versions, you first have to install the desired version and then use it to create the virtual environment. The bad news is that venv was introduced in Python 3.6, so it’s only available for 3.6 and later versions. :( As a result, I had to switch to the Virtualenv package.

To create a virtual environment with a specific Python version using virtualenv, you can do:

virtualenv venv --python=python2.7

Alternatively, you could use the shiny Pipenv tool to create virtual environments and enjoy its cool features. However, I found virtualenv to be good enough for my needs.

The Pain of Managing Python Versions

Over time, managing multiple Python versions became a major headache. I had to download old versions, build them, install them, and keep them organized.

I had previously used Conda environments, which allow you to install any Python version in an isolated environment. If a specified Python version isn’t already installed, Conda automatically downloads and installs it for you — no manual work needed.

To create a virtual environment with a specific Python version using Conda, you can do:

conda create -n myenv python=3.6

I was happy with Conda until I hit another roadblock. It turned out that Conda doesn’t support Python 3.3.7, which I needed for my project. In fact, Conda’s Python version support is much more limited compared to pyenv, even though Conda uses pyenv under the hood.

So, once again, I had to try a new tool: my new favorite, pyenv.

Enter `pyenv` and `pyenv-virtualenv`

RealPython has an excellent article about using pyenv (check it out here). With pyenv, you can easily install and manage different Python versions. Its plugin, pyenv-virtualenv, allows you to work with virtual environments effortlessly, similar to Conda environments but with more flexibility.

My Recommendations

Having used all of these tools, I can say that each has its pros and cons. Here’s my advice:

If you don’t care about Python versions earlier than 3.6 and don’t need to install more than three different Python versions for the rest of your life, just use the Standard library venv.
If Conda environments support all the Python versions you need, go for it.
If you’re like me and need to use ancient Python versions and expect to add even more in the future, use pyenv and pyenv-virtualenv to save yourself a lot of headaches.
Finally, you can use Pipenv for entirely different reasons. The good news is that you can also use it alongside pyenv (read more here).

Final Thoughts

This is my first English article, so I apologize for any mistakes. Google Docs helped me catch many of my errors in spelling and grammar. I’m learning every day and hope to improve over time.