Stack Stack Stack Stack Class

Definizione

Rappresenta una raccolta di oggetti semplice non generica LIFO (last-in-first-out).Represents a simple last-in-first-out (LIFO) non-generic collection of objects.

public ref class Stack : ICloneable, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Stack : ICloneable, System.Collections.ICollection
type Stack = class
    interface ICollection
    interface ICloneable
    interface IEnumerable
Public Class Stack
Implements ICloneable, ICollection
Ereditarietà
StackStackStackStack
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come creare e aggiungere i valori per un Stack e come visualizzare i relativi valori.The following example shows how to create and add values to a Stack and how to display its values.

using namespace System;
using namespace System::Collections;
void PrintValues( IEnumerable^ myCollection );
int main()
{
   
   // Creates and initializes a new Stack.
   Stack^ myStack = gcnew Stack;
   myStack->Push( "Hello" );
   myStack->Push( "World" );
   myStack->Push( "!" );
   
   // Displays the properties and values of the Stack.
   Console::WriteLine( "myStack" );
   Console::WriteLine( "\tCount:    {0}", myStack->Count );
   Console::Write( "\tValues:" );
   PrintValues( myStack );
}

void PrintValues( IEnumerable^ myCollection )
{
   IEnumerator^ myEnum = myCollection->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ obj = safe_cast<Object^>(myEnum->Current);
      Console::Write( "    {0}", obj );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 myStack
     Count:    3
     Values:    !    World    Hello
 */
using System;
using System.Collections;
public class SamplesStack  {

   public static void Main()  {

      // Creates and initializes a new Stack.
      Stack myStack = new Stack();
      myStack.Push("Hello");
      myStack.Push("World");
      myStack.Push("!");

      // Displays the properties and values of the Stack.
      Console.WriteLine( "myStack" );
      Console.WriteLine( "\tCount:    {0}", myStack.Count );
      Console.Write( "\tValues:" );
      PrintValues( myStack );
   }

   public static void PrintValues( IEnumerable myCollection )  {
      foreach ( Object obj in myCollection )
         Console.Write( "    {0}", obj );
      Console.WriteLine();
   }

}


/* 
This code produces the following output.

myStack
    Count:    3
    Values:    !    World    Hello
*/ 

Imports System
Imports System.Collections
Imports Microsoft.VisualBasic

Public Class SamplesStack    
    
    Public Shared Sub Main()
    
        ' Creates and initializes a new Stack.
        Dim myStack As New Stack()
        myStack.Push("Hello")
        myStack.Push("World")
        myStack.Push("!")
        
        ' Displays the properties and values of the Stack.
        Console.WriteLine("myStack")
        Console.WriteLine(ControlChars.Tab & "Count:    {0}", myStack.Count)
        Console.Write(ControlChars.Tab & "Values:")
        PrintValues(myStack)
    End Sub
    
    Public Shared Sub PrintValues(myCollection As IEnumerable)
        Dim obj As [Object]
        For Each obj In  myCollection
            Console.Write("    {0}", obj)
        Next obj
        Console.WriteLine()
    End Sub 'PrintValues

End Class

' This code produces the following output.
'
' myStack
'     Count:     3
'     Values:    !    World    Hello

Commenti

La capacità di un Stack è il numero di elementi di Stack può contenere.The capacity of a Stack is the number of elements the Stack can hold. Man mano che gli elementi vengono aggiunti a un Stack, automaticamente aumentato la capacità in base alle necessità tramite la riallocazione.As elements are added to a Stack, the capacity is automatically increased as required through reallocation.

Importante

Non è consigliabile usare il Stack classe per i nuovi sviluppi.We don't recommend that you use the Stack class for new development. È invece consigliabile usare il tipo generico System.Collections.Generic.Stack<T> classe.Instead, we recommend that you use the generic System.Collections.Generic.Stack<T> class. Per altre informazioni, vedere raccolte Non generiche non devono essere usate su GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Se Count è minore rispetto alla capacità dello stack, Push è un'operazione o (1).If Count is less than the capacity of the stack, Push is an O(1) operation. Se la capacità deve essere incrementata per far posto al nuovo elemento, Push diventa un'operazione O (n) operazione, in cui n è Count.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Pop è un'operazione o (1).Pop is an O(1) operation.

Stack accetta null come un valore valido e consente gli elementi duplicati.Stack accepts null as a valid value and allows duplicate elements.

Costruttori

Stack() Stack() Stack() Stack()

Inizializza una nuova istanza della classe Stack vuota e con capacità iniziale predefinita.Initializes a new instance of the Stack class that is empty and has the default initial capacity.

Stack(ICollection) Stack(ICollection) Stack(ICollection) Stack(ICollection)

Consente l'inizializzazione di una nuova istanza della classe Stack che contiene gli elementi copiati dall'insieme specificato e ha la capacità iniziale definita dal numero degli elementi copiati.Initializes a new instance of the Stack class that contains elements copied from the specified collection and has the same initial capacity as the number of elements copied.

Stack(Int32) Stack(Int32) Stack(Int32) Stack(Int32)

Consente l'inizializzazione di una nuova istanza della classe Stack, che è vuota e ha la capacità iniziale maggiore tra quella specificata e quella predefinita.Initializes a new instance of the Stack class that is empty and has the specified initial capacity or the default initial capacity, whichever is greater.

Proprietà

Count Count Count Count

Ottiene il numero di elementi contenuti in Stack.Gets the number of elements contained in the Stack.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Ottiene un valore che indica se l'accesso a Stack è sincronizzato (thread-safe).Gets a value indicating whether access to the Stack is synchronized (thread safe).

SyncRoot SyncRoot SyncRoot SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Stack.Gets an object that can be used to synchronize access to the Stack.

Metodi

Clear() Clear() Clear() Clear()

Rimuove tutti gli oggetti da Stack.Removes all objects from the Stack.

Clone() Clone() Clone() Clone()

Crea una copia superficiale di Stack.Creates a shallow copy of the Stack.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Determina se un elemento è incluso in Stack.Determines whether an element is in the Stack.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Consente di copiare lo Stack in una Array unidimensionale esistente, partendo dall'indice della matrice specificata.Copies the Stack to an existing one-dimensional Array, starting at the specified array index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Viene restituito un IEnumerator per l'oggetto Stack.Returns an IEnumerator for the Stack.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
Peek() Peek() Peek() Peek()

Viene restituito l'oggetto all'inizio dello Stack senza rimuoverlo.Returns the object at the top of the Stack without removing it.

Pop() Pop() Pop() Pop()

Rimuove e restituisce l'oggetto all'inizio dello Stack.Removes and returns the object at the top of the Stack.

Push(Object) Push(Object) Push(Object) Push(Object)

Inserisce un oggetto all'inizio dello Stack.Inserts an object at the top of the Stack.

Synchronized(Stack) Synchronized(Stack) Synchronized(Stack) Synchronized(Stack)

Restituisce un wrapper sincronizzato (thread-safe) per la classe Stack.Returns a synchronized (thread safe) wrapper for the Stack.

ToArray() ToArray() ToArray() ToArray()

Consente di copiare lo Stack in una nuova matrice.Copies the Stack to a new array.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte un' IEnumerable a un IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a

Thread safety

Statici pubblici (Shared in Visual Basic) membri di questo tipo sono thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. I membri di istanza non sono garantiti come thread-safe.Any instance members are not guaranteed to be thread safe.

Per garantire la sicurezza dei thread dei Stack, tutte le operazioni devono essere eseguite tramite il wrapper restituito dal Synchronized(Stack) (metodo).To guarantee the thread safety of the Stack, all operations must be done through the wrapper returned by the Synchronized(Stack) method.

L'enumerazione di una raccolta non è di per sé una procedura thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Per garantire la protezione dei thread durante l'enumerazione, è possibile bloccare la raccolta per l'intera enumerazione oppure intercettare le eccezioni determinate dalle modifiche apportate da altri thread.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Vedi anche