Queue Classe

Definizione

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

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

public class Queue : System.Collections.ICollection

public class Queue : ICloneable, System.Collections.ICollection

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

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

type Queue = class
    interface ICollection
    interface IEnumerable

type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

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

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

Public Class Queue
Implements ICollection

Public Class Queue
Implements ICloneable, ICollection

Ereditarietà

Object

Queue

Attributi

SerializableAttribute ComVisibleAttribute

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.

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

Proprietà

Metodi

Metodi di estensione

Si applica a

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>