blocks|key|1786786|text|为什么不直接使用大小为2的数组呢？队列应该能够动态地增长和缩小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1786787|或者在Queue<T>实例的周围创建一个包装器类，并在每次将<T>对象入队时检查队列的大小。如果大于2，则将第一个项目出列。|offset|length|style|CODE|1786788|entityMap^0|0|3|8|U|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

Why wouldn't you just use an array with a size of 2? A Queue is supposed to be able to dynamically grow and shrink.

Or create a wrapper class around an instance of <code>Queue&lt;T&gt;</code> instance and each time one enqueues a <code>&lt;T&gt;</code> object, check the size of the queue. If larger than 2, dequeue the first item.

blocks|key|1571890|text|你应该创建你自己的类，一个环形缓冲区可能会满足你的需要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1571891|.NET中的数据结构允许您指定容量，但数组除外，它用于构建用于保存内部数据的内部数据结构。|1571892|例如，对于列表，容量用于调整内部数组的大小。当您开始向列表中添加元素时，它将从索引0开始填充此数组，当它达到您的容量时，它会将容量增加到一个新的更高容量，并继续填充它。|1571893|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You should create your own class, a ringbuffer would probably fit your needs.

The data structures in .NET that allows you to specify capacity, except for array, uses this to build the internal data structure used to hold the internal data.

For instance, for a list, capacity is used to size an internal array. When you start adding elements to the list, it'll start filling this array from index 0 and up, and when it reaches your capacity, it increases the capacity to a new higher capacity, and continues filling it up.

blocks|key|1571938|text|我已经拼凑出了我正在寻找的东西的一个基本版本，它不是完美的，但它会做这项工作，直到出现更好的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1571939|public+class+LimitedQueue<T>+:+Queue<T>
{
++++public+int+Limit+{+get;+set;+}

++++public+LimitedQueue(int+limit)+:+base(limit)
++++{
++++++++Limit+=+limit;
++++}

++++public+new+void+Enqueue(T+item)
++++{
++++++++while+(Count+>=+Limit)
++++++++{
++++++++++++Dequeue();
++++++++}
++++++++base.Enqueue(item);
++++}
}|code-block|syntax|javascript|1571940|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I've knocked up a basic version of what I'm looking for, it's not perfect but it'll do the job until something better comes along.

<pre><code>public class LimitedQueue&lt;T&gt; : Queue&lt;T&gt;
{
 public int Limit { get; set; }

 public LimitedQueue(int limit) : base(limit)
 {
 Limit = limit;
 }

 public new void Enqueue(T item)
 {
 while (Count &gt;= Limit)
 {
 Dequeue();
 }
 base.Enqueue(item);
 }
}
</code></pre>

blocks|key|1571985|text|我建议你调出C5+Library。与SCG+(System.Collections.Generic)不同，C5被编程为接口，并被设计为子类化。大多数公共方法都是虚的，没有一个类是密封的。这样，你就不必使用那些讨厌的“新”关键字了，如果你的LimitedQueue<T>被转换成一个SCG.Queue<T>，就不会触发这个关键字。使用C5并使用与之前相同的代码，您将从CircularQueue<T>派生。CircularQueue<T>实际上同时实现了一个堆栈和一个队列，因此您几乎可以免费获得这两个选项的限制。我在下面用大约3.5个构造重写了它：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1571986|using+C5;

public+class+LimitedQueue<T>+:+CircularQueue<T>
{
++++public+int+Limit+{+get;+set;+}

++++public+LimitedQueue(int+limit)+:+base(limit)
++++{
++++++++this.Limit+=+limit;
++++}

++++public+override+void+Push(T+item)
++++{
++++++++CheckLimit(false);
++++++++base.Push(item);
++++}

++++public+override+void+Enqueue(T+item)
++++{
++++++++CheckLimit(true);
++++++++base.Enqueue(item);
++++}

++++protected+virtual+void+CheckLimit(bool+enqueue)
++++{
++++++++while+(this.Count+>=+this.Limit)
++++++++{
++++++++++++if+(enqueue)
++++++++++++{
++++++++++++++++this.Dequeue();
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++this.Pop();
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1571987|我认为这段代码应该完全符合您的要求。|1571988|entityMap|0|LINK|mutability|MUTABLE|url|http://www.itu.dk/research/c5^0|3B|F|3W|C|53|G|5M|G|6|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I would recommend that you pull up the <a href="http://www.itu.dk/research/c5" rel="noreferrer">C5 Library</a>. Unlike SCG (System.Collections.Generic), C5 is programmed to interface and designed to be subclassed. Most public methods are virtual and none of the classes are sealed. This way, you won't have to use that icky "new" keyword which wouldn't trigger if your <code>LimitedQueue&lt;T&gt;</code> were cast to a <code>SCG.Queue&lt;T&gt;</code>. With C5 and using close to the same code as you had before, you would derive from the <code>CircularQueue&lt;T&gt;</code>. The <code>CircularQueue&lt;T&gt;</code> actually implements both a stack and a queue, so you can get both options with a limit nearly for free. I've rewritten it below with some 3.5 constructs:

<pre><code>using C5;

public class LimitedQueue&lt;T&gt; : CircularQueue&lt;T&gt;
{
 public int Limit { get; set; }

 public LimitedQueue(int limit) : base(limit)
 {
 this.Limit = limit;
 }

 public override void Push(T item)
 {
 CheckLimit(false);
 base.Push(item);
 }

 public override void Enqueue(T item)
 {
 CheckLimit(true);
 base.Enqueue(item);
 }

 protected virtual void CheckLimit(bool enqueue)
 {
 while (this.Count &gt;= this.Limit)
 {
 if (enqueue)
 {
 this.Dequeue();
 }
 else
 {
 this.Pop();
 }
 }
 }
}
</code></pre>

I think that this code should do exactly what you were looking for.

blocks|key|1572031|text|我希望这门课能对你有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1572032|在内部，循环FIFO缓冲区使用指定大小的队列。一旦达到缓冲区的大小，它将用新的项替换旧的项。|1572033|注意:您不能随意删除项目。我将Remove(T+item)方法设置为返回false。如果需要，您可以进行修改以随机删除项目|1572034|public+class+CircularFIFO<T>+:+ICollection<T>+,+IDisposable
{
++++public+Queue<T>+CircularBuffer;

++++///+<summary>
++++///+The+default+initial+capacity.
++++///+</summary>
++++private+int+capacity+=+32;

++++///+<summary>
++++///+Gets+the+actual+capacity+of+the+FIFO.
++++///+</summary>
++++public+int+Capacity
++++{
++++++++get+{+return+capacity;+}++++++++++
++++}

++++///+<summary>
++++///++Initialize+a+new+instance+of+FIFO+class+that+is+empty+and+has+the+default+initial+capacity.
++++///+</summary>
++++public+CircularFIFO()
++++{++++++++++++
++++++++CircularBuffer+=+new+Queue<T>();
++++}

++++///+<summary>
++++///+Initialize+a+new+instance+of+FIFO+class+that+is+empty+and+has+the+specified+initial+capacity.
++++///+</summary>
++++///+<param+name="size">+Initial+capacity+of+the+FIFO.+</param>
++++public+CircularFIFO(int+size)
++++{
++++++++capacity+=+size;
++++++++CircularBuffer+=+new+Queue<T>(capacity);
++++}

++++///+<summary>
++++///+Adds+an+item+to+the+end+of+the+FIFO.
++++///+</summary>
++++///+<param+name="item">+The+item+to+add+to+the+end+of+the+FIFO.+</param>
++++public+void+Add(T+item)
++++{
++++++++if+(this.Count+>=+this.Capacity)
++++++++++++Remove();

++++++++CircularBuffer.Enqueue(item);
++++}

++++///+<summary>
++++///+Adds+array+of+items+to+the+end+of+the+FIFO.
++++///+</summary>
++++///+<param+name="item">+The+array+of+items+to+add+to+the+end+of+the+FIFO.+</param>
+++++public+void+Add(T[]+item)
++++{+
++++++++int+enqueuedSize+=+0;
++++++++int+remainEnqueueSize+=+this.Capacity+-+this.Count;

++++++++for+(;+(enqueuedSize+<+item.Length+&&+enqueuedSize+<+remainEnqueueSize);+enqueuedSize%2B%2B)
++++++++++++CircularBuffer.Enqueue(item[enqueuedSize]);

++++++++if+((item.Length+-+enqueuedSize)+!=+0)
++++++++{
++++++++++++Remove((item.Length+-+enqueuedSize));//remaining+item+size

++++++++++++for+(;+enqueuedSize+<+item.Length;+enqueuedSize%2B%2B)
++++++++++++++++CircularBuffer.Enqueue(item[enqueuedSize]);
++++++++}+++++++++++
++++}

++++///+<summary>
++++///+Removes+and+Returns+an+item+from+the+FIFO.
++++///+</summary>
++++///+<returns>+Item+removed.+</returns>
++++public+T+Remove()
++++{
++++++++T+removedItem+=+CircularBuffer.Peek();
++++++++CircularBuffer.Dequeue();

++++++++return+removedItem;
++++}

++++///+<summary>
++++///+Removes+and+Returns+the+array+of+items+form+the+FIFO.
++++///+</summary>
++++///+<param+name="size">+The+size+of+item+to+be+removed+from+the+FIFO.+</param>
++++///+<returns>+Removed+array+of+items+</returns>
++++public+T[]+Remove(int+size)
++++{
++++++++if+(size+>+CircularBuffer.Count)
++++++++++++size+=+CircularBuffer.Count;

++++++++T[]+removedItems+=+new+T[size];

++++++++for+(int+i+=+0;+i+<+size;+i%2B%2B)
++++++++{
++++++++++++removedItems[i]+=+CircularBuffer.Peek();
++++++++++++CircularBuffer.Dequeue();
++++++++}

++++++++return+removedItems;
++++}

++++///+<summary>
++++///+Returns+the+item+at+the+beginning+of+the+FIFO+with+out+removing+it.
++++///+</summary>
++++///+<returns>+Item+Peeked.+</returns>
++++public+T+Peek()
++++{
++++++++return+CircularBuffer.Peek();
++++}

++++///+<summary>
++++///+Returns+the+array+of+item+at+the+beginning+of+the+FIFO+with+out+removing+it.
++++///+</summary>
++++///+<param+name="size">+The+size+of+the+array+items.+</param>
++++///+<returns>+Array+of+peeked+items.+</returns>
++++public+T[]+Peek(int+size)
++++{
++++++++T[]+arrayItems+=+new+T[CircularBuffer.Count];
++++++++CircularBuffer.CopyTo(arrayItems,+0);

++++++++if+(size+>+CircularBuffer.Count)
++++++++++++size+=+CircularBuffer.Count;

++++++++T[]+peekedItems+=+new+T[size];

++++++++Array.Copy(arrayItems,+0,+peekedItems,+0,+size);

++++++++return+peekedItems;
++++}

++++///+<summary>
++++///+Gets+the+actual+number+of+items+presented+in+the+FIFO.
++++///+</summary>
++++public+int+Count
++++{
++++++++get
++++++++{
++++++++++++return+CircularBuffer.Count;
++++++++}
++++}

++++///+<summary>
++++///+Removes+all+the+contents+of+the+FIFO.
++++///+</summary>
++++public+void+Clear()
++++{
++++++++CircularBuffer.Clear();
++++}

++++///+<summary>
++++///+Resets+and+Initialize+the+instance+of+FIFO+class+that+is+empty+and+has+the+default+initial+capacity.
++++///+</summary>
++++public+void+Reset()
++++{
++++++++Dispose();
++++++++CircularBuffer+=+new+Queue<T>(capacity);
++++}

++++#region+ICollection<T>+Members

++++///+<summary>
++++///+Determines+whether+an+element+is+in+the+FIFO.
++++///+</summary>
++++///+<param+name="item">+The+item+to+locate+in+the+FIFO.+</param>
++++///+<returns></returns>
++++public+bool+Contains(T+item)
++++{
++++++++return+CircularBuffer.Contains(item);
++++}

++++///+<summary>
++++///+Copies+the+FIFO+elements+to+an+existing+one-dimensional+array.+
++++///+</summary>
++++///+<param+name="array">+The+one-dimensional+array+that+have+at+list+a+size+of+the+FIFO+</param>
++++///+<param+name="arrayIndex"></param>
++++public+void+CopyTo(T[]+array,+int+arrayIndex)
++++{
++++++++if+(array.Length+>=+CircularBuffer.Count)
++++++++++++CircularBuffer.CopyTo(array,+0);+++++++++++
++++}

++++public+bool+IsReadOnly
++++{
++++++++get+{+return+false;+}
++++}

++++public+bool+Remove(T+item)
++++{
++++++++return+false;+
++++}

++++#endregion

++++#region+IEnumerable<T>+Members

++++public+IEnumerator<T>+GetEnumerator()
++++{
+++++++return+CircularBuffer.GetEnumerator();
++++}

++++#endregion

++++#region+IEnumerable+Members

++++IEnumerator+IEnumerable.GetEnumerator()
++++{
++++++++return+CircularBuffer.GetEnumerator();
++++}

++++#endregion

++++#region+IDisposable+Members

++++///+<summary>
++++///+Releases+all+the+resource+used+by+the+FIFO.
++++///+</summary>
++++public+void+Dispose()
++++{++++++++++
++++++++CircularBuffer.Clear();
++++++++CircularBuffer+=+null;
++++++++GC.Collect();
++++}

++++#endregion
}|code-block|syntax|javascript|1572035|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Well I hope this class will helps You: 
Internally the Circular FIFO Buffer use a Queue&lt;T&gt; with the specified size. 
Once the size of the buffer is reached, it will replaces older items with new ones.

NOTE: You can't remove items randomly. I set the method Remove(T item) to return false.
if You want You can modify to remove items randomly

<pre><code>public class CircularFIFO&lt;T&gt; : ICollection&lt;T&gt; , IDisposable
{
 public Queue&lt;T&gt; CircularBuffer;

 /// &lt;summary&gt;
 /// The default initial capacity.
 /// &lt;/summary&gt;
 private int capacity = 32;

 /// &lt;summary&gt;
 /// Gets the actual capacity of the FIFO.
 /// &lt;/summary&gt;
 public int Capacity
 {
 get { return capacity; } 
 }

 /// &lt;summary&gt;
 /// Initialize a new instance of FIFO class that is empty and has the default initial capacity.
 /// &lt;/summary&gt;
 public CircularFIFO()
 { 
 CircularBuffer = new Queue&lt;T&gt;();
 }

 /// &lt;summary&gt;
 /// Initialize a new instance of FIFO class that is empty and has the specified initial capacity.
 /// &lt;/summary&gt;
 /// &lt;param name="size"&gt; Initial capacity of the FIFO. &lt;/param&gt;
 public CircularFIFO(int size)
 {
 capacity = size;
 CircularBuffer = new Queue&lt;T&gt;(capacity);
 }

 /// &lt;summary&gt;
 /// Adds an item to the end of the FIFO.
 /// &lt;/summary&gt;
 /// &lt;param name="item"&gt; The item to add to the end of the FIFO. &lt;/param&gt;
 public void Add(T item)
 {
 if (this.Count &gt;= this.Capacity)
 Remove();

 CircularBuffer.Enqueue(item);
 }

 /// &lt;summary&gt;
 /// Adds array of items to the end of the FIFO.
 /// &lt;/summary&gt;
 /// &lt;param name="item"&gt; The array of items to add to the end of the FIFO. &lt;/param&gt;
 public void Add(T[] item)
 { 
 int enqueuedSize = 0;
 int remainEnqueueSize = this.Capacity - this.Count;

 for (; (enqueuedSize &lt; item.Length &amp;&amp; enqueuedSize &lt; remainEnqueueSize); enqueuedSize++)
 CircularBuffer.Enqueue(item[enqueuedSize]);

 if ((item.Length - enqueuedSize) != 0)
 {
 Remove((item.Length - enqueuedSize));//remaining item size

 for (; enqueuedSize &lt; item.Length; enqueuedSize++)
 CircularBuffer.Enqueue(item[enqueuedSize]);
 } 
 }

 /// &lt;summary&gt;
 /// Removes and Returns an item from the FIFO.
 /// &lt;/summary&gt;
 /// &lt;returns&gt; Item removed. &lt;/returns&gt;
 public T Remove()
 {
 T removedItem = CircularBuffer.Peek();
 CircularBuffer.Dequeue();

 return removedItem;
 }

 /// &lt;summary&gt;
 /// Removes and Returns the array of items form the FIFO.
 /// &lt;/summary&gt;
 /// &lt;param name="size"&gt; The size of item to be removed from the FIFO. &lt;/param&gt;
 /// &lt;returns&gt; Removed array of items &lt;/returns&gt;
 public T[] Remove(int size)
 {
 if (size &gt; CircularBuffer.Count)
 size = CircularBuffer.Count;

 T[] removedItems = new T[size];

 for (int i = 0; i &lt; size; i++)
 {
 removedItems[i] = CircularBuffer.Peek();
 CircularBuffer.Dequeue();
 }

 return removedItems;
 }

 /// &lt;summary&gt;
 /// Returns the item at the beginning of the FIFO with out removing it.
 /// &lt;/summary&gt;
 /// &lt;returns&gt; Item Peeked. &lt;/returns&gt;
 public T Peek()
 {
 return CircularBuffer.Peek();
 }

 /// &lt;summary&gt;
 /// Returns the array of item at the beginning of the FIFO with out removing it.
 /// &lt;/summary&gt;
 /// &lt;param name="size"&gt; The size of the array items. &lt;/param&gt;
 /// &lt;returns&gt; Array of peeked items. &lt;/returns&gt;
 public T[] Peek(int size)
 {
 T[] arrayItems = new T[CircularBuffer.Count];
 CircularBuffer.CopyTo(arrayItems, 0);

 if (size &gt; CircularBuffer.Count)
 size = CircularBuffer.Count;

 T[] peekedItems = new T[size];

 Array.Copy(arrayItems, 0, peekedItems, 0, size);

 return peekedItems;
 }

 /// &lt;summary&gt;
 /// Gets the actual number of items presented in the FIFO.
 /// &lt;/summary&gt;
 public int Count
 {
 get
 {
 return CircularBuffer.Count;
 }
 }

 /// &lt;summary&gt;
 /// Removes all the contents of the FIFO.
 /// &lt;/summary&gt;
 public void Clear()
 {
 CircularBuffer.Clear();
 }

 /// &lt;summary&gt;
 /// Resets and Initialize the instance of FIFO class that is empty and has the default initial capacity.
 /// &lt;/summary&gt;
 public void Reset()
 {
 Dispose();
 CircularBuffer = new Queue&lt;T&gt;(capacity);
 }

 #region ICollection&lt;T&gt; Members

 /// &lt;summary&gt;
 /// Determines whether an element is in the FIFO.
 /// &lt;/summary&gt;
 /// &lt;param name="item"&gt; The item to locate in the FIFO. &lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public bool Contains(T item)
 {
 return CircularBuffer.Contains(item);
 }

 /// &lt;summary&gt;
 /// Copies the FIFO elements to an existing one-dimensional array. 
 /// &lt;/summary&gt;
 /// &lt;param name="array"&gt; The one-dimensional array that have at list a size of the FIFO &lt;/param&gt;
 /// &lt;param name="arrayIndex"&gt;&lt;/param&gt;
 public void CopyTo(T[] array, int arrayIndex)
 {
 if (array.Length &gt;= CircularBuffer.Count)
 CircularBuffer.CopyTo(array, 0); 
 }

 public bool IsReadOnly
 {
 get { return false; }
 }

 public bool Remove(T item)
 {
 return false; 
 }

 #endregion

 #region IEnumerable&lt;T&gt; Members

 public IEnumerator&lt;T&gt; GetEnumerator()
 {
 return CircularBuffer.GetEnumerator();
 }

 #endregion

 #region IEnumerable Members

 IEnumerator IEnumerable.GetEnumerator()
 {
 return CircularBuffer.GetEnumerator();
 }

 #endregion

 #region IDisposable Members

 /// &lt;summary&gt;
 /// Releases all the resource used by the FIFO.
 /// &lt;/summary&gt;
 public void Dispose()
 { 
 CircularBuffer.Clear();
 CircularBuffer = null;
 GC.Collect();
 }

 #endregion
}
</code></pre>

blocks|key|1787032|text|如果它对任何人有用，我做了一个LimitedStack<T>。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1787033|public+class+LimitedStack<T>
{
++++public+readonly+int+Limit;
++++private+readonly+List<T>+_stack;

++++public+LimitedStack(int+limit+=+32)
++++{
++++++++Limit+=+limit;
++++++++_stack+=+new+List<T>(limit);
++++}

++++public+void+Push(T+item)
++++{
++++++++if+(_stack.Count+==+Limit)+_stack.RemoveAt(0);
++++++++_stack.Add(item);
++++}

++++public+T+Peek()
++++{
++++++++return+_stack[_stack.Count+-+1];
++++}

++++public+void+Pop()
++++{
++++++++_stack.RemoveAt(_stack.Count+-+1);
++++}

++++public+int+Count
++++{
++++++++get+{+return+_stack.Count;+}
++++}
}|code-block|syntax|javascript|1787034|当最旧的项(堆栈的底部)变得太大时，它会删除它。|1787035|(这个问题是谷歌对"C#限制堆栈大小“的最高搜索结果)|1787036|entityMap^0|F|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|V|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

If it's of any use to anyone, I made a <code>LimitedStack&lt;T&gt;</code>.

<pre><code>public class LimitedStack&lt;T&gt;
{
 public readonly int Limit;
 private readonly List&lt;T&gt; _stack;

 public LimitedStack(int limit = 32)
 {
 Limit = limit;
 _stack = new List&lt;T&gt;(limit);
 }

 public void Push(T item)
 {
 if (_stack.Count == Limit) _stack.RemoveAt(0);
 _stack.Add(item);
 }

 public T Peek()
 {
 return _stack[_stack.Count - 1];
 }

 public void Pop()
 {
 _stack.RemoveAt(_stack.Count - 1);
 }

 public int Count
 {
 get { return _stack.Count; }
 }
}
</code></pre>

It removes the oldest item (bottom of stack) when it gets too big.

(This question was the top Google result for "C# limit stack size")

blocks|key|1787064|text|并发解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1787065|public+class+LimitedConcurrentQueue<ELEMENT>+:+ConcurrentQueue<ELEMENT>
{
++++public+readonly+int+Limit;

++++public+LimitedConcurrentQueue(int+limit)
++++{
++++++++Limit+=+limit;
++++}

++++public+new+void+Enqueue(ELEMENT+element)
++++{
++++++++base.Enqueue(element);
++++++++if+(Count+>+Limit)
++++++++{
++++++++++++TryDequeue(out+ELEMENT+discard);
++++++++}
++++}
}|code-block|syntax|javascript|1787066|注意:由于Enqueue控制元素的添加，并且一次只添加一个元素，因此不需要为TryDequeue执行while。|offset|length|style|CODE|1787067|entityMap^0|0|0|5|7|12|A|1E|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

<h3>Concurrent Solution</h3>
<pre><code>public class LimitedConcurrentQueue&lt;ELEMENT&gt; : ConcurrentQueue&lt;ELEMENT&gt;
{
 public readonly int Limit;

 public LimitedConcurrentQueue(int limit)
 {
 Limit = limit;
 }

 public new void Enqueue(ELEMENT element)
 {
 base.Enqueue(element);
 if (Count &gt; Limit)
 {
 TryDequeue(out ELEMENT discard);
 }
 }
}
</code></pre>
Note: Since <code>Enqueue</code> controls the addition of elements, and does so one at a time, there is no need to execute a <code>while</code> for <code>TryDequeue</code>.

blocks|key|1572190|text|您可以使用LinkedList并添加线程安全性：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1572191|public+class+Buffer<T>+:+LinkedList<T>
{
++++private+int+capacity;

++++public+Buffer(int+capacity)
++++{
++++++++this.capacity+=+capacity;+++
++++}

++++public+void+Enqueue(T+item)
++++{
++++++++//+todo:+add+synchronization+mechanism
++++++++if+(Count+==+capacity)+RemoveLast();
++++++++AddFirst(item);
++++}

++++public+T+Dequeue()
++++{
++++++++//+todo:+add+synchronization+mechanism
++++++++var+last+=+Last.Value;
++++++++RemoveLast();
++++++++return+last;
++++}
}|code-block|syntax|javascript|1572192|需要注意的一点是，在本例中，默认的枚举顺序是LIFO。但如果有必要，这一点可以被覆盖。|1572193|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.linkedlist-1?view=netcore-3.1^0|5|A|5|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

You can use a <a href="https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.linkedlist-1?view=netcore-3.1" rel="nofollow noreferrer"><code>LinkedList&lt;T&gt;</code></a> and add thread safety:

<pre><code>public class Buffer&lt;T&gt; : LinkedList&lt;T&gt;
{
 private int capacity;

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

 public void Enqueue(T item)
 {
 // todo: add synchronization mechanism
 if (Count == capacity) RemoveLast();
 AddFirst(item);
 }

 public T Dequeue()
 {
 // todo: add synchronization mechanism
 var last = Last.Value;
 RemoveLast();
 return last;
 }
}
</code></pre>

One thing to note is the default enumeration order will be LIFO in this example. But that can be overridden if necessary.

I have a Queue&lt;T&gt; object that I have initialised to a capacity of 2, but obviously that is just the capacity and it keeps expanding as I add items. Is there already an object that automatically dequeues an item when the limit is reached, or is the best solution to create my own inherited class?

Limit size of Queue<T> in .NET?

数据结构

我有一个Queue对象，我已经将其初始化为容量2，但很明显，这只是容量，随着我添加项，它会不断扩展。是否已经有一个对象在达到限制时自动将项出队，或者是创建我自己的继承类的最佳解决方案？

问在.NET中限制Queue<T>的大小？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET中限制Queue<T>的大小？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET中限制Queue<T>的大小？
EN