Queue Classe

Definizione

Rappresenta una raccolta di oggetti FIFO (First-In First-Out).Represents a first-in, first-out collection of objects.

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

Esempi

Nell'esempio seguente viene illustrato come creare e aggiungere valori a un Queue e come stamparne i valori.The following example shows how to create and add values to a Queue and how to print out its values.

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

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.
 
 myQ
     Count:    3
     Values:    Hello    World    !
*/
 using System;
 using System.Collections;
 public class SamplesQueue  {
 
    public static void Main()  {
 
       // Creates and initializes a new Queue.
       Queue myQ = new Queue();
       myQ.Enqueue("Hello");
       myQ.Enqueue("World");
       myQ.Enqueue("!");
 
       // Displays the properties and values of the Queue.
       Console.WriteLine( "myQ" );
       Console.WriteLine( "\tCount:    {0}", myQ.Count );
       Console.Write( "\tValues:" );
       PrintValues( myQ );
    }
 
 
    public static void PrintValues( IEnumerable myCollection )  {
       foreach ( Object obj in myCollection )
          Console.Write( "    {0}", obj );
       Console.WriteLine();
    }
 }
 /* 
 This code produces the following output.
 
 myQ
     Count:    3
     Values:    Hello    World    !
*/ 
Imports System.Collections

Public Class SamplesQueue

    Public Shared Sub Main()

        ' Creates and initializes a new Queue.
        Dim myQ As New Queue()
        myQ.Enqueue("Hello")
        myQ.Enqueue("World")
        myQ.Enqueue("!")

        ' Displays the properties and values of the Queue.
        Console.WriteLine("myQ")
        Console.WriteLine("    Count:    {0}", myQ.Count)
        Console.Write("    Values:")
        PrintValues(myQ)

    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.
' 
' myQ
'     Count:    3
'     Values:    Hello    World    !

Commenti

Questa classe implementa una coda come matrice circolare.This class implements a queue as a circular array. Gli oggetti archiviati in un Queue vengono inseriti in un'unica estremità e rimossi dall'altro.Objects stored in a Queue are inserted at one end and removed from the other.

Importante

Non è consigliabile usare la classe Queue per il nuovo sviluppo.We don't recommend that you use the Queue class for new development. È invece consigliabile usare la classe generica Queue<T>.Instead, we recommend that you use the generic Queue<T> class. Per altre informazioni, vedere le raccolte non generiche non devono essere usate in GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Le code e gli stack sono utili quando è necessaria l'archiviazione temporanea per informazioni. ovvero, quando potrebbe essere necessario rimuovere un elemento dopo il recupero del relativo valore.Queues and stacks are useful when you need temporary storage for information; that is, when you might want to discard an element after retrieving its value. Utilizzare Queue se è necessario accedere alle informazioni nello stesso ordine in cui sono archiviate nella raccolta.Use Queue if you need to access the information in the same order that it is stored in the collection. Utilizzare Stack se è necessario accedere alle informazioni in ordine inverso.Use Stack if you need to access the information in reverse order. Utilizzare ConcurrentQueue<T> o ConcurrentStack<T> se è necessario accedere alla raccolta da più thread contemporaneamente.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

È possibile eseguire tre operazioni principali su un Queue e sui relativi elementi:Three main operations can be performed on a Queue and its elements:

  • Enqueue aggiunge un elemento alla fine del Queue.Enqueue adds an element to the end of the Queue.

  • Dequeue rimuove l'elemento meno recente dall'inizio del Queue.Dequeue removes the oldest element from the start of the Queue.

  • Peek restituisce l'elemento meno recente che si trova all'inizio del Queue, ma non lo rimuove dalla Queue.Peek returns the oldest element that is at the start of the Queue but does not remove it from the Queue.

La capacità di un Queue è il numero di elementi che può essere tenuto da Queue.The capacity of a Queue is the number of elements the Queue can hold. Quando gli elementi vengono aggiunti a un Queue, la capacità viene aumentata automaticamente secondo necessità tramite la riallocazione.As elements are added to a Queue, the capacity is automatically increased as required through reallocation. La capacità può essere ridotta chiamando TrimToSize.The capacity can be decreased by calling TrimToSize.

Il fattore di crescita è il numero in base al quale la capacità corrente viene moltiplicata quando è necessaria una capacità maggiore.The growth factor is the number by which the current capacity is multiplied when a greater capacity is required. Il fattore di crescita viene determinato quando viene costruito Queue.The growth factor is determined when the Queue is constructed. Il fattore di crescita predefinito è 2,0.The default growth factor is 2.0. La capacità dell'Queue aumenterà sempre di almeno un minimo di quattro, indipendentemente dal fattore di crescita.The capacity of the Queue will always increase by at least a minimum of four, regardless of the growth factor. Ad esempio, un Queue con un fattore di crescita di 1,0 aumenterà sempre la capacità di quattro quando sarà necessaria una capacità maggiore.For example, a Queue with a growth factor of 1.0 will always increase in capacity by four when a greater capacity is required.

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

Per la versione generica di questa raccolta, vedere System.Collections.Generic.Queue<T>For the generic version of this collection, see System.Collections.Generic.Queue<T>

Costruttori

Queue()

Inizializza una nuova istanza della classe Queue, che è vuota, ha la capacità iniziale predefinita e utilizza il fattore di crescita predefinito.Initializes a new instance of the Queue class that is empty, has the default initial capacity, and uses the default growth factor.

Queue(ICollection)

Inizializza una nuova istanza della classe Queue che contiene gli elementi copiati dall'insieme specificato, dispone della capacità iniziale definita dal numero degli elementi copiati e utilizza il fattore di crescita predefinito.Initializes a new instance of the Queue class that contains elements copied from the specified collection, has the same initial capacity as the number of elements copied, and uses the default growth factor.

Queue(Int32)

Inizializza una nuova istanza della classe Queue, che è vuota, ha la capacità iniziale specificata e utilizza il fattore di crescita predefinito.Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the default growth factor.

Queue(Int32, Single)

Inizializza una nuova istanza della classe Queue, che è vuota, ha la capacità iniziale specificata e utilizza il fattore di crescita specificato.Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the specified growth factor.

Proprietà

Count

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

IsSynchronized

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

SyncRoot

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

Metodi

Clear()

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

Clone()

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

Contains(Object)

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

CopyTo(Array, Int32)

Copia gli elementi di Queue in un oggetto Array unidimensionale esistente, partendo dall'indice della matrice specificata.Copies the Queue elements to an existing one-dimensional Array, starting at the specified array index.

Dequeue()

Consente di rimuovere e restituire l'oggetto all'inizio della Queue.Removes and returns the object at the beginning of the Queue.

Enqueue(Object)

Aggiunge un oggetto alla fine di Queue.Adds an object to the end of the Queue.

Equals(Object)

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

(Ereditato da Object)
GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione di Queue.Returns an enumerator that iterates through the Queue.

GetHashCode()

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

(Ereditato da Object)
GetType()

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

(Ereditato da Object)
MemberwiseClone()

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

(Ereditato da Object)
Peek()

Restituisce l'oggetto all'inizio della Queue senza rimuoverlo.Returns the object at the beginning of the Queue without removing it.

Synchronized(Queue)

Restituisce un nuovo oggetto Queue che esegue il wrapping della coda originale ed è thread-safe.Returns a new Queue that wraps the original queue, and is thread safe.

ToArray()

Copia gli elementi di Queue in una nuova matrice.Copies the Queue elements to a new array.

ToString()

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

(Ereditato da Object)
TrimToSize()

Imposta la capacità sul numero effettivo di elementi contenuti in Queue.Sets the capacity to the actual number of elements in the Queue.

Metodi di estensione

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)

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)

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

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a

Thread safety

I membri statici pubblici (Shared in Visual Basic) 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 thread safety di Queue, tutte le operazioni devono essere eseguite tramite il wrapper restituito dal metodo Synchronized(Queue).To guarantee the thread safety of the Queue, all operations must be done through the wrapper returned by the Synchronized(Queue) 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