50 个 C#（高级）性能优化技巧🔥

作为一名经验丰富的 C# 开发人员，您一直在寻找提升应用程序性能的方法。好消息！您来对地方了。

本文将探讨 50 个绝妙的 C# 性能优化技巧，帮助您优化代码，确保应用程序流畅运行。从内存管理到并行计算，我们将涵盖您需要了解的关于 C# 优化的方方面面。

那么，让我们直接进入正题，释放 C# 应用程序的全部潜力吧！

内存管理和垃圾回收

在本节中，我们将介绍在 C# 应用程序中处理内存和减少垃圾回收开销的有效策略。

内存管理和垃圾回收是 C# 性能调优的重要方面，因此这些最佳实践将帮助您优化代码，从而实现最高效率。

利用 IDisposable 接口

使用 IDisposable 接口是提升 C# 性能的关键技巧。它可以帮助您正确管理非托管资源，并确保应用程序的内存使用效率。

糟糕的方式：

public class ResourceHolder
{
    private Stream _stream;

    public ResourceHolder(string filePath)
    {
        _stream = File.OpenRead(filePath);
    }

    // Missing: IDisposable implementation
}

上述错误情况中，ResourceHolder 类没有实现 IDisposable 接口，这意味着未托管的资源可能不会被释放，从而导致潜在的内存泄漏。

好方法：

public class ResourceHolder : IDisposable
{
    private Stream _stream;

    public ResourceHolder(string filePath)
    {
        _stream = File.OpenRead(filePath);
    }

    public void Dispose()
    {
        _stream?.Dispose(); // Properly disposing the unmanaged resource.
    }
}

通过实现该IDisposable接口，您可以确保在不再需要时释放非托管资源，从而防止内存泄漏并减轻垃圾回收器的压力。

这是 C# 中开发者应该利用的一种基本代码优化技巧。

避免过早优化

过早优化可能会适得其反，使你的 C# 代码更难阅读、维护和扩展。因此，首先应该专注于编写简洁高效的代码，只有在对应用程序进行全面分析后，才应在必要时进行优化。

糟糕的方式：

private void ProcessData()
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();

    // [Complex processing logic with unnecessary micro-optimizations]

    stopwatch.Stop();
    Console.WriteLine($"Processing time: {stopwatch.ElapsedMilliseconds} ms");
}

上述错误方法过于注重微优化，这会导致代码复杂、混乱，为了微不足道的性能提升而牺牲可维护性。

好方法：

private void ProcessData()
{
    // [Straightforward processing logic without premature optimization]

    // Optimize only if necessary, and only after profiling and identifying bottlenecks.
}

过早优化会增加代码的维护难度，而且可能对整体性能提升不大。因此，应该专注于编写简洁明了的代码，然后在进行全面的性能分析后，仅在必要时才进行优化。

这种方法将带来更易于维护和性能更高的 C# 应用程序。

使用 async/await 进行异步编程

异步编程是一种强大的技术，可以提升 C# 在 I/O 密集型操作中的性能，从而增强应用程序的响应速度和效率。本文将探讨C# 中async/ await的一些最佳实践。

限制并发操作的数量

管理并发对于 C# 性能优化至关重要。通过限制应用程序中的并发操作数量，可以帮助降低系统的整体负载。

糟糕的方式：

public async Task ProcessManyItems(List<string> items)
{
    var tasks = items.Select(async item => await ProcessItem(item));
    await Task.WhenAll(tasks);
}

不好的做法是，每个项目都会同时生成多个任务，而没有适当的限制，这可能会给系统造成很大的压力。

好方法：

public async Task ProcessManyItems(List<string> items, int maxConcurrency = 10)
{
    using (var semaphore = new SemaphoreSlim(maxConcurrency))
    {
        var tasks = items.Select(async item =>
        {
            await semaphore.WaitAsync(); // Limit concurrency by waiting for the semaphore.
            try
            {
                await ProcessItem(item);
            }
            finally
            {
                semaphore.Release(); // Release the semaphore to allow other operations.
            }
        });

        await Task.WhenAll(tasks);
    }
}

如果不限制并发数，许多任务将同时运行，这会导致系统负载过重，整体性能下降。因此，应该使用并发数限制SemaphoreSlim来控制并发操作的数量。

这是一个如何在不牺牲可读性和可维护性的前提下提高 C# 应用程序性能的绝佳示例。

尽可能使用ConfigureAwait(false)

ConfigureAwait(false) 是一个有价值的 C# 性能技巧，它可以帮助防止异步代码中的死锁，并通过不强制延续在原始同步上下文中运行来提高效率。

糟糕的方式：

public async Task<string> LoadDataAsync()
{
    var data = await ReadDataAsync();
    return ProcessData(data);
}

上述错误方法未使用 ConfigureAwait(false)，这在某些情况下存在潜在的死锁风险。

好方法：

public async Task<string> LoadDataAsync()
{
    var data = await ReadDataAsync().ConfigureAwait(false); // Use ConfigureAwait(false) to avoid potential deadlocks.
    return ProcessData(data);
}

ConfigureAwait(false)有助于避免异步代码中潜在的死锁，并通过不强制延续操作在原始上下文中运行来提高效率。在安全的情况下使用它，通常用于库代码和非 UI 应用程序。

这是一个 C# 性能调优的实际示例，可以对应用程序的整体响应速度和稳定性产生显著的积极影响。

并行计算和任务并行库（TPL）

并行计算可以帮助你充分利用多核处理器的强大功能，加速 CPU 密集型操作，最终提升 C# 应用程序的性能。接下来，我们将探讨一些在 C# 中充分利用并行计算的技巧。

使用 Parallel.For() 和 Parallel.ForEach() 实现并行循环

糟糕的方式：

private void ProcessData(List<int> data)
{
    for (int i = 0; i < data.Count; i++)
    {
        PerformExpensiveOperation(data[i]);
    }
}

上述糟糕的方法for是使用标准循环来处理数据采集，导致操作顺序执行。这没有充分利用现代多核CPU的全部潜力。

好方法：

private void ProcessData(List<int> data)
{
    Parallel.ForEach(data, item => PerformExpensiveOperation(item));
}

并行循环通过将工作负载分配到多个 CPU 核心，可以显著加速大型集合的处理。只要可行且安全，就应将常规for循环替换为其并行版本。这是一个利用并行计算技术大幅提升 C# 代码速度的绝佳示例。foreach

使用 Partitioner 类可以实现高效的工作负载分配

糟糕的方式：

private void ProcessData(IEnumerable<int> data)
{
    Parallel.ForEach(data, item => PerformExpensiveOperation(item));
}

上述糟糕的方法没有特别考虑如何优化并行任务间的工作负载划分。这可能会导致潜在的开销和负载分配不均。

好方法：

private void ProcessData(IEnumerable<int> data)
{
    var partitioner = Partitioner.Create(data);
    Parallel.ForEach(partitioner, item => PerformExpensiveOperation(item));
}

通过使用该类Partitioner，您可以有效地将工作负载分配到多个块中，从而减少潜在的开销并改善并行任务之间的负载均衡。

分区器创建最佳工作块，以最大限度地减少任务同步的开销，从而提高 C# 应用程序的性能和工作负载分配。

缓存数据的重要性

缓存可以通过减少获取和处理数据所需的时间，显著提升应用程序性能。在本节中，我们将讨论一些有效的缓存技术及其在 C# 代码优化中的正确实现方法。

使用内存缓存实现数据缓存

利用内存缓存可以大幅减少耗时的数据库检索，从而加快应用程序的运行速度。

糟糕的方式：

public Product GetProductById(int id)
{
    // Fetching product data from the database every time
    var product = _dbContext.Products.FirstOrDefault(p => p.Id == id);
    return product;
}

上述错误的做法是，每次调用该方法时都会从数据库中获取产品数据。这会导致严重的性能下降，尤其是在数据库位于远程位置或负载较高的情况下。

好方法：

private static MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());

public Product GetProductById(int id)
{
    // Fetching product data from the cache if available
    if (!_cache.TryGetValue(id, out Product product))
    {
        product = _dbContext.Products.FirstOrDefault(p => p.Id == id);
        _cache.Set(id, product, TimeSpan.FromMinutes(30));
    }
    return product;
}

这种良好方法展示了如何使用内存缓存来存储产品数据，从而减少耗时的数据库检索。利用MemoryCache内存缓存来缓存频繁请求的数据，可以提高性能。

这是一种 .NET 性能优化技术，有助于加快数据检索速度并降低数据库服务器的负载。

使用分布式缓存系统（例如 Redis）实现缓存。

分布式缓存系统（例如 Redis）可以通过跨多个服务器扩展并提供高可用性的方式缓存数据，从而进一步提高应用程序的性能。

糟糕的方式：

public List<Product> GetPopularProducts()
{
    // Fetching popular product data from the database every time
    var popularProducts = _dbContext.Products.Where(p => p.IsPopular).ToList();
    return popularProducts;
}

上述错误的方法每次调用该方法时都会从数据库中检索热门产品数据，导致不必要的数据库检索操作，从而降低性能。

好方法：

private static IDistributedCache _distributedCache;

public List<Product> GetPopularProducts()
{
    // Fetching popular product data from the distributed cache if available
    string cacheKey = "popularProducts";
    string cachedProducts = _distributedCache.GetString(cacheKey);

    if (cachedProducts == null)
    {
        var popularProducts = _dbContext.Products.Where(p => p.IsPopular).ToList();
        _distributedCache.SetString(cacheKey, JsonConvert.SerializeObject(popularProducts), new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30)
        });
        return popularProducts;
    }
    else
    {
        return JsonConvert.DeserializeObject<List<Product>>(cachedProducts);
    }
}

这种最佳实践展示了如何使用 Redis 实现分布式缓存来存储热门产品数据，从而减少数据库读取次数。采用 Redis 等分布式缓存系统，可以在多个服务器上进行缓存，并提高应用程序的可扩展性。

使用 Redis，您可以优化 C# 代码，即使应用程序运行在多个服务器上，也能确保快速数据访问。

并发性和线程安全性

并发管理是开发高质量 C# 应用程序的基础。确保线程安全可以防止出现不必要的错误和性能问题，因此让我们来探讨一些最佳实践。

尽可能使用无锁数据结构

选择无锁数据结构（例如ConcurrentBag，ConcurrentQueue或ConcurrentDictionary）可以帮助你在多线程场景中保持线程安全，而不会牺牲性能。

糟糕的方式：

private readonly object _syncRoot = new object();
private readonly List<int> _list = new List<int>();

public void Add(int item)
{
    lock (_syncRoot)
    {
        _list.Add(item);
    }
}

上述错误用法中，lock关键字用于同步对列表的访问，这可能导致争用和性能下降。

好方法：

private readonly ConcurrentBag<int> _bag = new ConcurrentBag<int>();

public void Add(int item)
{
    _bag.Add(item);
}

通过使用无锁数据结构（例如ConcurrentBag，ConcurrentQueue或ConcurrentDictionary），可以最大限度地减少争用，提高性能，并在多线程场景中确保线程安全。

使用高效的同步结构

利用高效的同步结构，例如SemaphoreSlim，ReaderWriterLockSlim或Monitor，可以帮助您保护共享资源并维护线程安全，同时最大限度地减少争用和性能影响。

糟糕的方式：

private readonly object _syncRoot = new object();
private readonly List<int> _list = new List<int>();

public void Add(int item)
{
    lock (_syncRoot)
    {
        _list.Add(item);
    }
}

上述错误用法中，lock关键字再次被用于同步。这会导致争用，并对性能产生负面影响。

好方法：

private readonly SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);
private readonly List<int> _list = new List<int>();

public async Task AddAsync(int item)
{
    await _semaphoreSlim.WaitAsync();
    try
    {
        _list.Add(item);
    }
    finally
    {
        _semaphoreSlim.Release();
    }
}

SemaphoreSlim像 `std::undefined` 、ReaderWriterLockSlim`std::undefined` 或 `std::undefined`这样的高效同步结构，Monitor可以保护共享资源并确保线程安全，同时最大限度地减少争用和性能开销。

根据应用程序的需求选择最合适的同步结构，并谨慎使用，以避免潜在的性能瓶颈。

使用 Interlocked 类来实现原子操作

使用该类Interlocked，您可以执行简单的原子操作而无需依赖锁，从而减少争用并提高性能。

糟糕的方式：

private int _counter;
private readonly object _syncRoot = new object();

public void IncrementCounter()
{
    lock (_syncRoot)
    {
        _counter++;
    }
}

上述错误用法中，lock关键字被用来确保计数器递增期间的线程安全。然而，这可能会导致线程争用和性能下降。

好方法：

private int _counter;

public void IncrementCounter()
{
    Interlocked.Increment(ref _counter);
}

该类Interlocked允许你在不使用锁的情况下执行简单的原子操作，从而提高性能并减少争用。对于递增、递减或加法等操作，应尽可能使用它。

理解和优化 LINQ 性能

LINQ是一个强大的工具，但如果使用不当，可能会影响性能。在本节中，我们将探讨一些技巧和窍门，以优化 C# 应用程序中 LINQ 的使用。

了解延迟执行和立即执行之间的区别

了解延迟执行和立即执行，可以更好地控制 LINQ 查询的执行时间，同时避免潜在的性能问题。

糟糕的方式：

public IEnumerable<int> GetEvenNumbers(IEnumerable<int> numbers)
{
    var evens = numbers.Where(n => n % 2 == 0);

    // Do some other work

    return evens;
}

上述错误方式会延迟 LINQ 查询的执行，如果返回的IEnumerable值被多次枚举，则可能导致冗余的查询执行。

好方法：

public IReadOnlyList<int> GetEvenNumbers(IEnumerable<int> numbers)
{
    var evens = numbers.Where(n => n % 2 == 0).ToList();

    // Do some other work

    return evens;
}

了解延迟执行和立即执行有助于您控制 LINQ 查询的执行时间，并避免潜在的性能问题。必要时，可以使用ToList()`if` 或 `if`强制立即执行。ToArray()

尽可能选择查询语法而不是方法语法。

选择查询语法而不是方法语法可以生成更易读、更易维护的代码，尤其是在处理复杂查询时。

糟糕的方式：

var query = items.Select(item => new { PropertyName = item.SomeProperty });

上述错误的做法是使用方法语法来表达查询，如果查询更复杂，就会变得难以阅读。

好方法：

var query = from item in items
            select new { PropertyName = item.SomeProperty };

使用查询语法而非方法语法可以编写出更易读、更易维护的代码，尤其是在处理复杂查询时。尽可能使用查询语法。

在多线程环境下使用 LINQ 时，请注意潜在的陷阱

在并行场景中使用 LINQ 时需要谨慎，以避免与线程安全和性能瓶颈相关的潜在问题。

糟糕的方式：

Parallel.ForEach(items, item =>
{
    var matchingItems = items.Where(i => i.Name == item.Name);
    Process(matchingItems);
});

上述错误方法是，多个线程枚举IEnumerableLINQ 查询的相同结果，这可能会导致不可预测的行为。

好方法：

Parallel.ForEach(items, item =>
{
    // Create a separate LINQ query for each parallel operation
    var matchingItems = items.AsParallel().Where(i => i.Name == item.Name);
    Process(matchingItems);
});

在并行场景中使用 LINQ 需要特别注意，以避免潜在问题，例如线程安全和性能瓶颈。采用AsParallel()扩展方法来确保安全性和并行性。

微优化和即时编译

C# 代码中的微优化看似微不足道，却能显著提升性能。接下来，我们将探讨一些优化代码的技巧。

执行循环展开以获得更好的性能

循环展开可以通过减少循环控制结构的开销来加快代码执行速度。但是，应谨慎使用循环展开，因为过度的循环展开会对代码的可读性和可维护性产生负面影响。

糟糕的方式：

for (int i = 0; i < array.Length; i++)
{
    array[i] = i * 2;
}

上述错误方法是使用一个简单的循环遍历数组中的每个元素，导致循环控制结构开销过高。

好方法：

int len = array.Length;
for (int i = 0; i < len; i += 4)
{
    array[i] = i * 2;
    array[i + 1] = (i + 1) * 2;
    array[i + 2] = (i + 2) * 2;
    array[i + 3] = (i + 3) * 2;
}

循环展开可以通过减少循环控制结构的开销来加快代码执行速度。但是，应谨慎使用循环展开，因为过度展开会影响代码的可读性和可维护性。

对关键方法使用激进的内联属性

通过为关键方法添加该AggressiveInlining属性，您可以指示 JIT 编译器将它们内联，从而减少方法调用的开销，进而提高性能。

糟糕的方式：

private int MultiplyByTwo(int value)
{
    return value * 2;
}

上述错误方法中，该方法未标记该AggressiveInlining属性，因此在 JIT 编译期间可能不会内联，从而导致执行速度可能变慢。

好方法：

[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int MultiplyByTwo(int value)
{
    return value * 2;
}

通过为关键方法添加该AggressiveInlining属性，您可以指示 JIT 编译器将它们内联，从而减少方法调用的开销，进而提高性能。

栈分配与堆分配

理解栈分配和堆分配的区别对于 C# 性能优化至关重要。让我们探讨一些高效分配内存的技巧，这些技巧可以帮助您显著提升代码运行速度。

尽可能限制堆分配对象的使用。

糟糕的方式：

private string GetUserName(int index)
{
    return new string($"User{index}".ToCharArray());
}

使用new关键字创建字符串对象会引入堆分配，并增加垃圾回收开销，从而对应用程序的整体性能产生负面影响。

好方法：

private string GetUserName(int index)
{
    return $"User{index}";
}

通过直接返回插值字符串，我们可以避免堆分配，减少垃圾回收带来的开销，从而提高 C# 代码的性能。

了解何时使用 stackalloc 关键字进行内存分配

糟糕的方式：

private double CalculateSum(double[] values)
{
    double sum = 0;
    for (int i = 0; i < values.Length; i++)
    {
        sum += values[i];
    }
    return sum;
}

这里的错误代码示例使用了双精度数组参数，该参数可能会分配在堆上，从而增加垃圾回收的开销并影响 .NET 的性能。

好方法：

private unsafe double CalculateSum(int count)
{
    double sum = 0;
    double* values = stackalloc double[count]; // Allocate memory on the stack
    for (int i = 0; i < count; i++)
    {
        sum += values[i];
    }
    return sum;
}

通过使用这种方式stackalloc，我们可以高效地在栈上分配内存，从而减少对堆和垃圾回收器的依赖。这有助于提升 .NET 的性能，并有可能加快代码执行速度。

高效数据结构与算法

选择合适的数据结构和算法会直接影响 C# 的性能。让我们来探讨一些技巧，以便在使用 .NET Core 和 C# 编写高性能代码时做出更好的选择。

根据您的需求选择合适的数据结构

糟糕的方式：

List<int> userList = new List<int>();

使用内存List来存储用户标识符会引入性能瓶颈，尤其是在需要频繁查找时。

好方法：

HashSet<int> userList = new HashSet<int>();

选择 AHashSet而不是 BList可以加快查找速度并提高性能。识别合适的数据结构对于高效的 C# 编码和解决 .NET 性能问题至关重要。

针对特定用例采用自定义排序算法

糟糕的方式：

double[] values = { 3.14, 1.61, 2.72 };
Array.Sort(values);

对于某些以性能为中心的特定用例，依赖默认排序算法可能并非最佳选择。

好方法：

double[] values = { 3.14, 1.61, 2.72 };
CustomSortAlgorithm.Sort(values);

采用自定义排序算法可以显著提升 C# 代码的性能，因为它允许您根据特定需求进行优化。这样，您就可以开发出更适合您使用场景的高性能代码。

反思与代码生成

反射和代码生成是 C# 中强大的工具，但使用不当会降低应用程序的运行速度。让我们深入探讨一些最佳实践，以优化它们的使用并避免 .NET 性能问题。

避免过度使用反射 API

糟糕的方式：

Type userType = typeof(User);
object user = Activator.CreateInstance(userType);

糟糕的代码示例利用ReflectionAPI 进行对象实例化，这会带来明显的性能损失。

好方法：

通过使用构造函数直接创建一个新对象，可以减少与反射 API 相关的运行时开销，从而提高 C# 的性能。

使用动态生成的 lambda 表达式而不是反射

糟糕的方式：

private static void SetPropertyViaReflection(object obj, PropertyInfo property, object value)
{
    property.SetValue(obj, value);
}

使用反射设置属性值时，由于处理该操作需要额外的开销，C# 的性能会受到影响。

好方法：

private static void SetPropertyViaExpression(object obj, PropertyInfo property, object value)
{
    var setter = property.SetMethod.CreateDelegate(typeof(Action<,>).MakeGenericType(property.DeclaringType, property.PropertyType));
    ((dynamic)setter)(obj, value);
}

动态生成 lambda 表达式而非使用反射可以显著提升性能。通过采用即时 (JIT) 编译器优化，您可以利用 .NET Core 和 C# 实现高性能编码。

使用 System.Numerics 的 SIMD（单指令多数据流）

SIMD 可以通过并行处理多个数据元素来显著提高性能。让我们来探讨如何在 C# 应用程序中利用 SIMD，从而使用 .NET Core 和 C# 实现高性能编码。

利用 Vector 充分发挥 SIMD 指令的强大功能

糟糕的方式：

private void Normalize(float[] data)
{
    for (int i = 0; i < data.Length; i++)
    {
        data[i] = data[i] / 2f;
    }
}

这段糟糕的代码示例是逐个处理数据元素的，速度很慢，会限制 C# 的性能潜力。

好方法：

private void Normalize(float[] data)
{
    Vector<float> factor = new Vector<float>(0.5f);
    for (int i = 0; i < data.Length; i += Vector<float>.Count)
    {
        Vector<float> vector = new Vector<float>(data, i);
        (vector * factor).CopyTo(data, i); // Process multiple elements in parallel
    }
}

通过使用Vector<T>SIMD 指令集，您可以同时处理多个数据元素。这可以显著提升 C# 代码的性能。

确保与硬件加速的SIMD兼容

糟糕的方式：

private void Normalize(float[] data)
{
    Vector<float> factor = new Vector<float>(0.5f);
    for (int i = 0; i < data.Length; i += Vector<float>.Count)
    {
        Vector<float> vector = new Vector<float>(data, i);
        (vector * factor).CopyTo(data, i);
    }
}

错误的示例代码可能无法在某些缺少 SIMD 支持的配置中运行，从而限制了代码在不同硬件上的兼容性。

好方法：

private void Normalize(float[] data)
{
    if (Vector.IsHardwareAccelerated) // Check for SIMD support
    {
        Vector<float> factor = new Vector<float>(0.5f);
        for (int i = 0; i < data.Length; i += Vector<float>.Count)
        {
            Vector<float> vector = new Vector<float>(data, i);
            (vector * factor).CopyTo(data, i);
        }
    }
    else
    {
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = data[i] / 2f;
        }
    }
}

通过使用 SIMD 指令之前检查硬件加速支持Vector.IsHardwareAccelerated，可以确保您的代码具有可移植性，并且在不同的平台上都能正确运行，即使在那些不支持 SIMD 的平台上也是如此。

当 SIMD 不可用时，提供常规代码作为回退方案，可确保在各种硬件配置中具有更好的兼容性。

Task 和 ValueTask 用于重用异步代码

利用这项技术ValueTask<TResult>可以帮助减少堆内存分配，并提高异步场景下的性能。让我们来看看如何有效地利用它来优化.NET代码。

使用 ValueTask 来减少堆内存分配

糟糕的方式：

public async Task<string> ReadDataAsync()
{
    var data = await ReadFromStreamAsync(_stream);
    return ProcessData(data);
}

错误代码示例依赖于堆分配的Task<TResult>对象，这会增加垃圾回收开销并降低 C# 的性能。

好方法：

public async ValueTask<string> ReadDataAsync()
{
    var data = await ReadFromStreamAsync(_stream);
    return ProcessData(data);
}

通过从 `std::undefined` 切换Task<TResult>到 `std::undefined` ValueTask<TResult>，您可以减少堆内存分配，最终提升 C# 的性能。这对于高频异步操作尤其有效。

通过适当的异步操作优化性能

糟糕的方式：

public async Task<int> CalculateAsync(int x, int y)
{
    return await Task.FromResult(x + y);
}

这段糟糕的代码示例使用了不必要的堆内存分配，Task.FromResult这会影响性能。

好方法：

public ValueTask<int> CalculateAsync(int x, int y)
{
    return new ValueTask<int>(x + y); // Reduce heap allocations
}

使用合适的异步操作可以显著优化 C# 的性能。在方法很可能同步完成或其异步路径可以合并的情况下，使用 `async`ValueTask<TResult>而不是 `async`Task<TResult>可以帮助减少堆分配并提高性能。

要根据具体情况和所涉及的异步操作的性质，谨慎选择何时进行ValueTask选择。Task

检测和减少装箱和拆箱

减少装箱和拆箱的开销可以显著提升 C# 代码的性能。让我们探讨一些避免这些耗时操作以优化 .NET 代码的技巧。

了解包装和拆箱的成本

糟糕的方式：

int number = 42;
object boxedNumber = number; // Boxing
int unboxedNumber = (int)boxedNumber; // Unboxing

装箱和拆箱操作会引入额外的开销，这可能会对 C# 性能产生负面影响。

好方法：

int number = 42; // Avoid boxing and unboxing

了解装箱和拆箱对性能的影响，可以帮助你在代码中做出更明智的决策，避免不必要的开销。尽可能减少这些操作，从而优化代码。

利用泛型和自定义接口来避免装箱。

糟糕的方式：

public interface INumber
{
    object Value { get; set; }
}

public class Number : INumber
{
    public object Value { get; set; }
}

糟糕的代码示例由于使用了对象类型而产生了装箱开销，这会影响 C# 的性能。

好方法：

public interface INumber<T>
{
    T Value { get; set; }
}

public class Number<T> : INumber<T> // Utilize generics to avoid boxing
{
    public T Value { get; set; }
}

使用泛型和自定义接口有助于避免装箱并提升性能。通过使用类型参数，您可以编写更高效的代码，避免值类型的装箱开销，同时保持引用类型的灵活性。

这样可以提高 C# 的性能，并有助于解决 .NET 的性能问题。

网络编程优化

优化网络通信对于提升 C# 应用程序的响应速度和性能至关重要。让我们学习如何通过专家技巧来增强您的网络编程能力。

选择高效的序列化方法

C# 开发人员经常需要序列化和反序列化数据，以便与外部系统或文件存储进行通信。选择高效的序列化方法可以显著影响 C# 应用程序的性能，进而影响 C# 优化器的效率。

糟糕的方式：

// Using XmlSerializer for data serialization
private string SerializeObjectToXml<T>(T obj)
{
    var serializer = new XmlSerializer(typeof(T));
    using (var writer = new StringWriter())
    {
        serializer.Serialize(writer, obj);
        return writer.ToString();
    }
}

由于 XML 序列化过程繁琐，因此它是一种速度较慢且过时的数据序列化方法。XmlSerializer 会生成大量临时对象，这可能会影响 .NET 代码的优化，导致性能下降、内存占用增加，甚至可能阻塞垃圾回收器 (GC)。

好方法：

// Using Newtonsoft.Json for data serialization
private string SerializeObjectToJson<T>(T obj)
{
    return JsonConvert.SerializeObject(obj);
}

这个优秀示例展示了如何使用 Newtonsoft.Json——一个比 XmlSerializer 更快、更高效的序列化库。
该库不仅能确保更佳的性能，还提供了一些额外的功能来帮助优化 Visual Studio 中的代码，从而使 C# 编译器的优化功能发挥更佳作用。

使用 HttpClientFactory 管理 HttpClient 实例

未能正确重用 HttpClient 实例可能会导致可用套接字耗尽以及其他性能问题。HttpClientFactory 能够正确管理和重用 HttpClient 实例，从而降低此类问题的发生概率。

糟糕的方式：

// Creating a new HttpClient instance for every request
var httpClient = new HttpClient();
var response = await httpClient.GetAsync("http://api.example.com/data");

好方法：

// Injecting HttpClient into the class using dependency injection and using the HttpClient provided by HttpClientFactory
private readonly HttpClient _httpClient;

public MyClass(HttpClient httpClient)
{
    _httpClient = httpClient;
}

public async Task GetDataAsync()
{
    var response = await _httpClient.GetAsync("http://api.example.com/data");
}

这个示例演示了如何使用 HttpClientFactory 通过依赖注入为类提供 HttpClient 实例。这种方法可以更有效地管理 HttpClient 实例的生命周期，防止因处理不当而导致的套接字耗尽和性能问题。

优化异常处理

异常处理是 C# 编程中至关重要的一环，但使用不当会导致性能瓶颈。让我们来看看如何高效且负责任地处理异常。

避免使用异常进行流程控制

将异常处理视为正常应用程序流程的一部分可能会对 C# 性能产生重大影响，因为这会给 C# 优化器生成不必要的工作，并在运行时造成潜在的性能瓶颈。

糟糕的方式：

try
{
    int.Parse(input);
}
catch (FormatException)
{
    // Handle the invalid input
}

在错误示例中，尝试解析无效的输入字符串会抛出异常。在这里抛出异常不利于性能，并且迫使我们通过处理 FormatException 来控制流程。

好方法：

if (int.TryParse(input, out int result))
{
    // Use the parsed value
}
else
{
    // Handle the invalid input
}

这个好方法示例利用了TryParse避免依赖异常来控制流程的方法。这种方法可以确保更高的 C# 性能和更简洁的代码。

使用异常过滤器来尽量减少 catch 块。

异常过滤器有助于编写高效的异常处理代码，使 catch 块更简洁、更易于维护。

糟糕的方式：

try
{
    // Perform an operation
}
catch (Exception ex)
{
    if (ex is InvalidOperationException || ex is ArgumentNullException)
    {
        // Handle the specific exceptions
    }
    else
    {
        throw;
    }
}

在这种糟糕的示例中，多个异常被捕获在一个 catch 代码块中，并使用嵌套的 if 语句来区分它们。这可能会导致代码更加复杂，更难维护。

好方法：

try
{
    // Perform an operation
}
catch (Exception ex) when (ex is InvalidOperationException || ex is ArgumentNullException)
{
    // Handle the specific exceptions
}

这个好方法示例演示了异常过滤器的用法。异常过滤器允许你仅在满足特定条件时才捕获异常，从而简化你的 catch 代码块，并避免使用多个 catch 代码块或重新抛出未处理的异常。

可空性和可空引用类型

处理可空引用类型是 C# 编程中至关重要的一部分，尤其是在避免空引用异常方面。让我们来看看一些专家技巧，以便在不影响性能的前提下安全地使用可空类型。

利用空合并运算符（??，??=）

空值合并运算符可帮助您在处理可空类型时编写简洁高效的代码，确保空值被替换为默认值。

糟糕的方式：

string input = GetNullableString();
if (input == null)
{
    input = "default";
}

错误示例展示了处理空值时冗长且性能较差的代码。

好方法：

string input = GetNullableString() ?? "default";

示例中使用了空值合并运算符，这为在 C# 中处理空值提供了一种更简洁高效的方法。这确保了更好的 C# 性能和更易于维护的代码。

使用可空引用类型可以避免运行时空引用异常。

C# 8.0 中引入的可空引用类型有助于在编译时而不是运行时捕获潜在的空引用异常。

糟糕的方式：

string name = GetName();
int length = name.Length; // Potential NullReferenceException

在错误示例中，我们可能会遇到 NullReferenceException 异常，该异常只能在运行时捕获，这可能会导致意外崩溃。

好方法：

string? name = GetName();
int length = name?.Length ?? 0; // No NullReferenceException

通过在示例中正确使用可空引用类型和空条件访问，您可以消除代码中潜在的空引用异常。

这有助于创建更安全、性能更高的代码，并且在开发和执行过程中都更容易理解。

利用 Span 和 Memory 实现高效的缓冲区管理

高效管理内存和缓冲区对于提升 C# 性能至关重要。本文将探讨 Span 和 Memory 如何帮助您优化代码，从而提高效率。

了解何时在数组上使用 Span 函数

在某些情况下，Span 提供了一种比数组性能更高的替代方案，它能够操作连续的内存区域，而无需额外的内存分配或复制。

糟糕的方式：

// Using arrays may lead to unnecessary memory allocations and copying
byte[] data = GetData();
ProcessData(data);

错误的方法可能会导致额外的内存分配和复制，从而对性能产生负面影响。

好方法：

// Using Span<T> avoids additional memory allocation and copying
byte[] data = GetData();
Span<byte> dataSpan = data.AsSpan();
ProcessData(dataSpan);

通过使用Span<T>数组，可以避免不必要的内存分配和复制，从而实现更快、更高效的代码执行。

使用 ArrayPool 回收临时缓冲区

ArrayPool 是一个共享的数组集合，有助于减少分配和垃圾回收大型缓冲区的频率。

糟糕的方式：

// Allocating a new large buffer
byte[] buffer = new byte[4096];

以这种方式创建新缓冲区可能会导致频繁的垃圾回收，从而降低性能。

好方法：

// Using ArrayPool<T> recycles previously allocated large buffers
var pool = ArrayPool<byte>.Shared;
byte[] buffer = pool.Rent(4096);
try
{
    // Work with the buffer
}
finally
{
    pool.Return(buffer);
}

使用此功能ArrayPool<T>可使您的应用程序重用先前分配的大缓冲区，从而最大限度地减少垃圾回收次数并提高整体性能。

懒惰加载和急迫加载技术

理解延迟加载和预加载技术的区别，有助于创建高性能的 C# 应用程序。让我们来探讨如何根据应用程序的需求做出正确的选择。

了解惰性加载和预加载之间的权衡。

延迟加载是指仅在需要时才加载数据，而预加载则会预先获取所有数据。为应用程序选择合适的加载方式需要在性能和内存消耗之间取得平衡。

糟糕的方式：

// Eagerly loading all entities from the database
var customers = dbContext.Customers.Include(c => c.Orders);

// Lazily loading when not required, leading to performance issues
var customer = dbContext.Customers.Find(customerId);
var orderCount = customer.Orders.Count;

如果这些问题处理不当，会导致性能下降和不必要的数据加载。

好方法：

// Eagerly loading specific data for an operation
var user = dbContext.Users.Include(u => u.Profile).SingleOrDefault(u => u.Id == userId);

// Lazily loading when appropriate for smaller object graphs
var product = dbContext.Products.Find(productId);
var price = product.Price;

通过了解延迟加载和预加载之间的权衡，您可以就何时使用每种方法做出明智的决定，从而获得更高效的应用程序。

使用 Lazy 类实现惰性属性

该类Lazy<T>允许您创建仅在首次访问时初始化的属性，这可以通过防止不必要的初始化来提高性能。

糟糕的方式：

// Initializing expensive resources upfront
private readonly ExpensiveObject _expensiveObject = new ExpensiveObject();
public ExpensiveObject ExpensiveObject => _expensiveObject;

这种方法可能会导致资源浪费和性能下降，因为即使不需要，也会初始化昂贵的资源。

好方法：

// Using Lazy<T> to initialize resources only when needed
private readonly Lazy<ExpensiveObject> _expensiveObject = new Lazy<ExpensiveObject>();
public ExpensiveObject ExpensiveObject => _expensiveObject.Value;

通过在Lazy<T>类中实现惰性属性，可以确保仅在必要时才初始化昂贵的资源，从而提高应用程序的效率和响应速度。

字符串插值及其对性能的影响及比较

在 C# 中，处理字符串是一项常见的操作，它会对应用程序的性能产生显著影响。我们将深入探讨一些关于优化字符串使用的专家指导。

使用 StringComparison 选项可以更高效地进行字符串比较。

字符串比较是频繁的操作，容易造成性能瓶颈。使用合适的字符串比较选项可以提高字符串比较的效率。

糟糕的方式：

// Allocating additional memory for string conversion before comparison
bool equal = string1.ToLower() == string2.ToLower();

这种方法会导致在比较之前进行不必要的字符串分配，从而导致性能下降。

好方法：

// Comparing strings directly using StringComparison options
bool equal = string.Equals(string1, string2, StringComparison.OrdinalIgnoreCase);

通过利用 StringComparison 选项，您可以避免不必要的字符串分配（例如 ToLower），并执行更高效的字符串比较。

在循环中，优先选择 StringBuilder 而不是字符串拼接。

在循环中连接字符串或执行多个字符串操作时，使用 `String()`StringBuilder函数效率更高，可以显著提高性能。

糟糕的方式：

// Concatenating strings in a loop creates many intermediate strings
string result = string.Empty;
for (int i = 0; i < 1000; i++)
{
    result += "Iteration: " + i;
}

错误的方法会在连接过程中生成许多中间字符串，这会导致性能显著下降。

好方法：

// StringBuilder minimizes string allocations and deallocations
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
{
    sb.AppendFormat("Iteration: {0}", i);
}
string result = sb.ToString();

利用此方法StringBuilder可以最大限度地减少新字符串的分配和释放次数，从而提高性能并降低内存消耗。

将这些专家技巧融入到你的 C# 编程中，可以显著提升应用程序的性能，并编写高效、优化良好的代码。掌握高级 C# 性能优化技巧是资深开发人员提升技能的关键。

文章来源：https://dev.to/bytehide/50-c-advanced-optimization-performance-tips-18l2

分享

50 个 C#（高级）性能优化技巧🔥

50 个 C#（高级）性能优化技巧🔥

内存管理和垃圾回收

利用 IDisposable 接口

避免过早优化

使用 async/await 进行异步编程

限制并发操作的数量

尽可能使用ConfigureAwait(false)

并行计算和任务并行库（TPL）

使用 Parallel.For() 和 Parallel.ForEach() 实现并行循环

使用 Partitioner 类可以实现高效的工作负载分配

缓存数据的重要性

使用内存缓存实现数据缓存

使用分布式缓存系统（例如 Redis）实现缓存。

并发性和线程安全性

尽可能使用无锁数据结构

使用高效的同步结构

使用 Interlocked 类来实现原子操作

理解和优化 LINQ 性能

了解延迟执行和立即执行之间的区别

尽可能选择查询语法而不是方法语法。

在多线程环境下使用 LINQ 时，请注意潜在的陷阱

微优化和即时编译

执行循环展开以获得更好的性能

对关键方法使用激进的内联属性

栈分配与堆分配

尽可能限制堆分配对象的使用。

了解何时使用 stackalloc 关键字进行内存分配

高效数据结构与算法

根据您的需求选择合适的数据结构

针对特定用例采用自定义排序算法

反思与代码生成

避免过度使用反射 API

使用动态生成的 lambda 表达式而不是反射

使用 System.Numerics 的 SIMD（单指令多数据流）

利用 Vector 充分发挥 SIMD 指令的强大功能

确保与硬件加速的SIMD兼容

Task 和 ValueTask 用于重用异步代码

使用 ValueTask 来减少堆内存分配

通过适当的异步操作优化性能

检测和减少装箱和拆箱

了解包装和拆箱的成本

利用泛型和自定义接口来避免装箱。

网络编程优化

选择高效的序列化方法

使用 HttpClientFactory 管理 HttpClient 实例

优化异常处理

避免使用异常进行流程控制

使用异常过滤器来尽量减少 catch 块。

可空性和可空引用类型

利用空合并运算符（??，??=）

使用可空引用类型可以避免运行时空引用异常。

利用 Span 和 Memory 实现高效的缓冲区管理

了解何时在数组上使用 Span 函数

使用 ArrayPool 回收临时缓冲区

懒惰加载和急迫加载技术

了解惰性加载和预加载之间的权衡。

使用 Lazy 类实现惰性属性

字符串插值及其对性能的影响及比较

使用 StringComparison 选项可以更高效地进行字符串比较。

在循环中，优先选择 StringBuilder 而不是字符串拼接。