Tips, tricks and quirks in .NET

That simple LINQ refactoring your IDE suggests could make your code five times slower. Discover which common .NET 'optimizations' to avoid.

#1about 2 minutes

The surprising internal structure of generic lists

The generic `List<T>` in .NET is not a linked list but is implemented as a resizable array, which has important performance implications.

#2about 4 minutes

Comparing the performance of for and foreach loops

While `for` loops were historically faster, optimizations in .NET 7 have made `foreach` performance nearly identical due to reduced enumerator overhead.

#3about 4 minutes

Why `Where().Count()` is faster than `Count(predicate)`

Using `Count()` with a predicate is significantly slower than chaining `Where()` and `Count()` because it results in a virtual method call instead of an instance method call.

#4about 4 minutes

When not to use `StringBuilder` for concatenation

`StringBuilder` is not always the fastest option for joining strings; for a small number of short strings, simple concatenation with `+` can be more performant due to `StringBuilder`'s resizing overhead.

#5about 3 minutes

The difference between `string.Empty` and an empty literal

Despite generating different IL code, `string.Empty` and the `""` literal compile to identical assembly instructions and have the same performance, with the only difference being compile-time usage constraints.

#6about 5 minutes

Safer null checking and the risk of operator overloading

Using the `==` operator for null checks is unsafe because it can be overloaded; the `is null` pattern should be used instead to avoid unexpected behavior.

#7about 4 minutes

How to terminate an application instantly

The `Environment.FailFast` method immediately terminates an application without executing `catch` or `finally` blocks, making it a drastic way to handle catastrophic failures.

#8about 4 minutes

Understanding the default banker's rounding in .NET

The `Math.Round` method in .NET uses banker's rounding by default, which rounds values ending in .5 to the nearest even integer, a behavior that can be surprising.