C#-具有环列表行为的字典？

我需要一个可以存储键和项的环列表字典<代码>容量=50当我添加

#51

时，必须删除第一项。基本上，它必须是一个行为类似于环列表的字典

---

在.NETFramework中有什么东西可以做到这一点吗？或者我必须自己写吗？

我想你找不到任何内置的东西，但你可以使用

---

OrderedDictionary

按项目插入的顺序维护项目。无论何时达到限制/容量，您都可以移除第一项

或使用扩展方法：

编辑：

因为

最新添加的条目将首先返回

所以 您可以删除第一项，如：

dictionary.Remove(dictionary.Last().Key);  

&因此，您的扩展方法是：

addExtension(this Dictionary<string, object> dictionary, string key, object value)
   {
        if(dictionary.Count == 50)
                dictionary.Remove(dictionary.Last().Key);  

        dictionary.Add(key, value);   
   }

addExtension（此字典、字符串键、对象值）
{
如果（dictionary.Count==50）
dictionary.Remove（dictionary.Last（）.Key）；
添加（键、值）；
}

试试这个：

class Program
{
    static void Main(string[] args)
    {
        var rD = new RingDictionary(50);
        for (int i = 0; i < 75; i++)
        {
            rD.Add(i, i);
        }
        foreach (var item in rD.Keys)
        {
            Console.WriteLine("{0} {1}", item, rD[item]);
        }
    }
}

class RingDictionary : OrderedDictionary
{
    int indexKey;

    int _capacity = 0;
    public int Capacity
    {
        get { return _capacity; }
        set
        {
            if (value <= 0)
            {
                var errorMessage = typeof(Environment)
                    .GetMethod(
                        "GetResourceString",
                        System.Reflection.BindingFlags.Static |
                        System.Reflection.BindingFlags.NonPublic,
                        null,
                        new Type[] { typeof(string) },
                        null)
                    .Invoke(null, new object[] { 
                        "ArgumentOutOfRange_NegativeCapacity" 
                    }).ToString();
                throw new ArgumentException(errorMessage);
            }
            _capacity = value;
        }
    }

    public RingDictionary(int capacity)
    {
        indexKey = -1;
        Capacity = capacity;
    }

    public new void Add(object key, object value)
    {
        indexKey++;

        if (base.Keys.Count > _capacity)
        {
            for (int i = base.Keys.Count-1; i >Capacity-1 ; i--)
            {
                base.RemoveAt(i);
            }
        }

        if (base.Keys.Count == _capacity)
        {
            base.RemoveAt(indexKey % _capacity);
            base.Insert(indexKey % _capacity, key, value);
        }
        else
        {
            base.Add(key, value);
        }
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var rD=新的环字典（50）；
对于（int i=0；i<75；i++）
{
rD.Add（i，i）；
}
foreach（rD.key中的var项）
{
WriteLine（“{0}{1}”，item，rD[item]）；
}
}
}
类环字典：OrderedDictionary
{
int索引键；
int _容量=0；
公共int容量
{
获取{return\u capacity；}
设置
{
if（值_容量）
{
对于（int i=base.Keys.Count-1；i>Capacity-1；i--）
{
基底移除（i）；
}
}
if（base.Keys.Count==\u容量）
{
基本移动（索引键%\u容量）；
插入（索引键%\容量、键、值）；
}
其他的
{
添加（键、值）；
}
}
}

您必须自己编写。只需在下面使用一个链表和一个字典。正如Haris Hasan所说，您可以使用OrderedDictionary。它不是密封类，因此您可以从它继承并编写新的

Insert

方法定义（）。不幸的是，它没有重写，但您可以明确地使用类。参数化版本：

静态void AddExtension（此IDictionary dictionary，T key，V value）{dictionary.Add（key，value）；if（dictionary.Count==50）dictionary.Remove（dictionary.First（）.key）；}

您不是正在从

字典中删除随机项吗？

字典中的项顺序没有定义。您甚至可能正在删除刚才添加的项：-）请参见@AshokDamani，例如，现在至少您正在删除随机项，但您确定它不是新添加的：-）以获得更好的性能你不应该删除和插入值，而应该覆盖旧的值。除此之外，我会按照你的方式去做。