Queue Clase

Definición

Representa una colección de objetos de tipo primero en entrar, primero en salir.Represents a first-in, first-out collection of objects.

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.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Queue : ICloneable, System.Collections.ICollection
type Queue = class
    interface ICollection
    interface IEnumerable
type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable
type Queue = class
    interface ICollection
    interface ICloneable
    interface IEnumerable
Public Class Queue
Implements ICollection
Public Class Queue
Implements ICloneable, ICollection
Herencia
Queue
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo crear y agregar valores a un Queue y cómo imprimir sus 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.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.This class implements a queue as a circular array. Los objetos almacenados en un Queue se insertan en un extremo y se quitan de los demás.Objects stored in a Queue are inserted at one end and removed from the other.

Importante

No se recomienda usar la clase Queue para el desarrollo nuevo.We don't recommend that you use the Queue class for new development. En su lugar, se recomienda usar la clase Queue<T> genérica.Instead, we recommend that you use the generic Queue<T> class. Para obtener más información, consulte no se deben usar colecciones no genéricas en github.For more information, see Non-generic collections shouldn't be used on GitHub.

Las colas y las pilas son útiles cuando se necesita almacenamiento temporal para obtener información; es decir, cuando es posible que desee descartar un elemento después de recuperar su 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 si necesita tener acceso a la información en el mismo orden en que se almacena en la colección.Use Queue if you need to access the information in the same order that it is stored in the collection. Use Stack si necesita tener acceso a la información en orden inverso.Use Stack if you need to access the information in reverse order. Utilice ConcurrentQueue<T> o ConcurrentStack<T> si necesita tener acceso a la colección desde varios subprocesos simultáneamente.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

Se pueden realizar tres operaciones principales en una Queue y sus elementos:Three main operations can be performed on a Queue and its elements:

  • Enqueue agrega un elemento al final de la Queue.Enqueue adds an element to the end of the Queue.

  • Dequeue quita el elemento más antiguo del inicio de la Queue.Dequeue removes the oldest element from the start of the Queue.

  • Peek devuelve el elemento más antiguo que está al principio del Queue pero no lo quita 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 capacidad de una Queue es el número de elementos que puede contener el Queue.The capacity of a Queue is the number of elements the Queue can hold. A medida que se agregan elementos a un Queue, la capacidad aumenta automáticamente según sea necesario a través de la reasignación.As elements are added to a Queue, the capacity is automatically increased as required through reallocation. La capacidad se puede reducir llamando a TrimToSize.The capacity can be decreased by calling TrimToSize.

El factor de crecimiento es el número por el que se multiplica la capacidad actual cuando se necesita una capacidad mayor.The growth factor is the number by which the current capacity is multiplied when a greater capacity is required. El factor de crecimiento se determina cuando se construye el Queue.The growth factor is determined when the Queue is constructed. El factor de crecimiento predeterminado es 2,0.The default growth factor is 2.0. La capacidad del Queue siempre aumentará en un mínimo de cuatro, independientemente del factor de crecimiento.The capacity of the Queue will always increase by at least a minimum of four, regardless of the growth factor. Por ejemplo, un Queue con un factor de crecimiento de 1,0 siempre aumentará en capacidad en cuatro cuando se necesite una mayor capacidad.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 acepta null como un valor válido y permite elementos duplicados.Queue accepts null as a valid value and allows duplicate elements.

Para obtener la versión genérica de esta colección, vea System.Collections.Generic.Queue<T>For the generic version of this collection, see System.Collections.Generic.Queue<T>

Constructores

Queue()

Inicializa una nueva instancia de la clase Queue que está vacía, tiene la capacidad inicial predeterminada y utiliza el factor de crecimiento predeterminado.Initializes a new instance of the Queue class that is empty, has the default initial capacity, and uses the default growth factor.

Queue(ICollection)

Inicializa una nueva instancia de la clase Queue que contiene elementos copiados de la colección especificada, tiene la misma capacidad inicial que el número de elementos copiados y utiliza el factor de crecimiento predeterminado.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)

Inicializa una nueva instancia de la clase Queue que está vacía, tiene la capacidad inicial especificada y utiliza el factor de crecimiento predeterminado.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)

Inicializa una nueva instancia de la clase Queue que está vacía, tiene la capacidad inicial especificada y utiliza el factor de crecimiento especificado.Initializes a new instance of the Queue class that is empty, has the specified initial capacity, and uses the specified growth factor.

Propiedades

Count

Obtiene el número de elementos incluidos en Queue.Gets the number of elements contained in the Queue.

IsSynchronized

Obtiene un valor que indica si el acceso a la interfaz Queue está sincronizado (es seguro para subprocesos).Gets a value indicating whether access to the Queue is synchronized (thread safe).

SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a Queue.Gets an object that can be used to synchronize access to the Queue.

Métodos

Clear()

Quita todos los objetos de la colección Queue.Removes all objects from the Queue.

Clone()

Crea una copia superficial de la colección Queue.Creates a shallow copy of the Queue.

Contains(Object)

Determina si un elemento se encuentra en Queue.Determines whether an element is in the Queue.

CopyTo(Array, Int32)

Copia los elementos de Queue en una Array unidimensional existente, a partir del índice especificado de la matriz.Copies the Queue elements to an existing one-dimensional Array, starting at the specified array index.

Dequeue()

Quita y devuelve el objeto al comienzo de Queue.Removes and returns the object at the beginning of the Queue.

Enqueue(Object)

Agrega un objeto al final de Queue.Adds an object to the end of the Queue.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetEnumerator()

Devuelve un enumerador que recorre en iteración la colección Queue.Returns an enumerator that iterates through the Queue.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
Peek()

Devuelve un objeto al principio de Queue sin eliminarlo.Returns the object at the beginning of the Queue without removing it.

Synchronized(Queue)

Devuelve un nuevo Queue que contiene la cola original y es seguro para subprocesos.Returns a new Queue that wraps the original queue, and is thread safe.

ToArray()

Copia los elementos Queue en una matriz nueva.Copies the Queue elements to a new array.

ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)
TrimToSize()

Establece la capacidad en el número real de elementos que hay en Queue.Sets the capacity to the actual number of elements in the Queue.

Métodos de extensión

Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Se aplica a

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos.Public static (Shared in Visual Basic) members of this type are thread safe. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.Any instance members are not guaranteed to be thread safe.

Para garantizar la seguridad para subprocesos del Queue, todas las operaciones se deben realizar a través del contenedor devuelto por el método Synchronized(Queue).To guarantee the thread safety of the Queue, all operations must be done through the wrapper returned by the Synchronized(Queue) method.

Enumerar una colección no es intrínsecamente un procedimiento seguro para subprocesos.Enumerating through a collection is intrinsically not a thread-safe procedure. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.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.

Consulte también: