Aquí podría ser tu PUBLICIDAD


¿Limitar el tamaño de Queue <T> en .NET?

votos
50

Tengo un objeto Queue <T> que he inicializado a una capacidad de 2, pero obviamente esa es solo la capacidad y sigue expandiéndose a medida que agrego elementos. ¿Ya hay un objeto que dequeue automáticamente un artículo cuando se alcanza el límite, o es la mejor solución para crear mi propia clase heredada?

Publicado el 04/08/2008 a las 15:47
fuente por usuario tags2k
En otros idiomas...        العربية       

7 respuestas

votos
32

He alterado una versión básica de lo que estoy buscando, no es perfecta, pero hará el trabajo hasta que surja algo mejor.

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);
    }
}
Respondida el 04/08/2008 a las 03:57
fuente por usuario tags2k


Aquí podría ser tu PUBLICIDAD


votos
17

Recomiendo que levante la Biblioteca C5 . A diferencia de SCG (System.Collections.Generic), C5 está programado para interfaz y diseñado para ser subclassed. La mayoría de los métodos públicos son virtuales y ninguna de las clases está sellada. De esta manera, no tendrá que usar esa palabra clave icky "nueva" que no se desencadenaría si su LimitedQueue<T>conversión a a SCG.Queue<T>. Con C5 y usando casi el mismo código que tenía antes, derivaría de CircularQueue<T>. La CircularQueue<T>realidad implementa tanto una pila como una cola, por lo que puedes obtener ambas opciones con un límite casi gratuito. Lo he reescrito a continuación con unos 3.5 constructos:

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();
            }
        }
    }
}

Creo que este código debería hacer exactamente lo que estabas buscando.

Respondida el 24/10/2008 a las 02:51
fuente por usuario Marcus Griep

votos
5

Debes crear tu propia clase, un Ringbuffer probablemente se ajuste a tus necesidades.

Las estructuras de datos en .NET que le permiten especificar la capacidad, a excepción de la matriz, usa esto para construir la estructura de datos interna utilizada para contener los datos internos.

Por ejemplo, para una lista, la capacidad se usa para dimensionar una matriz interna. Cuando comience a agregar elementos a la lista, comenzará a llenar esta matriz desde el índice 0 y hacia arriba, y cuando alcance su capacidad, aumentará la capacidad a una nueva capacidad más alta y continuará llenándola.

Respondida el 04/08/2008 a las 03:56
fuente por usuario Lasse Vågsæther Karlsen

votos
3

Bueno espero que esta voluntad de clase le ayuda a:
Internamente, la FIFO buffer circular utilizar una cola <T> con el tamaño especificado. Una vez que se alcanza el tamaño de la memoria intermedia, se sustituye artículos anteriores con los nuevos.

NOTA: No se puede eliminar elementos al azar. Me puse el método Remove (artículo T) para volver falsa. Si lo desea, puede modificar para eliminar los elementos al azar

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
}
Respondida el 15/11/2011 a las 01:40
fuente por usuario Robel.E

votos
3

¿Por qué no usarías simplemente una matriz con un tamaño de 2? Se supone que una cola puede crecer y contraerse dinámicamente.

O cree una clase contenedora alrededor de una instancia de Queue<T>instancia y cada vez que encola un <T>objeto, verifique el tamaño de la cola. Si es mayor que 2, dequeue el primer elemento.

Respondida el 04/08/2008 a las 03:52
fuente por usuario CodingWithoutComments

votos
1

Si es de ninguna utilidad para nadie, hice una 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; }
    }
}

Se elimina el elemento más antiguo (parte inferior de la pila) cuando se hace demasiado grande.

(Esta cuestión fue el resultado superior en Google de "C # límite de tamaño de la pila")

Respondida el 15/01/2012 a las 06:28
fuente por usuario mpen

votos
0

Solución concurrente

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);
        }
    }
}

Nota: Puesto que Enqueuecontrola la adición de elementos, y lo hace a uno a la vez, no hay necesidad de ejecutar una whilepara TryDequeue.

Respondida el 09/05/2018 a las 05:39
fuente por usuario SwiftArchitect