Queue Classe

Définition

Espace de noms:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Source:

Queue.cs

Représente une collection d’objets premier entré, premier sorti.

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

Héritage

Object

Queue

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.

Important

Nous vous déconseillons d’utiliser la classe pour le Queue nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la classe générique Queue<T> . Pour plus d’informations, consultez Collections non génériques ne doivent pas être utilisées sur GitHub.

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

Queue()	Initialise une nouvelle instance de la classe Queue qui est vide, possède la capacité initiale par défaut et utilise le facteur de croissance par défaut.
Queue(ICollection)	Initialise une nouvelle instance de la classe Queue qui contient des éléments copiés à partir de la collection spécifiée, possède la capacité initiale correspondant au nombre d'éléments copiés et utilise le facteur de croissance par défaut.
Queue(Int32)	Initialise une nouvelle instance de la classe Queue qui est vide, possède la capacité initiale spécifiée et utilise le facteur de croissance par défaut.
Queue(Int32, Single)	Initialise une nouvelle instance de la classe Queue qui est vide, possède la capacité initiale spécifiée et utilise le facteur de croissance spécifié.

Propriétés

Count	Obtient le nombre d’éléments contenus dans le Queue.
IsSynchronized	Obtient une valeur indiquant si l’accès à Queue est synchronisé (thread-safe).
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès à Queue.

Méthodes

Clear()	Supprime tous les objets du Queue.
Clone()	Crée une copie superficielle de Queue.
Contains(Object)	Détermine si le Queue contient un élément.
CopyTo(Array, Int32)	Copie les éléments Queue dans un Array unidimensionnel existant, en commençant au niveau de l'index de tableau spécifié.
Dequeue()	Supprime et renvoie l'objet au début de la Queue.
Enqueue(Object)	Ajoute un objet à la fin de la Queue.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetEnumerator()	Retourne un énumérateur qui itère au sein de Queue.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Peek()	Renvoie l'objet situé au début de la Queue sans le supprimer.
Synchronized(Queue)	Retourne un nouvel objet Queue thread-safe encapsulant la file d'attente d'origine.
ToArray()	Copie les éléments Queue vers un nouveau tableau.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
TrimToSize()	Définit la capacité au nombre réel d'éléments dans Queue.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

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>