C#防止内存泄漏的实战指南

public class DataCache
{
    // 静态字典会一直增长，永远不会被清理
    public static Dictionary<int, User> Cache = new Dictionary<int, User>();
}

public class UserProcessor
{
    public void ProcessUser(User user)
    {
        // 将所有处理过的用户都放入静态缓存
        DataCache.Cache[user.Id] = user; 
        // ... 其他处理逻辑
    }
}

// 使用弱引用示例（注意：弱引用可能已被GC，需要检查Target是否为null）
public class WeakDataCache
{
    private static Dictionary<int, WeakReference<User>> _weakCache = new Dictionary<int, WeakReference<User>>();

    public static void AddUser(User user)
    {
        _weakCache[user.Id] = new WeakReference<User>(user);
    }

    public static User GetUser(int id)
    {
        if (_weakCache.TryGetValue(id, out WeakReference<User> wr) && wr.TryGetTarget(out User user))
        {
            return user;
        }
        return null;
    }
    // 需要定期清理 _weakCache 中值为null（已被回收）的WeakReference，否则字典本身会泄漏。
}

public class EventPublisher
{
    public static event EventHandler SomethingHappened;
}

public class ShortLivedSubscriber
{
    public ShortLivedSubscriber()
    {
        // 订阅静态事件！静态事件发布者生命周期 == 应用程序生命周期
        EventPublisher.SomethingHappened += OnSomethingHappened;
    }

    private void OnSomethingHappened(object sender, EventArgs e) { }
    // 这个类实例即使被置为null，也因为被静态事件引用而无法被GC回收。
}

public class DisposableSubscriber : IDisposable
{
    public DisposableSubscriber()
    {
        EventPublisher.SomethingHappened += OnSomethingHappened;
    }

    private void OnSomethingHappened(object sender, EventArgs e) { }

    public void Dispose()
    {
        // 在Dispose方法中取消订阅，这是最佳实践
        EventPublisher.SomethingHappened -= OnSomethingHappened;
    }
}

// 使用示例
using (var subscriber = new DisposableSubscriber())
{
    // 使用subscriber...
} // 离开using块时，Dispose()被自动调用，事件被取消订阅

public void ReadFile(string path)
{
    FileStream fs = new FileStream(path, FileMode.Open);
    // ... 读取文件
    // 忘记调用 fs.Close() 或 fs.Dispose()
    // 即使fs被GC，底层的文件句柄也可能不会立即释放
}

// 使用using语句
public void ReadFile(string path)
{
    using (FileStream fs = new FileStream(path, FileMode.Open))
    {
        // ... 读取文件
    } // 离开这里时，fs.Dispose()会自动调用，即使发生异常也会
}

// 实现IDisposable模式（简化版）
public class ResourceHolder : IDisposable
{
    private FileStream _fileStream;
    private bool _disposed = false;

    public void OpenFile(string path)
    {
        _fileStream = new FileStream(path, FileMode.Open);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // 释放托管资源
                _fileStream?.Dispose();
            }
            // 释放非托管资源（如果有的话）
            _disposed = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // 告诉GC不需要再调用终结器
    }

    // 终结器（Finalizer）作为最后的安全网，防止开发者忘记调用Dispose()
    ~ResourceHolder()
    {
        Dispose(false);
    }
}

public class BackgroundWorker
{
    private System.Timers.Timer _timer;

    public BackgroundWorker()
    {
        _timer = new System.Timers.Timer(1000);
        _timer.Elapsed += OnTimerElapsed;
        _timer.Start();
    }

    private void OnTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        // 做某些工作
    }
    // 即使没有其他地方引用BackgroundWorker，其_timer仍然活跃并持有对其的引用。
}

public class SafeBackgroundWorker : IDisposable
{
    private System.Timers.Timer _timer;

    public SafeBackgroundWorker()
    {
        _timer = new System.Timers.Timer(1000);
        _timer.Elapsed += OnTimerElapsed;
        _timer.Start();
    }

    private void OnTimerElapsed(object sender, System.Timers.ElapsedEventArgs e) { }

    public void Dispose()
    {
        _timer?.Stop();    // 停止计时
        _timer?.Dispose(); // 释放定时器资源
        _timer = null;
    }
}

public class LeakyWebService
{
    public async Task ProcessRequestAsync()
    {
        var largeObject = new byte[1000000]; // 一个大对象
        // lambda表达式捕获了largeObject
        SomeLongRunningOperation.Completed += (s, e) => 
        {
            // 即使ProcessRequestAsync方法早已执行完毕，
            // 因为事件订阅未被移除，这个lambda和它捕获的largeObject会一直存活
            Console.WriteLine(largeObject.Length); 
        };
        await SomeLongRunningOperation.StartAsync();
    }
}

public async Task SafeProcessRequestAsync()
{
    var largeObject = new byte[1000000];
    // 提取所需的最小数据，而不是捕获整个对象
    int length = largeObject.Length; 

    EventHandler handler = null;
    handler = (s, e) => 
    {
        // 只使用提取出来的数据
        Console.WriteLine(length); 
        // 操作完成后立即取消订阅，允许lambda和其上下文被回收
        SomeLongRunningOperation.Completed -= handler;
    };

    SomeLongRunningOperation.Completed += handler;
    await SomeLongRunningOperation.StartAsync();
}