Posso limitare la profondità di uno stack generico?

Esiste un modo integrato per limitare la profondità di un System.Collection.Generics.Stack? In modo che se sei alla massima capacità, spingendo un nuovo elemento rimuoverebbe la parte inferiore della pila?

So che posso farlo convertendo in un array e ricostruendo lo stack, ma ho pensato che probabilmente c’è già un metodo su di esso.

EDIT: ho scritto un metodo di estensione:

public static void Trim (this Stack stack, int trimCount) { if (stack.Count <= trimCount) return; stack = new Stack ( stack .ToArray() .Take(trimCount) ); } 

Quindi, restituisce una nuova pila al taglio, ma non è immutabilità il modo funzionale =)

Il motivo è che sto memorizzando i passaggi di annullamento per un’app in uno stack e desidero solo memorizzare una quantità limitata di passaggi.

Quello che stai cercando è chiamato un dropout stack . AFAIK, il BCL non ne contiene uno, anche se sono banali da implementare. In genere, la funzionalità Annulla e Ripristina si basa su tali strutture di dati.

Sono fondamentalmente un array e quando spingi nello stack la “cima” della pila si muove attorno all’array. Alla fine, il top si riavvolgerà all’inizio quando lo stack è pieno e sostituirà il “fondo” dello stack.

Google non ha fornito molte informazioni su di esso. Questo è il meglio che ho potuto trovare:

(PDF di avviso) http://courses.cs.vt.edu/~cs2704/spring04/projects/DropOutStack.pdf

Ecco un codice per la piastra della caldaia, per iniziare. Ti consentirò di compilare il resto (controllo di integrità, conteggio, indicizzatore, ecc.)

 class DropOutStack { private T[] items; private int top = 0; public DropOutStack(int capacity) { items = new T[capacity]; } public void Push(T item) { items[top] = item; top = (top + 1) % items.Length; } public T Pop() { top = (items.Length + top - 1) % items.Length; return items[top]; } } 

In effetti stai guardando qualcosa di simile all’attuazione della lista circolare. Esiste un’implementazione di LimitedQueue eseguita da PIEBALDconsult su CodeProject. È simile al tuo requisito Hai solo bisogno di avvolgere Stack anziché Queue come fatto dall’autore. Inoltre l’autore ha anche implementato l’indicizzatore, che è utile se è necessario accedere a qualsiasi altra cosa diversa dallo stack in cima (per visualizzare magari l’elenco di annullamenti).

EDIT: l’implementazione dell’autore genera anche un evento quando l’ultimo (in primo luogo, dipende se si tratta di una coda o di uno stack) viene rimosso, in modo che tu possa sapere quando qualcosa viene gettato via.

Per chiunque altro, che ha trovato questa domanda mentre cercava di limitare le dimensioni degli stack di annullamento / ripetizione, ecco la soluzione migliore (utilizza LinkedList):

Limita le dimensioni di una raccolta generica

Non riesco a vedere un modo. È ansible ereditare dallo Stack , ma non sembra che ci sia nulla di utile da ignorare.

Il modo facile (anche se un po ‘noioso) sarebbe quello di avvolgere lo Stack nel proprio, ad esempio, LimitedStack . Quindi implementa i metodi che desideri e passa a uno Stack interno Stack , includendo la logica di limitazione nel metodo Push e in qualsiasi altro luogo ti serva.

È un dolore scrivere tutti quei membri pass-through, specialmente se stai implementando tutte le stesse interfacce di Stack … ma d’altra parte, devi solo farlo una volta e poi è fatto.

Credo che tu stia cercando un dequio (eventualmente modificato), la struttura dei dati che consente l’accesso da entrambe le estremità.