public class DataCache
{
    // 靜態(tài)字典會一直增長，永遠(yuǎn)不會被清理
    public static Dictionary<int, User> Cache = new Dictionary<int, User>();
}

public class UserProcessor
{
    public void ProcessUser(User user)
    {
        // 將所有處理過的用戶都放入靜態(tài)緩存
        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()
    {
        // 訂閱靜態(tài)事件！靜態(tài)事件發(fā)布者生命周期 == 應(yīng)用程序生命周期
        EventPublisher.SomethingHappened += OnSomethingHappened;
    }

    private void OnSomethingHappened(object sender, EventArgs e) { }
    // 這個類實例即使被置為null，也因為被靜態(tài)事件引用而無法被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()被自動調(diào)用，事件被取消訂閱

public void ReadFile(string path)
{
    FileStream fs = new FileStream(path, FileMode.Open);
    // ... 讀取文件
    // 忘記調(diào)用 fs.Close() 或 fs.Dispose()
    // 即使fs被GC，底層的文件句柄也可能不會立即釋放
}

// 使用using語句
public void ReadFile(string path)
{
    using (FileStream fs = new FileStream(path, FileMode.Open))
    {
        // ... 讀取文件
    } // 離開這里時，fs.Dispose()會自動調(diào)用，即使發(fā)生異常也會
}

// 實現(xiàn)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不需要再調(diào)用終結(jié)器
    }

    // 終結(jié)器（Finalizer）作為最后的安全網(wǎng)，防止開發(fā)者忘記調(diào)用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表達(dá)式捕獲了largeObject
        SomeLongRunningOperation.Completed += (s, e) => 
        {
            // 即使ProcessRequestAsync方法早已執(zhí)行完畢，
            // 因為事件訂閱未被移除，這個lambda和它捕獲的largeObject會一直存活
            Console.WriteLine(largeObject.Length); 
        };
        await SomeLongRunningOperation.StartAsync();
    }
}

public async Task SafeProcessRequestAsync()
{
    var largeObject = new byte[1000000];
    // 提取所需的最小數(shù)據(jù)，而不是捕獲整個對象
    int length = largeObject.Length; 

    EventHandler handler = null;
    handler = (s, e) => 
    {
        // 只使用提取出來的數(shù)據(jù)
        Console.WriteLine(length); 
        // 操作完成后立即取消訂閱，允許lambda和其上下文被回收
        SomeLongRunningOperation.Completed -= handler;
    };

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