防止 C# .NET 应用程序中的内存泄漏：最佳实践和工具

在程序执行过程中，由于某些原因，分配的内存仍未使用时，会发生内存泄漏。这会导致程序运行时内存消耗增加，从而导致速度变慢或崩溃。即使 C# .NET 具有垃圾回收器 （GC） 来管理内存，但某些情况仍可能导致内存泄漏。本文将通过示例来探讨几种常见的内存泄漏场景及其应用，以及测试方法。

1. 未订阅的事件订阅

应用场景

在 .NET 中，事件是一种对象间通信的机制。如果 subscriber 对象订阅了 publisher 对象的事件，但在不再需要时没有取消订阅，则 publisher 将继续保留对 subscriber 的引用，从而防止 subscriber 对象被垃圾回收。

例

// Define an event publisher class
public class EventPublisher
{
    // Declare an event using the EventHandler<EventArgs> delegate, where the event data type is EventArgs
    public event EventHandler<EventArgs> MyEvent;

    // Method to trigger the event
    public void RaiseEvent()
    {
        // ?.Invoke safely triggers the event. If MyEvent is not null, it calls the methods of all subscribers
        MyEvent?.Invoke(this, EventArgs.Empty);
    }
}

// Define an event subscriber class
public class EventSubscriber
{
    // Subscribe to the event in the constructor
    public EventSubscriber(EventPublisher publisher)
    {
        // Subscribe to the MyEvent event published by the publisher
        publisher.MyEvent += Publisher_MyEvent;
    }

    // Event handling method, executed when the event is triggered
    private void Publisher_MyEvent(object sender, EventArgs e)
    {
        // Output a message indicating the event has been received
        Console.WriteLine("Event received.");
    }
}

// Test code
var publisher = new EventPublisher();
var subscriber = new EventSubscriber(publisher);
publisher.RaiseEvent();

// The subscription should be canceled at this point, otherwise subscriber cannot be GC collected
// publisher.MyEvent -= subscriber.Publisher_MyEvent;

2. 静态字段引用

应用场景

静态成员的生存期与应用程序相同。如果静态字段引用大型对象或集合，并且在应用程序的整个生命周期内不再需要此对象或集合，则不会释放内存。

例

public class DataHolder
{
    private static List<byte[]> largeDataList = new List<byte[]>();

    public static void AddLargeObject()
    {
        largeDataList.Add(new byte[1024 * 1024]);
        // Add 1MB data
    }
}

// Test code
DataHolder.AddLargeObject();

// Even if the AddLargeObject method is no longer called, the data in largeDataList will not be released

3. 大型对象堆 （LOH） 分配

应用场景

在 .NET 中，大于 85KB 的对象将分配给大型对象堆 （LOH）。LOH 的垃圾回收频率低于常规对象堆。频繁分配和释放大型对象会导致内存使用量持续增加。

例

public class LargeObjectAllocator
{
    public void AllocateLargeObject()
    {
        byte[] largeArray = new byte[85000];
        // Allocate to LOH
        // Use largeArray
    }
}

// Test code
var allocator = new LargeObjectAllocator();
for (int i = 0; i < 1000; i++)
{
    allocator.AllocateLargeObject();
    // This will cause a large amount of memory to be allocated to LOH, potentially causing a sharp increase in memory usage
}

4. ValueTask 滥用

应用场景

ValueTask是用于优化异步代码中的内存分配的值类型。但是，使用不当（例如，多次等待同一实例）可能会导致意外行为和内存泄漏。ValueTask

例

public class ValueTaskExample
{
    public async ValueTask<int> GetValueAsync()
    {
        await Task.Delay(100);
        // Simulate asynchronous operation
        return 42;
    }

    public async Task BadUsage()
    {
        var valueTask = GetValueAsync();

        var result1 = await valueTask;
        // Waiting on the same ValueTask instance a second time is not recommended
        var result2 = await valueTask;
    }
}

// Test code
var example = new ValueTaskExample();
await example.BadUsage();

测试内存泄漏

可以使用 来测试内存泄漏。NET 的内置性能监控器，或者使用 JetBrains dotMemory 等专用内存分析工具。这些工具可以帮助开发人员监控应用程序的内存使用情况并确定内存泄漏的来源。

虽然 C# .NET 提供了垃圾回收机制，但开发人员仍然需要注意其代码中可能导致内存泄漏的情况。通过了解常见的内存泄漏场景并采取适当的预防措施，可以有效避免内存泄漏，从而提高应用程序的性能和稳定性。

如果你喜欢我的文章，请给我一个赞！谢谢