Question

我是使用Generics并尝试使用C＃中的Generic Circular双向链表实现LRU缓存的新手。我有几个问题。请帮帮我

1）在我的LRUCache构造函数中正在执行此操作

    head = new Node<T>(default(T), default(T));

这是不对的，我想用一些默认键值对（-1，-1）数据而不是类型默认值初始化我的头。

2）在我的get中，我检查节点是基于键并返回默认值（T）为空。但我想返回null本身。

这是我的代码

 public class Node<T>
{
    public KeyValuePair<T, T> KeyValue { get; set; }
    public Node<T> Next { get; set; }
    public Node<T> Previous { get; set; }
    public Node(T key, T value)
    {
        this.KeyValue = new KeyValuePair<T, T>(key, value);
        Next = null;
        Previous = null;
    }
}
public class LRUCache<T>
{
    private readonly int capacity;
    private int count;
    private readonly Node<T> head;
    private readonly Dictionary<T, Node<T>> myDictionary;
    public LRUCache(int capacity)
    {
        head = new Node<T>(default(T), default(T));
        head.Next = head;
        head.Previous = head;
        this.capacity = capacity;
        myDictionary = new Dictionary<T, Node<T>>();
    }
 public void set(T key, T value)
  {
   Node<T> node;
        myDictionary.TryGetValue(key, out node);
        if (node == null)
        {
            if (this.count == this.capacity)
            {
                // remove the last element
                myDictionary.Remove(head.Previous.KeyValue.Key);
                head.Previous = head.Previous.Previous;
                head.Previous.Next = head;
                count--;
            }
            // create new node and add to dictionary
            var newNode = new Node<T>(key, value);
            myDictionary[key] = newNode;
            this.InsertAfterTheHead(newNode);
            // increase count
            count++;
        }
        else
        {
            node.KeyValue = new KeyValuePair<T, T>(key, value);
            this.MoveToFirstElementAfterHead(node);
        }
  }
 public T get(T key)
 {
        Node<T> node;
        myDictionary.TryGetValue(key, out node);
        if (node == null)
        {
            return default(T);

        }
        this.MoveItToFirstElementAfterHead(node);
        return node.KeyValue.Value;
 }
}

Answer 1

假设节点中包含的值是包含用作键的属性的类，请尝试以下操作：

public abstract class Node<TNode, TNodeSupport, TKey, TValue>
    where TNode : Node<TNode, TNodeSupport, TKey, TValue>
    where TNodeSupport : Node<TNode, TNodeSupport, TKey, TValue>.BaseNodeSupport, new()
    where TValue : class
{
    protected static readonly TNodeSupport Support = new TNodeSupport();

    public KeyValuePair<TKey, TValue> KeyValue { get; set; }
    public TNode Next { get; set; }
    public TNode Previous { get; set; }
    protected Node(TValue value)
    {
        this.KeyValue = new KeyValuePair<TKey, TValue>(Support.GetKeyFromValue(value), value);
        Next = null;
        Previous = null;
    }

    public class LRUCache
    {
        private readonly int capacity;
        private int count;
        private readonly TNode head;
        private readonly Dictionary<TKey, TNode> myDictionary;
        public LRUCache(int capacity)
        {
            head = Support.CreateHeadNode();
            head.Next = head;
            head.Previous = head;
            this.capacity = capacity;
            myDictionary = new Dictionary<TKey, TNode>();
        }
        public void set(TValue value)
        {
           TKey key = Support.GetKeyFromValue(value);
           TNode node;
           myDictionary.TryGetValue(key, out node);
           if (node == null)
           {
              if (this.count == this.capacity)
              {
                    // remove the last element
                   myDictionary.Remove(head.Previous.KeyValue.Key);
                   head.Previous = head.Previous.Previous;
                   head.Previous.Next = head;
                   count--;
               }
               // create new node and add to dictionary
               var newNode = Support.CreateNodeFromValue(value);
               myDictionary[key] = newNode;
               this.InsertAfterTheHead(newNode);
               // increase count
               count++;
           }
           else
           {
               node.KeyValue = new KeyValuePair<TKey, TValue>(key, value);
                this.MoveToFirstElementAfterHead(node);
           }
        }
        public TValue get(TKey key)
        {
            TNode node;
            myDictionary.TryGetValue(key, out node);
            if (node == null)
            {
                return null;

            }
            this.MoveItToFirstElementAfterHead(node);
            return node.KeyValue.Value;
        }
    }

    public abstract class BaseNodeSupport
    {
        public abstract TKey GetKeyFromValue(TValue value);
        public abstract TNode CreateNodeFromValue(TValue value);
        public abstract TNode CreateHeadNode();
    }

}

定义您的节点和项目：

public class Item
{
    public Guid Id;
    public String Data;
}
public class ItemNode : Node<ItemNode, ItemNode.Support, Guid, Item>
{
    public class NodeSupport : BaseNodeSupport
    {
        public override Guid GetKeyFromValue(Item value) { return value.Id; }
        public override ItemNode CreateNodeFromValue(Item value) {return new ItemNode(value)
        public override ItemNode CreateHeadNode() { return new ItemNode(new Item(){Id = Guid.Empty, Data = String.Empty}); }
    }
    public ItemNode(Item item) : base(item) {}
}

像这样使用：

public class Program
{
    static void Main()
    {
        var cache = new ItemNode.LRUCache(100);
    }
}

在此解决方案中，Node是一个类和一个通用/参数命名空间，用于保存来自第三方库或本地定义的项目。

TNodeSupport类用作单例，提供在整个Node命名空间中使用的三个支持函数。第一个函数接受一个项目并从该项目返回密钥。第二个函数从项目创建TNode。第三个函数使用默认的空项创建默认头节点。

LRUCache包含在Node通用命名空间中，因此它可以访问它所需的泛型类型参数以便运行。 LRUCache逻辑实现与作者的原始实现大致相同。

在定义子类Node的示例中，ItemNode是参数化的子类/子名称空间。 ItemNode为TNode参数指定自身，为TNodeSupport参数指定ItemNode.NodeSupport，为TKey参数指定Guid，为TValue参数指定Item。

Item类是一个人为的类，用于包含一些数据以及将用作项目键的Id。

Item.NodeSupport类派生自Node.BaseNodeSupport类，并覆盖三个支持函数。在GetKeyFromValue方法中，它返回所提供的Item实例的Id属性。在CreateNodeFromValue方法中，它返回使用提供的Item实例构造的ItemNode。在CreateHeadNode方法中，它返回一个新的ItemNode，该ItemNode由一个新的Item构成，该Item包含Id的Guid.Empty和数据的String.Empty。

在Program类中，我们实例化ItemNode.LRUCache以包含包含Items的ItemNode实例。

LRU缓存与通用循环双向链表C＃

1 个答案: