Queue Queue Queue Queue Class

Définition

Représente une collection d'objets premier entré, premier sorti.Represents a first-in, first-out collection of objects.

public ref class Queue : ICloneable, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Queue : ICloneable, System.Collections.ICollection
type Queue = class
    interface ICollection
    interface ICloneable
    interface IEnumerable
Public Class Queue
Implements ICloneable, ICollection
Héritage
QueueQueueQueueQueue
Attributs
Implémente

Exemples

L’exemple suivant montre comment créer et ajouter des valeurs pour un Queue et comment imprimer ses valeurs.The following example shows how to create and add values to a Queue and how to print out its values.

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
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 'Main

    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 'PrintValues

End Class 'SamplesQueue


' 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.This class implements a queue as a circular array. Objets stockés dans un Queue sont insérés à une extrémité et supprimés à l’autre.Objects stored in a Queue are inserted at one end and removed from the other.

Important

Nous ne vous recommandons d’utiliser la Queue classe pour tout nouveau développement.We don't recommend that you use the Queue class for new development. Au lieu de cela, nous vous recommandons d’utiliser le modèle générique Queue<T> classe.Instead, we recommend that you use the generic Queue<T> class. Pour plus d’informations, consultez les collections Non génériques ne doit pas être utilisées sur GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Les piles et les files d’attente sont utiles lorsque vous avez besoin de stockage temporaire des informations ; Autrement dit, lorsque vous souhaitez ignorer un élément après avoir récupéré sa valeur.Queues and stacks are useful when you need temporary storage for information; that is, when you might want to discard an element after retrieving its value. Utilisez Queue si vous avez besoin accéder aux informations dans le même ordre que celui qu’elles sont stockées dans la collection.Use Queue if you need to access the information in the same order that it is stored in the collection. Utilisez Stack si vous avez besoin accéder aux informations dans l’ordre inverse.Use Stack if you need to access the information in reverse order. Utilisez ConcurrentQueue<T> ou ConcurrentStack<T> si vous avez besoin pour accéder à la collection à partir de plusieurs threads simultanément.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

Trois opérations principales peuvent être effectuées sur un Queue et ses éléments :Three main operations can be performed on a Queue and its elements:

  • Enqueue Ajoute un élément à la fin de la Queue.Enqueue adds an element to the end of the Queue.

  • Dequeue Supprime l’élément le plus ancien à partir du début de la Queue.Dequeue removes the oldest element from the start of the Queue.

  • Peek Retourne l’élément le plus ancien qui se trouve au début de la Queue mais ne supprime ne pas de la Queue.Peek returns the oldest element that is at the start of the Queue but does not remove it from the Queue.

La capacité d’un Queue est le nombre d’éléments du Queue peut contenir.The capacity of a Queue is the number of elements the Queue can hold. Comme les éléments sont ajoutés à un Queue, la capacité est automatiquement augmentée par réallocation.As elements are added to a Queue, the capacity is automatically increased as required through reallocation. La capacité peut être diminuée en appelant TrimToSize.The capacity can be decreased by calling TrimToSize.

Le facteur de croissance est le nombre par lequel la capacité actuelle est multipliée lorsqu’une capacité supérieure est requise.The growth factor is the number by which the current capacity is multiplied when a greater capacity is required. Le facteur de croissance est déterminé lorsque le Queue est construit.The growth factor is determined when the Queue is constructed. Le facteur de croissance par défaut est 2.0.The default growth factor is 2.0. La capacité de la Queue augmentera toujours d’au moins un minimum de quatre, quel que soit le facteur de croissance.The capacity of the Queue will always increase by at least a minimum of four, regardless of the growth factor. Par exemple, un Queue avec un facteur de croissance de 1.0 augmentera toujours de capacité par quatre lorsqu’une capacité supérieure est requise.For example, a Queue with a growth factor of 1.0 will always increase in capacity by four when a greater capacity is required.

Queue accepte null comme une valeur valide et autorise les éléments en double.Queue accepts null as a valid value and allows duplicate elements.

Pour la version générique de cette collection, consultez System.Collections.Generic.Queue<T>For the generic version of this collection, see System.Collections.Generic.Queue<T>

Constructeurs

Queue() Queue() Queue() 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.Initializes a new instance of the Queue class that is empty, has the default initial capacity, and uses the default growth factor.

Queue(ICollection) Queue(ICollection) Queue(ICollection) 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.Initializes a new instance of the Queue class that contains elements copied from the specified collection, has the same initial capacity as the number of elements copied, and uses the default growth factor.

Queue(Int32) Queue(Int32) Queue(Int32) 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.Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the default growth factor.

Queue(Int32, Single) Queue(Int32, Single) Queue(Int32, Single) 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é.Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the specified growth factor.

Propriétés

Count Count Count Count

Obtient le nombre d'éléments contenus dans le Queue.Gets the number of elements contained in the Queue.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtient une valeur indiquant si l'accès à Queue est synchronisé (thread-safe).Gets a value indicating whether access to the Queue is synchronized (thread safe).

SyncRoot SyncRoot SyncRoot SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à Queue.Gets an object that can be used to synchronize access to the Queue.

Méthodes

Clear() Clear() Clear() Clear()

Supprime tous les objets du Queue.Removes all objects from the Queue.

Clone() Clone() Clone() Clone()

Crée une copie superficielle de Queue.Creates a shallow copy of the Queue.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Détermine si le Queue contient un élément.Determines whether an element is in the Queue.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) 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é.Copies the Queue elements to an existing one-dimensional Array, starting at the specified array index.

Dequeue() Dequeue() Dequeue() Dequeue()

Supprime et retourne l'objet au début de Queue.Removes and returns the object at the beginning of the Queue.

Enqueue(Object) Enqueue(Object) Enqueue(Object) Enqueue(Object)

Ajoute un objet à la fin de la Queue.Adds an object to the end of the Queue.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Retourne un énumérateur qui itère au sein de Queue.Returns an enumerator that iterates through the Queue.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Peek() Peek() Peek() Peek()

Retourne l'objet situé au début de Queue sans le supprimer.Returns the object at the beginning of the Queue without removing it.

Synchronized(Queue) Synchronized(Queue) Synchronized(Queue) Synchronized(Queue)

Retourne un nouvel objet Queue thread-safe encapsulant la file d'attente d'origine.Returns a new Queue that wraps the original queue, and is thread safe.

ToArray() ToArray() ToArray() ToArray()

Copie les éléments Queue vers un nouveau tableau.Copies the Queue elements to a new array.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
TrimToSize() TrimToSize() TrimToSize() TrimToSize()

Définit la capacité au nombre réel d'éléments dans Queue.Sets the capacity to the actual number of elements in the Queue.

Méthodes d’extension

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convertit un IEnumerable à un IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Cohérence de thread

Statique public (Shared en Visual Basic) de ce type sont thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Il n'est pas garanti que les membres d'instance soient thread-safe.Any instance members are not guaranteed to be thread safe.

Pour garantir la sécurité des threads de la Queue, toutes les opérations doivent être effectuées via le wrapper retourné par la Synchronized(Queue) (méthode).To guarantee the thread safety of the Queue, all operations must be done through the wrapper returned by the Synchronized(Queue) method.

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. 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.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Voir aussi