Queue Queue Queue Queue Class

Definição

Representa uma coleção primeiro a entrar, primeiro a sair de objetos.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
Herança
QueueQueueQueueQueue
Atributos
Implementações

Exemplos

O exemplo a seguir mostra como criar e adicionar valores para um Queue e como imprimir seus valores.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    !

Comentários

Essa classe implementa uma fila como uma matriz de circular.This class implements a queue as a circular array. Objetos armazenados em um Queue são inseridas em uma extremidade e removido da outra.Objects stored in a Queue are inserted at one end and removed from the other.

Importante

Não é recomendável que você use o Queue classe para novo desenvolvimento.We don't recommend that you use the Queue class for new development. Em vez disso, é recomendável que você use o genérico Queue<T> classe.Instead, we recommend that you use the generic Queue<T> class. Para obter mais informações, consulte coleções não genéricas não devem ser usadas no GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Pilhas e filas são úteis quando você precisar de armazenamento temporário para obter informações; ou seja, quando você talvez queira descartar um elemento após recuperar seu valor.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. Use Queue se você precisar acessar as informações na mesma ordem em que ele é armazenado na coleção.Use Queue if you need to access the information in the same order that it is stored in the collection. Use Stack se você precisar acessar as informações na ordem inversa.Use Stack if you need to access the information in reverse order. Use ConcurrentQueue<T> ou ConcurrentStack<T> se você precisar acessar a coleção de vários threads simultaneamente.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

Três operações principais podem ser executadas em um Queue e seus elementos:Three main operations can be performed on a Queue and its elements:

  • Enqueue Adiciona um elemento ao final do Queue.Enqueue adds an element to the end of the Queue.

  • Dequeue Remove o elemento mais antigo do início do Queue.Dequeue removes the oldest element from the start of the Queue.

  • Peek Retorna o elemento mais antigo que está no início do Queue , mas não o remove do Queue.Peek returns the oldest element that is at the start of the Queue but does not remove it from the Queue.

A capacidade de um Queue é o número de elementos a Queue pode conter.The capacity of a Queue is the number of elements the Queue can hold. Como os elementos são adicionados a um Queue, a capacidade é aumentada automaticamente conforme necessário por meio de realocação.As elements are added to a Queue, the capacity is automatically increased as required through reallocation. A capacidade pode ser diminuída chamando TrimToSize.The capacity can be decreased by calling TrimToSize.

O fator de crescimento é o número pelo qual a capacidade atual é multiplicada quando uma capacidade maior é necessária.The growth factor is the number by which the current capacity is multiplied when a greater capacity is required. O fator de crescimento é determinado quando o Queue é construído.The growth factor is determined when the Queue is constructed. O fator de crescimento padrão é 2.0.The default growth factor is 2.0. A capacidade do Queue sempre terão um aumento de um mínimo de quatro, independentemente do fator de crescimento.The capacity of the Queue will always increase by at least a minimum of four, regardless of the growth factor. Por exemplo, um Queue com um fator de crescimento do 1.0 sempre aumentará em capacidade por quatro quando uma capacidade maior é necessária.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 aceita null como um valor válido e permite elementos duplicados.Queue accepts null as a valid value and allows duplicate elements.

Para obter a versão genérica dessa coleção, consulte System.Collections.Generic.Queue<T>For the generic version of this collection, see System.Collections.Generic.Queue<T>

Construtores

Queue() Queue() Queue() Queue()

Inicializa uma nova instância da classe Queue que está vazia, tem a capacidade inicial padrão e usa o fator de crescimento padrão.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)

Inicializa uma nova instância da classe Queue que contém os elementos copiados da coleção especificada, tem a mesma capacidade inicial que o número de elementos copiados e usa o fator de crescimento padrão.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)

Inicializa uma nova instância da classe Queue que está vazia, tem a capacidade inicial especificada e usa o fator de crescimento padrão.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)

Inicializa uma nova instância da classe Queue que está vazia, tem a capacidade inicial especificada e usa o fator de crescimento especificado.Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the specified growth factor.

Propriedades

Count Count Count Count

Obtém o número de elementos contidos no Queue.Gets the number of elements contained in the Queue.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtém um valor que indica se o acesso à Queue é sincronizado (thread-safe).Gets a value indicating whether access to the Queue is synchronized (thread safe).

SyncRoot SyncRoot SyncRoot SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao Queue.Gets an object that can be used to synchronize access to the Queue.

Métodos

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

Remove todos os objetos da Queue.Removes all objects from the Queue.

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

Cria uma cópia superficial do Queue.Creates a shallow copy of the Queue.

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

Determina se um elemento está no Queue.Determines whether an element is in the Queue.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copia os elementos Queue em um Array unidimensional existente, começando no índice da matriz especificado.Copies the Queue elements to an existing one-dimensional Array, starting at the specified array index.

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

Remove e retorna o objeto no início do Queue.Removes and returns the object at the beginning of the Queue.

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

Adiciona um objeto ao final do Queue.Adds an object to the end of the Queue.

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Retorna um enumerador que itera por meio de Queue.Returns an enumerator that iterates through the Queue.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Retorna o objeto ao início da Queue sem removê-lo.Returns the object at the beginning of the Queue without removing it.

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

Retorna um novo Queue que encapsula a fila original e é thread-safe.Returns a new Queue that wraps the original queue, and is thread safe.

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

Copia os elementos do Queue em uma nova matriz.Copies the Queue elements to a new array.

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

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

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

Define a capacidade para o número real de elementos em Queue.Sets the capacity to the actual number of elements in the Queue.

Extension Methods

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

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

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

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

Habilita a paralelização de uma consulta.Enables parallelization of a query.

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

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Aplica-se a

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Não há garantia de que qualquer membro de instância seja thread-safe.Any instance members are not guaranteed to be thread safe.

Para garantir a segurança do thread do Queue, todas as operações devem ser feitas por meio de wrapper retornado pelo Synchronized(Queue) método.To guarantee the thread safety of the Queue, all operations must be done through the wrapper returned by the Synchronized(Queue) method.

A enumeração por meio de uma coleção não é um procedimento thread-safe intrínseco.Enumerating through a collection is intrinsically not a thread-safe procedure. Mesmo quando uma coleção está sincronizada, outros threads ainda podem modificar a coleção, o que faz o enumerador lançar uma exceção.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Para garantir thread-safe durante a enumeração, é possível bloquear a coleção durante toda a enumeração ou verificar as exceções resultantes das alterações feitas por outros 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.

Veja também