Queue Classe

Définition

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

Héritage

Object

Queue

Attributs

SerializableAttribute ComVisibleAttribute

Implémente

ICollection IEnumerable ICloneable

Exemples

L’exemple suivant montre comment créer et ajouter des valeurs à un Queue et comment imprimer ses valeurs.

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    !

Remarques

Cette classe implémente une file d’attente sous forme de tableau circulaire. Les objets stockés dans un Queue sont insérés à une extrémité et supprimés de l’autre.

Les files d’attente et les piles sont utiles lorsque vous avez besoin d’un stockage temporaire pour les informations ; autrement dit, lorsque vous souhaiterez peut-être ignorer un élément après avoir récupéré sa valeur. Utilisez Queue si vous avez besoin d’accéder aux informations dans le même ordre qu’elles sont stockées dans la collection. Utilisez Stack si vous devez accéder aux informations dans l’ordre inverse. Utilisez ConcurrentQueue<T> ou ConcurrentStack<T> si vous devez accéder simultanément à la collection à partir de plusieurs threads.

Trois opérations main peuvent être effectuées sur un Queue et ses éléments :

• Enqueueajoute un élément à la fin de .Queue

• Dequeuesupprime l’élément le plus ancien du début de .Queue

• Peekretourne l’élément le plus ancien qui se trouve au début du Queue , mais ne le supprime pas de .Queue

La capacité d’un Queue est le nombre d’éléments que peut Queue contenir. À mesure que des éléments sont ajoutés à un Queue, la capacité est automatiquement augmentée en fonction des besoins par le biais de la réaffectation. La capacité peut être réduite en appelant TrimToSize.

Le facteur de croissance est le nombre par lequel la capacité actuelle est multipliée lorsqu’une capacité supérieure est nécessaire. Le facteur de croissance est déterminé lorsque le Queue est construit. Le facteur de croissance par défaut est 2.0. La capacité du Queue augmente toujours d’au moins quatre, quel que soit le facteur de croissance. Par exemple, un Queue avec un facteur de croissance de 1,0 augmente toujours sa capacité de quatre quand une capacité supérieure est nécessaire.

Queue accepte null comme valeur valide et autorise les éléments en double.

Pour obtenir la version générique de cette collection, consultez System.Collections.Generic.Queue<T>

Constructeurs

Propriétés

Méthodes

Méthodes d’extension

S’applique à

Cohérence de thread

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Pour garantir la sécurité du thread de , Queuetoutes les opérations doivent être effectuées via le wrapper retourné par la Synchronized(Queue) méthode .

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres threads.

Voir aussi

• Queue<T>