Stack Classe

Riferimento

Definizione

Spazio dei nomi:: System.Collections

Assembly:: mscorlib.dll, System.Collections.NonGeneric.dll

Assembly:: System.Collections.NonGeneric.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Rappresenta una raccolta di oggetti non generica di tipo LIFO (Last-In First-Out).

public ref class Stack : System::Collections::ICollection

public ref class Stack : ICloneable, System::Collections::ICollection

public class Stack : System.Collections.ICollection

public class Stack : ICloneable, System.Collections.ICollection

[System.Serializable]
public class Stack : ICloneable, System.Collections.ICollection

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class Stack : ICloneable, System.Collections.ICollection

type Stack = class
    interface ICollection
    interface IEnumerable

type Stack = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
type Stack = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Stack = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Stack = class
    interface ICollection
    interface ICloneable
    interface IEnumerable

Public Class Stack
Implements ICollection

Public Class Stack
Implements ICloneable, ICollection

Ereditarietà: Object
Stack

Attributi: SerializableAttribute ComVisibleAttribute

Implementazioni: ICollection IEnumerable ICloneable

Esempio

Nell'esempio seguente viene illustrato come creare e aggiungere valori a stack e come visualizzarne i valori.

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.Collections

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

End Class

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

Commenti

La capacità di un Stack oggetto è il numero di elementi che può Stack contenere. Man mano che gli elementi vengono aggiunti a un Stackoggetto , la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione.

Importante

Non è consigliabile usare la classe per il Stack nuovo sviluppo. È invece consigliabile usare la classe generica System.Collections.Generic.Stack<T> . Per altre informazioni, vedere Raccolte non generiche che non devono essere usate in GitHub.

Se Count è minore della capacità dello stack, Push è un'operazione O(1) . Se la capacità deve essere aumentata per contenere il nuovo elemento, Push diventa un'operazione O(n) , dove n è Count. Pop è un'operazione O(1) .

Stack accetta null come valore valido e consente elementi duplicati.

Costruttori

Stack()	Inizializza una nuova istanza della classe Stack vuota e con capacità iniziale predefinita.
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.
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.

Proprietà

Count	Ottiene il numero di elementi contenuti in Stack.
IsSynchronized	Ottiene un valore che indica se l'accesso a Stack è sincronizzato (thread-safe).
SyncRoot	Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Stack.

Metodi

Clear()	Rimuove tutti gli oggetti da Stack.
Clone()	Crea una copia superficiale di Stack.
Contains(Object)	Determina se un elemento è incluso in Stack.
CopyTo(Array, Int32)	Copia Stack in una Array unidimensionale esistente, iniziando dall'indice di matrice specificato.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetEnumerator()	Restituisce IEnumerator per Stack.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Peek()	Viene restituito l'oggetto all'inizio dello Stack senza rimuoverlo.
Pop()	Rimuove e restituisce l'oggetto all'inizio dell'oggetto Stack.
Push(Object)	Inserisce un oggetto all'inizio della classe Stack.
Synchronized(Stack)	Restituisce un wrapper sincronizzato (thread-safe) per la classe Stack.
ToArray()	Consente di copiare lo Stack in una nuova matrice.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Metodi di estensione

Cast<TResult>(IEnumerable)	Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.
OfType<TResult>(IEnumerable)	Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)	Consente la parallelizzazione di una query.
AsQueryable(IEnumerable)	Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Thread safety

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe. Non è invece garantita la sicurezza dei membri dell'istanza.

Per garantire la thread safety di Stack, tutte le operazioni devono essere eseguite tramite il wrapper restituito dal Synchronized(Stack) metodo .

L'enumerazione di una raccolta non è di per sé una procedura thread-safe. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. 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.

Vedi anche

Stack<T>