Queue Classe

Definizione

Spazio dei nomi:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Origine:

Queue.cs

Rappresenta una raccolta di oggetti first-in first-out.

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

public class Queue : ICloneable, System.Collections.ICollection

type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

Public Class Queue
Implements ICloneable, ICollection

Ereditarietà

Object

Queue

Implementazioni

ICollection IEnumerable ICloneable

Esempio

Nell'esempio seguente viene illustrato come creare e aggiungere valori a un Queue e come stamparne i valori.

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. Gli oggetti archiviati in un Queue vengono inseriti in un'estremità e rimossi dall'altro.

Importante

Non è consigliabile usare la classe Queue per il nuovo sviluppo. È invece consigliabile usare la classe generica Queue<T>. Per altre informazioni, vedere raccolte non generiche non devono essere usate in GitHub.

Le code e gli stack sono utili quando è necessaria l'archiviazione temporanea per informazioni; ovvero, quando si potrebbe voler rimuovere un elemento dopo il recupero del relativo valore. Utilizzare Queue se è necessario accedere alle informazioni nello stesso ordine in cui sono archiviate nella raccolta. Usare Stack se è necessario accedere alle informazioni in ordine inverso. Usare ConcurrentQueue<T> o ConcurrentStack<T> se è necessario accedere alla raccolta da più thread contemporaneamente.

È possibile eseguire tre operazioni principali su un Queue e sui relativi elementi:

• Enqueue aggiunge un elemento alla fine del Queue.

• Dequeue rimuove l'elemento meno recente dall'inizio del Queue.

• Peek restituisce l'elemento meno recente che si trova all'inizio del Queue, ma non lo rimuove dal Queue.

La capacità di un Queue è il numero di elementi che il Queue può contenere. Man mano che gli elementi vengono aggiunti a un Queue, la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione. La capacità può essere ridotta chiamando TrimToSize.

Il fattore di crescita è il numero in base al quale la capacità corrente viene moltiplicata quando è necessaria una capacità maggiore. Il fattore di crescita viene determinato quando viene costruito il Queue. Il fattore di crescita predefinito è 2,0. La capacità del Queue aumenterà sempre di almeno quattro, indipendentemente dal fattore di crescita. Ad esempio, un Queue con un fattore di crescita pari a 1,0 aumenterà sempre di quattro quando è necessaria una capacità maggiore.

Queue accetta null come valore valido e consente elementi duplicati.

Per la versione generica di questa raccolta, vedere System.Collections.Generic.Queue<T>

Costruttori

Queue()	Inizializza una nuova istanza della classe Queue vuota, ha la capacità iniziale predefinita e usa il fattore di crescita predefinito.
Queue(ICollection)	Inizializza una nuova istanza della classe Queue che contiene elementi copiati dalla raccolta specificata, ha la stessa capacità iniziale del numero di elementi copiati e usa il fattore di crescita predefinito.
Queue(Int32, Single)	Inizializza una nuova istanza della classe Queue vuota, ha la capacità iniziale specificata e usa il fattore di crescita specificato.
Queue(Int32)	Inizializza una nuova istanza della classe Queue vuota, ha la capacità iniziale specificata e usa il fattore di crescita predefinito.

Proprietà

Count	Ottiene il numero di elementi contenuti nella Queue.
IsSynchronized	Ottiene un valore che indica se l'accesso al Queue è sincronizzato (thread-safe).
SyncRoot	Ottiene un oggetto che può essere utilizzato per sincronizzare l'accesso al Queue.

Metodi

Clear()	Rimuove tutti gli oggetti dalla Queue.
Clone()	Crea una copia superficiale del Queue.
Contains(Object)	Determina se un elemento si trova nel Queue.
CopyTo(Array, Int32)	Copia gli elementi Queue in un Arrayunidimensionale esistente, a partire dall'indice di matrice specificato.
Dequeue()	Rimuove e restituisce l'oggetto all'inizio del Queue.
Enqueue(Object)	Aggiunge un oggetto alla fine del Queue.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetEnumerator()	Restituisce un enumeratore che scorre il Queue.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
Peek()	Restituisce l'oggetto all'inizio del Queue senza rimuoverlo.
Synchronized(Queue)	Restituisce un nuovo Queue che esegue il wrapping della coda originale ed è thread-safe.
ToArray()	Copia gli elementi Queue in una nuova matrice.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TrimToSize()	Imposta la capacità sul numero effettivo di elementi nella Queue.

Metodi di estensione

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

Thread safety

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe. Non è garantito che tutti i membri dell'istanza siano thread-safe.

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

L'enumerazione tramite una raccolta non è intrinsecamente una procedura thread-safe. Anche quando una raccolta viene sincronizzata, altri thread possono comunque modificare la raccolta, causando la generazione di un'eccezione da parte dell'enumeratore. Per garantire la thread safety durante l'enumerazione, è possibile bloccare la raccolta durante l'intera enumerazione o intercettare le eccezioni risultanti dalle modifiche apportate da altri thread.

Vedi anche

• Queue<T>