Queue Classe

Definição

Namespace:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Origem:

Queue.cs

Representa uma coleção primeiro a entrar, primeiro a sair de objetos.

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

Herança

Object

Queue

Implementações

ICollection IEnumerable ICloneable

Exemplos

O exemplo a seguir mostra como criar e adicionar valores a um Queue e como imprimir seus valores.

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    !

Comentários

Essa classe implementa uma fila como uma matriz circular. Os objetos armazenados em um Queue são inseridos em uma extremidade e removidos do outro.

Importante

Não recomendamos que você use a Queue classe para desenvolvimento novo. Em vez disso, recomendamos que você use a classe genérica Queue<T> . Para obter mais informações, consulte Coleções não genéricas não devem ser usadas no GitHub.

Filas e pilhas são úteis quando você precisa de armazenamento temporário para obter informações; ou seja, quando talvez você queira descartar um elemento depois de recuperar seu valor. Use Queue se precisar acessar as informações na mesma ordem em que elas são armazenadas na coleção. Use Stack se precisar acessar as informações em ordem inversa. Use ConcurrentQueue<T> ou ConcurrentStack<T> se você precisar acessar a coleção de vários threads simultaneamente.

Três operações de main podem ser executadas em um Queue e seus elementos:

• Enqueue adiciona um elemento ao final do Queue.

• Dequeue remove o elemento mais antigo do início do Queue.

• Peek retorna o elemento mais antigo que está no início do , mas não o Queue remove do Queue.

A capacidade de um Queue é o número de elementos que o Queue pode conter. À medida que os elementos são adicionados a um Queue, a capacidade é aumentada automaticamente conforme necessário por meio da realocação. A capacidade pode ser reduzida chamando TrimToSize.

O fator de crescimento é o número pelo qual a capacidade atual é multiplicada quando uma capacidade maior é necessária. O fator de crescimento é determinado quando o Queue é construído. O fator de crescimento padrão é 2,0. A capacidade do Queue sempre aumentará em pelo menos um mínimo de quatro, independentemente do fator de crescimento. Por exemplo, um Queue com um fator de crescimento de 1,0 sempre aumentará a capacidade em quatro quando uma capacidade maior for necessária.

Queue aceita null como um valor válido e permite elementos duplicados.

Para obter a versão genérica desta coleção, consulte System.Collections.Generic.Queue<T>

Construtores

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.
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.
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.
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.

Propriedades

Count	Obtém o número de elementos contidos no Queue.
IsSynchronized	Obtém um valor que indica se o acesso à Queue é sincronizado (thread-safe).
SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso ao Queue.

Métodos

Clear()	Remove todos os objetos da Queue.
Clone()	Cria uma cópia superficial do Queue.
Contains(Object)	Determina se um elemento está no Queue.
CopyTo(Array, Int32)	Copia os elementos Queue em um Array unidimensional existente, começando no índice da matriz especificado.
Dequeue()	Remove e retorna o objeto no início do Queue.
Enqueue(Object)	Adiciona um objeto ao final do Queue.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetEnumerator()	Retorna um enumerador que itera por meio de Queue.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Peek()	Retorna o objeto ao início da Queue sem removê-lo.
Synchronized(Queue)	Retorna um novo Queue que encapsula a fila original e é thread-safe.
ToArray()	Copia os elementos do Queue em uma nova matriz.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TrimToSize()	Define a capacidade para o número real de elementos em Queue.

Métodos de Extensão

Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe. Não há garantia de que qualquer membro de instância seja seguro para threads.

Para garantir a segurança de thread do Queue, todas as operações devem ser feitas por meio do wrapper retornado pelo Synchronized(Queue) método .

A enumeração por meio de uma coleção não é um procedimento thread-safe intrínseco. 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. 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.

Confira também

• Queue<T>