Queue Clase

Definición

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

Herencia

Object

Queue

Atributos

SerializableAttribute ComVisibleAttribute

Implementaciones

ICollection IEnumerable ICloneable

Ejemplos

En el ejemplo siguiente se muestra cómo crear y agregar valores a y Queue cómo imprimir sus 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    !

Comentarios

Esta clase implementa una cola como una matriz circular. Los objetos almacenados en se Queue insertan en un extremo y se quitan de la otra.

Las colas y pilas son útiles cuando se necesita almacenamiento temporal para obtener información; es decir, cuando quiera descartar un elemento después de recuperar su valor. Use Queue si necesita acceder a la información en el mismo orden en que se almacena en la colección. Use Stack si necesita acceder a la información en orden inverso. Use ConcurrentQueue<T> o ConcurrentStack<T> si necesita acceder a la colección desde varios subprocesos simultáneamente.

Se pueden realizar tres operaciones principales en un Queue elemento y sus elementos:

• Enqueue agrega un elemento al final de Queue.

• Dequeue quita el elemento más antiguo del principio de Queue.

• Peek devuelve el elemento más antiguo que está al principio de , Queue pero no lo quita de Queue.

La capacidad de un Queue es el número de elementos que Queue puede contener. A medida que se agregan elementos a , Queuela capacidad aumenta automáticamente según sea necesario mediante la reasignación. La capacidad se puede reducir llamando a TrimToSize.

El factor de crecimiento es el número por el que se multiplica la capacidad actual cuando se requiere una mayor capacidad. El factor de crecimiento se determina cuando Queue se construye . El factor de crecimiento predeterminado es 2.0. La capacidad de siempre Queue aumentará en al menos un mínimo de cuatro, independientemente del factor de crecimiento. Por ejemplo, un Queue con un factor de crecimiento de 1,0 siempre aumentará la capacidad en cuatro cuando se requiera una capacidad mayor.

Queuenull acepta como un valor válido y permite elementos duplicados.

Para obtener la versión genérica de esta colección, consulte System.Collections.Generic.Queue<T>

Constructores

Propiedades

Métodos

Métodos de extensión

Se aplica a

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Para garantizar la seguridad de subprocesos de Queue, todas las operaciones deben realizarse a través del contenedor devuelto por el Synchronized(Queue) método .

Enumerar una colección no es intrínsecamente un procedimiento seguro para subprocesos. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción. Con el fin de garantizar la seguridad para la ejecución de subprocesos durante la enumeración, se puede bloquear la colección durante toda la enumeración o detectar las excepciones resultantes de los cambios realizados por otros subprocesos.

Consulte también

• Queue<T>