Structs are C#'s "value types": they behave like numbers, not like objects. That single difference (copy-by-value) gives you performance wins in the right places, and surprising bugs in the wrong ones. This post covers when structs shine, where they bite, and how to avoid the common gotchas.
Equality is a story about intent. Are two instances the same thing in memory, or do they merely carry the same data? Getting that line right keeps dictionaries stable, sets duplicate-free, and tests trustworthy.
Events look like their own language feature, but they’re just delegates with a safety wrapper. Even if you mostly use async streams or IObservable these days, knowing how events are lowered helps you reason about legacy code and avoid subtle bugs.
Delegates are type-safe references to methods and form the foundation of callbacks, events, and LINQ. In this post, we explore how delegates work under the hood, when to use built-in types like Action, Func, and Predicate, and when it makes sense to define your own delegate types. Clear examples show how LINQ operators (Where, Select, OrderBy) internally rely on delegates to enable flexible and expressive data processing.
When working with multithreaded applications, synchronization is essential to ensure that shared data is accessed safely. Without proper synchronization, threads can interleave unpredictably, leading to data corruption, race conditions, or inconsistent results. In this post, we’ll explore the main synchronization primitives in .NET: lock (Monitor), Semaphore, SemaphoreSlim, Interlocked, and ReaderWriterLockSlim.
Async and await make asynchronous programming feel simple — but there’s a lot happening behind the scenes. In this post, we’ll explore how the compiler rewrites async methods, what state machines and continuations are, and how to build one manually without using async/await.
Every allocation has a cost — but not all of them are obvious. In this post, we explore hidden heap allocations in C#: enumerators, boxing, closures, arrays, and strings. Learn how to spot them, measure them, and write allocation-free code.
Learn how Span<T>, Memory<T>, and their readonly variants enable high-performance, allocation-free data access in C#. We’ll explore when to use each, how they differ from arrays, and how ReadOnlySequence<T> powers streaming scenarios.
Generics provide type safety and performance in C#. In this post, we explore constraints, the Curiously Recurring Template Pattern (CRTP), and static abstract members in interfaces — advanced tools that make your APIs more reusable, expressive, and future-proof.
Extension methods look like they extend types, but they’re just static methods with special syntax. In this post, we’ll see how the compiler rewrites them, how they differ from instance methods, and why LINQ depends on them.