最新
Head -> [BagView] -> [ShopView] -> [QuestView] -> [SettingsView] <- Tail
                                                        最久未使用

Head -> [QuestView] -> [BagView] -> [ShopView] -> [SettingsView] <- Tail

Put(A)
Put(B)
Put(C)
Get(A)
Put(D)

using System;
using System.Collections.Generic;

public sealed class LruCache<TKey, TValue>
{
    private readonly int _capacity;
    private readonly Action<TKey, TValue> _onEvicted;
    private readonly Dictionary<TKey, LinkedListNode<Entry>> _map;
    private readonly LinkedList<Entry> _list;

    private readonly struct Entry
    {
        public Entry(TKey key, TValue value)
        {
            Key = key;
            Value = value;
        }

        public TKey Key { get; }
        public TValue Value { get; }
    }

    public LruCache(int capacity, Action<TKey, TValue> onEvicted = null)
    {
        if (capacity <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(capacity), "LRU capacity must be greater than 0.");
        }

        _capacity = capacity;
        _onEvicted = onEvicted;
        _map = new Dictionary<TKey, LinkedListNode<Entry>>(capacity);
        _list = new LinkedList<Entry>();
    }

    public int Count => _map.Count;
    public int Capacity => _capacity;

    public bool TryGet(TKey key, out TValue value)
    {
        if (!_map.TryGetValue(key, out var node))
        {
            value = default;
            return false;
        }

        MoveToFront(node);
        value = node.Value.Value;
        return true;
    }

    public void Put(TKey key, TValue value)
    {
        if (_map.TryGetValue(key, out var existingNode))
        {
            existingNode.Value = new Entry(key, value);
            MoveToFront(existingNode);
            return;
        }

        var node = new LinkedListNode<Entry>(new Entry(key, value));
        _list.AddFirst(node);
        _map.Add(key, node);

        if (_map.Count > _capacity)
        {
            EvictLeastRecentlyUsed();
        }
    }

    public bool Remove(TKey key)
    {
        if (!_map.TryGetValue(key, out var node))
        {
            return false;
        }

        RemoveNode(node, invokeEvicted: true);
        return true;
    }

    public void Clear()
    {
        while (_list.Last != null)
        {
            RemoveNode(_list.Last, invokeEvicted: true);
        }
    }

    private void MoveToFront(LinkedListNode<Entry> node)
    {
        if (node.List == _list && node != _list.First)
        {
            _list.Remove(node);
            _list.AddFirst(node);
        }
    }

    private void EvictLeastRecentlyUsed()
    {
        var last = _list.Last;
        if (last != null)
        {
            RemoveNode(last, invokeEvicted: true);
        }
    }

    private void RemoveNode(LinkedListNode<Entry> node, bool invokeEvicted)
    {
        _list.Remove(node);
        _map.Remove(node.Value.Key);

        if (invokeEvicted)
        {
            _onEvicted?.Invoke(node.Value.Key, node.Value.Value);
        }
    }
}

using System;

public static class LruCacheDemo
{
    public static void Run()
    {
        var cache = new LruCache<string, int>(
            capacity: 3,
            onEvicted: (key, value) => Console.WriteLine($"Evict {key}={value}")
        );

        cache.Put("A", 1);
        cache.Put("B", 2);
        cache.Put("C", 3);

        cache.TryGet("A", out _); // A 变成最近使用
        cache.Put("D", 4);        // 淘汰 B

        Console.WriteLine(cache.TryGet("B", out _)); // False
        Console.WriteLine(cache.TryGet("A", out _)); // True
    }
}

Evict B=2
False
True

public interface IUiCacheItem
{
    string CacheKey { get; }
    bool CanCache { get; }

    void OnOpen(object args);
    void OnCloseToCache();
    void OnReuseFromCache(object args);
    void OnEvictFromCache();
}

using System;
using UnityEngine;

public sealed class UiLruCache
{
    private readonly LruCache<string, IUiCacheItem> _cache;

    public UiLruCache(int capacity)
    {
        _cache = new LruCache<string, IUiCacheItem>(
            capacity,
            onEvicted: (_, item) => item.OnEvictFromCache()
        );
    }

    public bool TryReuse(string key, object args, out IUiCacheItem item)
    {
        if (!_cache.TryGet(key, out item))
        {
            return false;
        }

        item.OnReuseFromCache(args);
        return true;
    }

    public void Recycle(IUiCacheItem item)
    {
        if (item == null)
        {
            return;
        }

        if (!item.CanCache)
        {
            item.OnEvictFromCache();
            return;
        }

        item.OnCloseToCache();
        _cache.Put(item.CacheKey, item);
    }

    public void Remove(string key)
    {
        _cache.Remove(key);
    }

    public void Clear()
    {
        _cache.Clear();
    }
}

using UnityEngine;

public abstract class CachedUiView : MonoBehaviour, IUiCacheItem
{
    [SerializeField] private string cacheKey;
    [SerializeField] private bool canCache = true;

    public string CacheKey => cacheKey;
    public bool CanCache => canCache;

    public virtual void OnOpen(object args)
    {
        gameObject.SetActive(true);
    }

    public virtual void OnCloseToCache()
    {
        gameObject.SetActive(false);
    }

    public virtual void OnReuseFromCache(object args)
    {
        gameObject.SetActive(true);
    }

    public virtual void OnEvictFromCache()
    {
        Destroy(gameObject);
    }
}

using UnityEngine;

public sealed class UiService
{
    private readonly UiLruCache _closedViewCache;
    private readonly IUiFactory _factory;
    private readonly Transform _uiRoot;

    public UiService(IUiFactory factory, Transform uiRoot, int closedCacheCapacity)
    {
        _factory = factory;
        _uiRoot = uiRoot;
        _closedViewCache = new UiLruCache(closedCacheCapacity);
    }

    public IUiCacheItem Open(string viewKey, object args = null)
    {
        if (_closedViewCache.TryReuse(viewKey, args, out var cached))
        {
            return cached;
        }

        var item = _factory.Create(viewKey, _uiRoot);
        item.OnOpen(args);
        return item;
    }

    public void Close(IUiCacheItem item)
    {
        _closedViewCache.Recycle(item);
    }

    public void ClearClosedCache()
    {
        _closedViewCache.Clear();
    }
}

public interface IUiFactory
{
    IUiCacheItem Create(string viewKey, Transform parent);
}

public sealed class UiCacheConfig
{
    public string ViewKey;
    public bool CanCache;
    public int Priority;
    public int EstimatedMemoryCost;
}

当前缓存成本 + 新对象成本 > 最大预算
    -> 持续淘汰最旧对象
    -> 直到预算足够

public sealed class UiCacheSnapshot
{
    public string Key;
    public int AgeRank;
    public bool Active;
    public int EstimatedCost;
}

热点：A, B, C
突然扫描：D, E, F, G

uiService.Open("BagView", args);
uiService.Close(bagView);

UiService
  - Open(viewKey, args)
  - Close(view)
  - ClearClosedCache()

UiLruCache
  - TryReuse(viewKey, args, out view)
  - Recycle(view)
  - Remove(viewKey)
  - Clear()

LruCache<TKey, TValue>
  - TryGet(key, out value)
  - Put(key, value)
  - Remove(key)
  - Clear()

IUiCacheItem
  - CacheKey
  - CanCache
  - OnOpen(args)
  - OnCloseToCache()
  - OnReuseFromCache(args)
  - OnEvictFromCache()

IUiFactory
  - Create(viewKey, parent)

public enum UiCacheScope
{
    Global,
    Scene,
    Battle,
    Activity
}

BagView
ShopView
QuestView
ActivityView:637
PlayerProfile:12345