ImageCache.cs

using System;
using System.Collections.Generic;
using System.Drawing;

namespace LinView
{
    /// <summary>
    /// LRU 图片缓存：最多保留 N 张已加载的 Bitmap。
    /// 
    /// ProtectedKey 用于保护"当前正在显示的图片"，它不会被淘汰也不会被 Dispose。
    /// 其他被淘汰的 Bitmap 会主动 Dispose，立即释放内存。
    /// </summary>
    public class ImageCache
    {
        private int _maxCount;
        private string? _protectedKey;

        private readonly LinkedList<string> _order = new();
        private readonly Dictionary<string, LinkedListNode<string>> _nodes = new();
        private readonly Dictionary<string, Bitmap> _cache = new();
        private readonly object _lock = new();

        public ImageCache(int maxCount)
        {
            _maxCount = Math.Max(0, maxCount);
        }

        /// <summary>最大缓存数量，0 表示禁用</summary>
        public int MaxCount
        {
            get => _maxCount;
            set
            {
                lock (_lock)
                {
                    _maxCount = Math.Max(0, value);
                    TrimToSizeNoLock();
                }
            }
        }

        /// <summary>受保护的 key（不会被淘汰或释放）</summary>
        public string? ProtectedKey
        {
            get => _protectedKey;
            set
            {
                lock (_lock)
                {
                    _protectedKey = value;
                }
            }
        }

        public bool IsEnabled => _maxCount > 0;

        public bool Contains(string key)
        {
            if (_maxCount <= 0) return false;
            lock (_lock)
            {
                return _cache.ContainsKey(key);
            }
        }

        /// <summary>判断某个 Bitmap 引用是否在缓存里</summary>
        public bool ContainsBitmap(Bitmap bmp)
        {
            if (bmp == null) return false;
            lock (_lock)
            {
                foreach (var kv in _cache)
                {
                    if (ReferenceEquals(kv.Value, bmp))
                        return true;
                }
                return false;
            }
        }

        public Bitmap? Get(string key)
        {
            if (_maxCount <= 0) return null;
            lock (_lock)
            {
                if (!_cache.TryGetValue(key, out var bmp)) return null;

                if (_nodes.TryGetValue(key, out var node))
                {
                    _order.Remove(node);
                    _order.AddFirst(node);
                }

                return bmp;
            }
        }

        public void Add(string key, Bitmap bmp)
        {
            if (bmp == null) return;

            lock (_lock)
            {
                if (_maxCount <= 0) return;

                if (_cache.TryGetValue(key, out var old))
                {
                    if (!ReferenceEquals(old, bmp))
                    {
                        _cache[key] = bmp;

                        // 释放旧位图，但两种情况下不释放：
                        // 1. 该 key 是 ProtectedKey（正在显示，不能提前释放）
                        // 2. 旧位图被 cache 中其他 key 共享
                        bool canDispose =
                            !string.Equals(key, _protectedKey, StringComparison.Ordinal)
                            && !IsBitmapSharedLocked(old, key);
                        if (canDispose)
                            old.Dispose();
                    }

                    if (_nodes.TryGetValue(key, out var n))
                    {
                        _order.Remove(n);
                        _order.AddFirst(n);
                    }
                    return;
                }

                _cache[key] = bmp;
                var node = _order.AddFirst(key);
                _nodes[key] = node;

                TrimToSizeNoLock();
            }
        }

        public void Remove(string key)
        {
            lock (_lock)
            {
                if (_nodes.TryGetValue(key, out var node))
                {
                    _order.Remove(node);
                    _nodes.Remove(key);
                }

                if (_cache.TryGetValue(key, out var bmp))
                {
                    _cache.Remove(key);

                    if (!string.Equals(key, _protectedKey, StringComparison.Ordinal)
                        && !IsBitmapSharedLocked(bmp, key))
                    {
                        bmp.Dispose();
                    }
                }
            }
        }

        public void Clear()
        {
            lock (_lock)
            {
                foreach (var kv in _cache)
                {
                    if (string.Equals(kv.Key, _protectedKey, StringComparison.Ordinal))
                        continue;
                    if (IsBitmapSharedLocked(kv.Value, kv.Key))
                        continue;
                    kv.Value.Dispose();
                }
                _cache.Clear();
                _order.Clear();
                _nodes.Clear();
            }
        }

        /// <summary>
        /// 判断某个 Bitmap 是否还被 cache 中除 excludeKey 以外的其他 key 引用。
        /// 必须在 _lock 内调用。
        /// </summary>
        private bool IsBitmapSharedLocked(Bitmap bmp, string excludeKey)
        {
            foreach (var kv in _cache)
            {
                if (string.Equals(kv.Key, excludeKey, StringComparison.Ordinal))
                    continue;
                if (ReferenceEquals(kv.Value, bmp))
                    return true;
            }
            return false;
        }

        private void TrimToSizeNoLock()
        {
            // 从链表尾部（最旧）开始淘汰，跳过 ProtectedKey
            var node = _order.Last;
            while (node != null && _cache.Count > _maxCount)
            {
                var key = node.Value;
                var prev = node.Previous;

                if (!string.Equals(key, _protectedKey, StringComparison.Ordinal))
                {
                    _order.Remove(node);
                    _nodes.Remove(key);

                    if (_cache.TryGetValue(key, out var bmp))
                    {
                        _cache.Remove(key);

                        // 只有没被其他 key 共享时才真正释放
                        if (!IsBitmapSharedLocked(bmp, key))
                            bmp.Dispose();
                    }
                }

                node = prev;
            }
        }
    }
}