C# Application Performance Optimization: Best Practices for .NET

Introduction: Why C# Performance Matters

In the modern world of software development, application speed directly impacts user experience, infrastructure costs, and product competitiveness. The .NET platform and C# language provide powerful tools for creating high-performance systems, however, incorrect use of features (for example, uncontrolled memory management or inefficient algorithms) can lead to serious delays and excessive resource consumption. In this article, we will break down key techniques for optimizing the performance of C# applications that will help you write faster and more efficient code.

1. Profiling: Find the Bottleneck Before Optimizing

Before making changes, it is necessary to accurately determine where the most time is spent. Without profiling, you risk optimizing what is already fast, missing the real bottlenecks.

Profiling Tools

• Visual Studio Diagnostic Tools — a built-in profiler for analyzing CPU, memory, and exceptions.
• dotMemory — a powerful tool for analyzing memory management and finding leaks.
• PerfView — a free tool from Microsoft for deep .NET performance analysis.
• BenchmarkDotNet — a library for micro-benchmarking individual code sections.

Example of using BenchmarkDotNet to measure the speed of two methods:

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class StringBenchmark
{
    private string[] data = Enumerable.Range(0, 1000).Select(i => $"Item {i}").ToArray();

    [Benchmark]
    public string ConcatenateWithPlus()
    {
        string result = "";
        foreach (var s in data) result += s;
        return result;
    }

    [Benchmark]
    public string ConcatenateWithStringBuilder()
    {
        var sb = new System.Text.StringBuilder();
        foreach (var s in data) sb.Append(s);
        return sb.ToString();
    }
}

// Run: BenchmarkRunner.Run<StringBenchmark>();

The benchmark results will clearly show that StringBuilder is tens of times faster than concatenation using + in loops.

2. Memory Management and Reducing GC Pressure

The Garbage Collector (GC) is a powerful mechanism, but its frequent operation can negatively impact performance, especially in high-load systems. The main goal is to minimize the number of allocations and the lifetime of objects.

2.1. Using Structs Instead of Classes

If an object is small (less than 16-24 bytes) and has a short lifetime, consider using a struct. Structs are stored on the stack (or embedded in the parent object) and do not create GC pressure.

// Class — heap allocation
public class PointClass
{
    public int X { get; set; }
    public int Y { get; set; }
}

// Struct — on the stack
public struct PointStruct
{
    public int X;
    public int Y;
}

2.2. Object Pooling

For frequently created and destroyed objects (e.g., database connections, buffers), use a pool. .NET Core has a built-in implementation ObjectPool<T>.

using Microsoft.Extensions.ObjectPool;

var pool = new DefaultObjectPool<List<int>>(new ListPolicy());
var list = pool.Get();
try
{
    // Work with the list
}
finally
{
    pool.Return(list); // Return to the pool
}

2.3. Span<T> and Memory<T>

These types allow working with contiguous memory regions without additional allocations. They are ideal for parsing, working with arrays and strings.

public int SumDigits(ReadOnlySpan<