C# code performance optimization requires tools rather than intuition. BenchmarkDotNet is the first choice for benchmarking. 1. Automatically handle JIT warm-up and GC effects by scientifically comparing the execution efficiency of different methods; 2. Profiling using tools such as Visual Studio, dotTrace or PerfView to find the truly time-consuming "hot spot" functions; 3. Pay attention to memory allocation, combine [MemoryDiagnoser], Diagnostic Tools and PerfView to analyze GC pressure, reduce object creation in high-frequency paths, and give priority to using structures or pooling technology to reduce GC burden.

It is often not possible to write codes by relying on them alone. As a high-level language, although CLR and GC help you handle a lot of things, performance issues still have to be spoken by tools. If you want to optimize performance, you must first know where the bottleneck is, which is inseparable from benchmarking and profiling.

Use Benchmark to measure performance differences

Benchmark does not let you run a loop and see the time, but rather scientifically compare the execution efficiency of different methods. The most recommended way is to use BenchmarkDotNet , a benchmark test library designed specifically for .NET, which can automatically handle JIT preheating, GC impact and other issues.

For example, if you want to compare the speed difference between List<t></t> and Span<t></t> in data processing, you can write two methods and then let BenchmarkDotNet run:

 [Benchmark]
public void UseList()
{
    var list = new List<int>();
    for (int i = 0; i < 10000; i ) list.Add(i);
}

[Benchmark]
public void UseSpan()
{
    Span<int> span = stackalloc int[10000];
    for (int i = 0; i < 10000; i ) span[i] = i;
}

After running, you will see clear statistical results, including average time consumption, memory allocation and other indicators. This is very important in determining whether performance improvements are real or effective.

Tips:

• Avoid doing I/O operations or network requests in Benchmark, which can easily interfere with the results.
• Turn off the debugger (Release mode) before testing, otherwise the performance data will be distorted.
• Run multiple times to average the value to avoid interference from accidental factors.

Profiling finds out real performance hotspots

Benchmark is suitable for comparing small pieces of code, but if your application is stuttered overall, you have to use profiling to find the "hot spot" function. Commonly used tools are:

• Visual Studio built-in performance profiler
• dotTrace (produced by JetBrains)
• PerfView (Microsoft open source free)

Taking Visual Studio as an example, you can directly click on the CPU usage in the "Diagnostic Tools". After running the program for a period of time, you can see the most time-consuming method in the call stack. You will find that sometimes you think the slowness is not slow, but what really drags on you is an inconspicuous loop or frequent string splicing.

To give a common example:
When parsing JSON, you used Newtonsoft.Json 's JObject.Parse() and found that it took more than 30% of the CPU time. At this time, you can consider changing to System.Text.Json , or cache the parsing results to reduce duplicate calls.

Notes:

• Try to do profiling under hardware and loads close to the production environment.
• Performance performance may be different on different platforms (such as Windows and Linux).
• Profiling will affect the running speed of the program, so it cannot be turned on for a long time.

Pay attention to the impact of GC and memory allocation

One of the advantages of C# is that there is GC that automatically manages memory, but it can also become a performance bottleneck. Frequent small object allocation will cause GC to be triggered frequently, especially Gen2 recycling, which will significantly slow down the program.

Memory allocation can be observed in the following ways:

• Add the [MemoryDiagnoser] feature to the BenchmarkDotNet to directly see how much memory is allocated for each call.
• View memory trend charts using Visual Studio's "Diagnostic Tools".
• PerfView can also display GC events and stack information in detail.

A common optimization point is to use Span<t></t> , MemoryPool<t></t> or ArrayPool<t></t> to multiplex buffers to reduce GC pressure. For example, when receiving data packets in network communication, it is better to apply for a byte array repeatedly than to pre-allocate the pool.

Suggested practices:

• Reduce object creation in high-frequency paths.
• Scenarios where the object's life cycle is short but frequently called, structure or pooling technology is preferred.
• Check the GC recycling frequency, especially the number of Gen2 times. If it is too high, be vigilant.

The above are some basic methods for C# code performance testing and optimization. After all, performance optimization is not based on guessing, but on testing. As long as you master the correct tools and methods, many problems can be solved easily.

The above is the detailed content of Benchmarking and Profiling C# Code Performance. For more information, please follow other related articles on the PHP Chinese website!