Records are C#'s built-in value-semantics types for modeling data. They look like classes, but the compiler wires up value equality, deconstruction, and with expressions for you. That power is great when you want immutable "data carriers", and risky when you treat them like mutable objects. This post explains where records help, where they hurt, and how to control the generated members.
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.