Gibt es eine LRU-Implementierung von IDictionary?

Dies eine sehr einfache und schnelle Umsetzung entwickelten wir eine Website, die wir besitzen.

Wir versuchen, den code zu verbessern, so viel wie möglich, aber halten Sie thread-sicher.
Ich denke, der code ist sehr einfach und klar, aber wenn Sie eine Erklärung brauchen oder eine Anleitung, wie es zu benutzen, zögern Sie nicht zu Fragen.

namespace LRUCache
{
    public class LRUCache<K,V>
    {
        private int capacity;
        private Dictionary<K, LinkedListNode<LRUCacheItem<K, V>>> cacheMap = new Dictionary<K, LinkedListNode<LRUCacheItem<K, V>>>();
        private LinkedList<LRUCacheItem<K, V>> lruList = new LinkedList<LRUCacheItem<K, V>>();

        public LRUCache(int capacity)
        {
            this.capacity = capacity;
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        public V get(K key)
        {
            LinkedListNode<LRUCacheItem<K, V>> node;
            if (cacheMap.TryGetValue(key, out node))
            {
                V value = node.Value.value;
                lruList.Remove(node);
                lruList.AddLast(node);
                return value;
            }
            return default(V);
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        public void add(K key, V val)
        {
            if (cacheMap.Count >= capacity)
            {
                RemoveFirst();
            }

            LRUCacheItem<K, V> cacheItem = new LRUCacheItem<K, V>(key, val);
            LinkedListNode<LRUCacheItem<K, V>> node = new LinkedListNode<LRUCacheItem<K, V>>(cacheItem);
            lruList.AddLast(node);
            cacheMap.Add(key, node);
        }

        private void RemoveFirst()
        {
            //Remove from LRUPriority
            LinkedListNode<LRUCacheItem<K,V>> node = lruList.First;
            lruList.RemoveFirst();

            //Remove from cache
            cacheMap.Remove(node.Value.key);
        }
    }

    class LRUCacheItem<K,V>
    {
        public LRUCacheItem(K k, V v)
        {
            key = k;
            value = v;
        }
        public K key;
        public V value;
    }
}

InformationsquelleAutor der Antwort

Ich habe kürzlich eine Klasse namens LurchTable um die Notwendigkeit für eine C# - Variante der LinkedHashMap. Eine kurze Diskussion der LurchTable finden Sie hier.

Basic features:

• Verbunden Gleichzeitige Wörterbuch durch Einfügen, Modifizieren oder den Zugriff
• Wörterbuch/Z. B. concurrentdictionary Schnittstelle unterstützen
• Peek/TryDequeue/Dequeue-Zugang zu den 'ältesten' - Eintrag
• Ermöglicht das hard-limit auf Elemente umgesetzt insertion
• Ereignisse verfügbar für das hinzufügen, aktualisieren und entfernen von

Source Code: http://csharptest.net/browse/src/Library/Collections/LurchTable.cs

GitHub: https://github.com/csharptest/CSharpTest.Net.Collections

HTML-Hilfe: http://help.csharptest.net/

PM> Install-Package CSharpTest.Net.Sammlungen

InformationsquelleAutor der Antwort csharptest.net

Den Caching Application Block von EntLib hat eine LRU-Aufräumvorgang option out of the box und können im Speicher sein. Vielleicht ist es ein bisschen Schwergewicht für das, was Sie wollen, tho.

InformationsquelleAutor der Antwort JP Alioto

Dieser nimmt Martin's code mit Mr T's Anregungen und macht es Stylecop freundlich. Oh, es erlaubt auch für die Entsorgung von Werten, wie Sie Zyklus, die aus dem cache.

namespace LruCache
{
    using System;
    using System.Collections.Generic;

    ///<summary>
    ///A least-recently-used cache stored like a dictionary.
    ///</summary>
    ///<typeparam name="TKey">
    ///The type of the key to the cached item
    ///</typeparam>
    ///<typeparam name="TValue">
    ///The type of the cached item.
    ///</typeparam>
    ///<remarks>
    ///Derived from https://stackoverflow.com/a/3719378/240845
    ///</remarks>
    public class LruCache<TKey, TValue>
    {
        private readonly Dictionary<TKey, LinkedListNode<LruCacheItem>> cacheMap =
            new Dictionary<TKey, LinkedListNode<LruCacheItem>>();

        private readonly LinkedList<LruCacheItem> lruList =
            new LinkedList<LruCacheItem>();

        private readonly Action<TValue> dispose;

        ///<summary>
        ///Initializes a new instance of the <see cref="LruCache{TKey, TValue}"/>
        ///class.
        ///</summary>
        ///<param name="capacity">
        ///Maximum number of elements to cache.
        ///</param>
        ///<param name="dispose">
        ///When elements cycle out of the cache, disposes them. May be null.
        ///</param>
        public LruCache(int capacity, Action<TValue> dispose = null)
        {
            this.Capacity = capacity;
            this.dispose = dispose;
        }

        ///<summary>
        ///Gets the capacity of the cache.
        ///</summary>
        public int Capacity { get; }

        ///<summary>Gets the value associated with the specified key.</summary>
        ///<param name="key">
        ///The key of the value to get.
        ///</param>
        ///<param name="value">
        ///When this method returns, contains the value associated with the specified
        ///key, if the key is found; otherwise, the default value for the type of the 
        ///<paramref name="value" /> parameter. This parameter is passed
        ///uninitialized.
        ///</param>
        ///<returns>
        ///true if the <see cref="T:System.Collections.Generic.Dictionary`2" /> 
        ///contains an element with the specified key; otherwise, false.
        ///</returns>
        public bool TryGetValue(TKey key, out TValue value)
        {
            lock (this.cacheMap)
            {
                LinkedListNode<LruCacheItem> node;
                if (this.cacheMap.TryGetValue(key, out node))
                {
                    value = node.Value.Value;
                    this.lruList.Remove(node);
                    this.lruList.AddLast(node);
                    return true;
                }

                value = default(TValue);
                return false;
            }
        }

        ///<summary>
        ///Looks for a value for the matching <paramref name="key"/>. If not found, 
        ///calls <paramref name="valueGenerator"/> to retrieve the value and add it to
        ///the cache.
        ///</summary>
        ///<param name="key">
        ///The key of the value to look up.
        ///</param>
        ///<param name="valueGenerator">
        ///Generates a value if one isn't found.
        ///</param>
        ///<returns>
        ///The requested value.
        ///</returns>
        public TValue Get(TKey key, Func<TValue> valueGenerator)
        {
            lock (this.cacheMap)
            {
                LinkedListNode<LruCacheItem> node;
                TValue value;
                if (this.cacheMap.TryGetValue(key, out node))
                {
                    value = node.Value.Value;
                    this.lruList.Remove(node);
                    this.lruList.AddLast(node);
                }
                else
                {
                    value = valueGenerator();
                    if (this.cacheMap.Count >= this.Capacity)
                    {
                        this.RemoveFirst();
                    }

                    LruCacheItem cacheItem = new LruCacheItem(key, value);
                    node = new LinkedListNode<LruCacheItem>(cacheItem);
                    this.lruList.AddLast(node);
                    this.cacheMap.Add(key, node);
                }

                return value;
            }
        }

        ///<summary>
        ///Adds the specified key and value to the dictionary.
        ///</summary>
        ///<param name="key">
        ///The key of the element to add.
        ///</param>
        ///<param name="value">
        ///The value of the element to add. The value can be null for reference types.
        ///</param>
        public void Add(TKey key, TValue value)
        {
            lock (this.cacheMap)
            {
                if (this.cacheMap.Count >= this.Capacity)
                {
                    this.RemoveFirst();
                }

                LruCacheItem cacheItem = new LruCacheItem(key, value);
                LinkedListNode<LruCacheItem> node = 
                    new LinkedListNode<LruCacheItem>(cacheItem);
                this.lruList.AddLast(node);
                this.cacheMap.Add(key, node);
            }
        }

        private void RemoveFirst()
        {
            //Remove from LRUPriority
            LinkedListNode<LruCacheItem> node = this.lruList.First;
            this.lruList.RemoveFirst();

            //Remove from cache
            this.cacheMap.Remove(node.Value.Key);

            //dispose
            this.dispose?.Invoke(node.Value.Value);
        }

        private class LruCacheItem
        {
            public LruCacheItem(TKey k, TValue v)
            {
                this.Key = k;
                this.Value = v;
            }

            public TKey Key { get; }

            public TValue Value { get; }
        }
    }
}

InformationsquelleAutor der Antwort mheyman