Queue Classe

Definizione

Spazio dei nomi:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Source:

Queue.cs

Rappresenta una raccolta di oggetti FIFO (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 e Queue come stampare i relativi 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 oggetto vengono inseriti alla fine e rimossi dall'altro.

Importante

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

Le code e gli stack sono utili quando è necessaria l'archiviazione temporanea per informazioni; vale a dire, quando si potrebbe voler eliminare un elemento dopo il recupero del relativo valore. Usare 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 oggetto e sui relativi elementi:

• Enqueue aggiunge un elemento alla fine di Queue.

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

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

La capacità di un Queue oggetto è il numero di elementi che può Queue contenere. Man mano che gli elementi vengono aggiunti a un Queueoggetto , 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 viene moltiplicata la capacità corrente quando è necessaria una capacità maggiore. Il fattore di crescita viene determinato quando viene costruito .Queue Il fattore di crescita predefinito è 2,0. La capacità dell'oggetto Queue aumenterà sempre di almeno un minimo di quattro, indipendentemente dal fattore di crescita. Ad esempio, un Queue oggetto con un fattore di crescita pari a 1,0 aumenterà sempre di quattro se è 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, che è vuota, ha la capacità iniziale predefinita e utilizza il fattore di crescita predefinito.
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.
Queue(Int32)	Inizializza una nuova istanza della classe Queue, che è vuota, ha la capacità iniziale specificata e utilizza il fattore di crescita predefinito.
Queue(Int32, Single)	Inizializza una nuova istanza della classe Queue, che è vuota, ha la capacità iniziale specificata e utilizza il fattore di crescita specificato.

Proprietà

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

Metodi

Clear()	Rimuove tutti gli oggetti da Queue.
Clone()	Crea una copia superficiale di Queue.
Contains(Object)	Determina se un elemento è incluso in Queue.
CopyTo(Array, Int32)	Copia gli elementi di Queue in un oggetto Array unidimensionale esistente, partendo dall'indice della matrice specificata.
Dequeue()	Consente di rimuovere e restituire l'oggetto all'inizio della Queue.
Enqueue(Object)	Aggiunge un oggetto alla fine di Queue.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetEnumerator()	Restituisce un enumeratore che esegue l'iterazione di Queue.
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()	Restituisce l'oggetto all'inizio della Queue senza rimuoverlo.
Synchronized(Queue)	Restituisce un nuovo oggetto Queue che esegue il wrapping della coda originale ed è thread-safe.
ToArray()	Copia gli elementi di 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 contenuti in Queue.

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.

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 Queue, tutte le operazioni devono essere eseguite tramite il wrapper restituito dal Synchronized(Queue) 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

• Queue<T>