Queue Queue Queue Queue Class

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 : 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
Herencia
QueueQueueQueueQueue
Atributos
Implementaciones

Ejemplos

El ejemplo siguiente 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
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    !

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 la otra.Objects stored in a Queue are inserted at one end and removed from the other.

Importante

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

Las colas y pilas son útiles cuando se necesita almacenamiento temporal de información; es decir, cuando 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 acceder a la información en el mismo orden 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 acceder a la información en orden inverso.Use Stack if you need to access the information in reverse order. Use 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 un 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 desde el principio 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 de la Queue pero no se 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 un Queue es el número de elementos de la Queue puede contener.The capacity of a Queue is the number of elements the Queue can hold. Cuando se agregan elementos a un Queue, automáticamente se aumenta la capacidad según sea necesario mediante la reasignación.As elements are added to a Queue, the capacity is automatically increased as required through reallocation. La capacidad puede reducirse mediante una llamada 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 requiere una mayor capacidad.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 el Queue se construye.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 de la Queue aumentarán siempre en al menos un mínimo de cuatro, sin tener en cuenta el 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 por cuatro cuando se requiere 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() Queue() Queue() 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) Queue(ICollection) Queue(ICollection) 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) Queue(Int32) Queue(Int32) 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) Queue(Int32, Single) Queue(Int32, Single) 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 Count Count Count

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

IsSynchronized IsSynchronized IsSynchronized 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 SyncRoot SyncRoot 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() Clear() Clear() Clear()

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

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

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

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

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

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) 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() Dequeue() Dequeue() Dequeue()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Synchronized(Queue) Synchronized(Queue) Synchronized(Queue) 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() ToArray() ToArray() ToArray()

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

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

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

(Inherited from Object)
TrimToSize() TrimToSize() TrimToSize() 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.

Extension Methods

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

Convierte los elementos de un IEnumerable al 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 los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

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

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

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

Se aplica a

Seguridad para subprocesos

Estáticos públicos (Shared en Visual Basic) los miembros 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 de la Queue, todas las operaciones deben realizarse a través del contenedor devuelto por el 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.

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: