Turbocharged: Writing High-Performance C# and .NET Code

We took a file parsing operation from 7 GB of memory down to 250 MB. Learn the modern .NET I/O techniques that made it possible.

#1about 2 minutes

Defining performance metrics for .NET applications

Performance is defined by three key metrics: execution time, throughput, and memory allocations, which influence garbage collection frequency.

#2about 1 minute

Adopting a scientific approach to code optimization

Follow a simple, iterative cycle of measuring with data, optimizing a small part of the code, and then measuring again to validate improvements.

#3about 2 minutes

Choosing the right tools for performance measurement

Use tools like Visual Studio diagnostic tools for profiling and Benchmark.NET for precise micro-benchmarking of specific code paths.

#4about 2 minutes

Getting started with Benchmark.NET for micro-benchmarking

Benchmark.NET is an open-source library that provides high-precision measurements for small units of code by handling warm-up and statistical analysis.

#5about 3 minutes

Understanding Span<T> for efficient memory operations

Span<T> provides a type-safe, read/write view over a contiguous region of memory, such as arrays or stack-allocated memory, without new allocations.

#6about 4 minutes

Using Span<T> slicing to optimize array operations

Slicing a span creates a new view over a portion of the original data in constant time, avoiding the overhead of creating new arrays and copying data.

#7about 2 minutes

Parsing strings without allocations using ReadOnlySpan<char>

Create a `ReadOnlySpan<char>` from a string to parse it by slicing, which avoids creating new substring allocations and reduces memory pressure.

#8about 3 minutes

Navigating Span<T> limitations with Memory<T>

Since `Span<T>` is a stack-only `ref struct`, use the `Memory<T>` type in heap-based scenarios like async methods, then get a span from it when needed.

#9about 4 minutes

Case study: Optimizing S3 object key generation

A practical example shows how replacing string arrays and regex with `Span<T>` and stack allocation dramatically reduced memory allocations from 1KB to 192 bytes per operation.

#10about 2 minutes

Reusing temporary buffers with ArrayPool

Use `ArrayPool<T>` to rent and return temporary arrays, which reduces garbage collection pressure by reusing buffers instead of allocating new ones repeatedly.

#11about 2 minutes

Implementing high-performance I/O with System.IO.Pipelines

System.IO.Pipelines simplifies efficient stream processing by managing buffers from an `ArrayPool`, allowing you to work with data as it becomes available.

#12about 4 minutes

Case study: Parsing large files with pipelines

By replacing a library that loaded an entire file into memory with a pipeline-based parser, allocations were reduced from over 7.2 GB to 242 MB.

#13about 2 minutes

Making the business case for performance optimization

Translate performance gains like reduced allocations and increased throughput into monetary value, such as lower infrastructure costs, to get buy-in from stakeholders.

#14about 3 minutes

Summary of key principles for high-performance code

Always measure your code, focus on hot paths, avoid memory copies by using `Span<T>`, and consider `ArrayPool` and `Pipelines` for I/O-heavy scenarios.

#15about 4 minutes

Q&A: Span to array costs and using ValueTasks

The Q&A covers the cost of converting a span back to an array and discusses when to use `ValueTask` over `Task` to avoid allocations in synchronous completion paths.