Limitar o tamanho de Queue<T> no .NET?
-
08-06-2019 - |
Pergunta
Eu tenho um objeto Queue<T> que inicializei com uma capacidade de 2, mas obviamente essa é apenas a capacidade e continua se expandindo à medida que adiciono itens.Já existe um objeto que retira automaticamente um item da fila quando o limite é atingido ou a melhor solução é criar minha própria classe herdada?
Solução
Criei uma versão básica do que procuro, não é perfeita, mas servirá até que algo melhor apareça.
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);
}
}
Outras dicas
Eu recomendo que você puxe o Biblioteca C5.Ao contrário do SCG (System.Collections.Generic), o C5 é programado para interface e projetado para ser subclassificado.A maioria dos métodos públicos são virtuais e nenhuma das classes é selada.Dessa forma, você não terá que usar aquela palavra-chave "nova" nojenta que não seria acionada se o seu LimitedQueue<T>
foram lançados para um SCG.Queue<T>
.Com C5 e usando quase o mesmo código que você tinha antes, você derivaria do CircularQueue<T>
.O CircularQueue<T>
na verdade, implementa uma pilha e uma fila, para que você possa obter ambas as opções com um limite quase de graça.Eu reescrevi abaixo com algumas construções 3.5:
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();
}
}
}
}
Acho que esse código deve fazer exatamente o que você estava procurando.
Você deve criar sua própria classe, um ringbuffer provavelmente atenderia às suas necessidades.
As estruturas de dados em .NET que permitem especificar a capacidade, exceto array, usam isso para construir a estrutura de dados interna usada para armazenar os dados internos.
Por exemplo, para uma lista, a capacidade é usada para dimensionar um array interno.Quando você começar a adicionar elementos à lista, ele começará a preencher esse array a partir do índice 0 e superior e, quando atingir sua capacidade, aumentará a capacidade para uma nova capacidade superior e continuará preenchendo-a.
Por que você não usaria apenas um array com tamanho 2?Supõe-se que uma fila seja capaz de crescer e diminuir dinamicamente.
Ou crie uma classe wrapper em torno de uma instância de Queue<T>
instância e cada vez que alguém enfileira uma <T>
objeto, verifique o tamanho da fila.Se for maior que 2, retire o primeiro item da fila.
Bem, espero que esta aula ajude você:
Internamente, o Circular FIFO Buffer usa um Queue<T> com o tamanho especificado.Assim que o tamanho do buffer for atingido, ele substituirá os itens mais antigos por novos.
OBSERVAÇÃO:Você não pode remover itens aleatoriamente.Eu configurei o método Remove(T item) para retornar falso.se quiser, você pode modificar para remover itens aleatoriamente
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++)
CircularBuffer.Enqueue(item[enqueuedSize]);
if ((item.Length - enqueuedSize) != 0)
{
Remove((item.Length - enqueuedSize));//remaining item size
for (; enqueuedSize < item.Length; enqueuedSize++)
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++)
{
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
}
Se for de alguma utilidade para alguém, fiz um LimitedStack<T>
.
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; }
}
}
Ele remove o item mais antigo (parte inferior da pilha) quando fica muito grande.
(Esta pergunta foi o principal resultado do Google para "Tamanho limite da pilha em C#")
Solução Simultânea
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);
}
}
}
Observação:Desde Enqueue
controla a adição de elementos, e faz isso um de cada vez, não há necessidade de executar um while
para TryDequeue
.