Queue<T> Classe

Definizione

Rappresenta una raccolta di oggetti FIFO (First-In First-Out).Represents a first-in, first-out collection of objects.

generic <typename T>
public ref class Queue : System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
type Queue<'T> = class
    interface seq<'T>
    interface ICollection
    interface IReadOnlyCollection<'T>
    interface IEnumerable
Public Class Queue(Of T)
Implements ICollection, IEnumerable(Of T), IReadOnlyCollection(Of T)

Parametri di tipo

T

Specifica il tipo di elementi della coda.Specifies the type of elements in the queue.

Ereditarietà
Queue<T>
Attributi
Implementazioni

Esempi

Nell'esempio di codice seguente vengono illustrati diversi Queue<T> metodi della classe generica.The following code example demonstrates several methods of the Queue<T> generic class. Nell'esempio di codice viene creata una coda di stringhe con la capacità predefinita Enqueue e viene utilizzato il metodo per accodare cinque stringhe.The code example creates a queue of strings with default capacity and uses the Enqueue method to queue five strings. Gli elementi della coda vengono enumerati, che non modifica lo stato della coda.The elements of the queue are enumerated, which does not change the state of the queue. Il Dequeue metodo viene usato per rimuovere dalla coda la prima stringa.The Dequeue method is used to dequeue the first string. Il Peek metodo viene usato per esaminare l'elemento successivo nella coda e quindi il metodo viene usato Dequeue per rimuovere la coda.The Peek method is used to look at the next item in the queue, and then the Dequeue method is used to dequeue it.

Il ToArray metodo viene usato per creare una matrice e copiarvi gli elementi della coda, quindi la matrice viene passata Queue<T> al costruttore che accetta IEnumerable<T>, creando una copia della coda.The ToArray method is used to create an array and copy the queue elements to it, then the array is passed to the Queue<T> constructor that takes IEnumerable<T>, creating a copy of the queue. Vengono visualizzati gli elementi della copia.The elements of the copy are displayed.

Viene creata una matrice due volte la dimensione della coda e il CopyTo metodo viene usato per copiare gli elementi della matrice a partire dal centro della matrice.An array twice the size of the queue is created, and the CopyTo method is used to copy the array elements beginning at the middle of the array. Il Queue<T> costruttore viene nuovamente utilizzato per creare una seconda copia della coda contenente tre elementi null all'inizio.The Queue<T> constructor is used again to create a second copy of the queue containing three null elements at the beginning.

Il Contains metodo viene utilizzato per indicare che la stringa "quattro" si trova nella prima copia della coda, dopo la quale il Clear metodo cancella la copia e la Count proprietà indica che la coda è vuota.The Contains method is used to show that the string "four" is in the first copy of the queue, after which the Clear method clears the copy and the Count property shows that the queue is empty.

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Queue<string> numbers = new Queue<string>();
        numbers.Enqueue("one");
        numbers.Enqueue("two");
        numbers.Enqueue("three");
        numbers.Enqueue("four");
        numbers.Enqueue("five");

        // A queue can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nDequeuing '{0}'", numbers.Dequeue());
        Console.WriteLine("Peek at next item to dequeue: {0}", 
            numbers.Peek());
        Console.WriteLine("Dequeuing '{0}'", numbers.Dequeue());

        // Create a copy of the queue, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Queue<string> queueCopy = new Queue<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in queueCopy )
        {
            Console.WriteLine(number);
        }
        
        // Create an array twice the size of the queue and copy the
        // elements of the queue, starting at the middle of the 
        // array. 
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);
        
        // Create a second queue, using the constructor that accepts an
        // IEnumerable(Of T).
        Queue<string> queueCopy2 = new Queue<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in queueCopy2 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nqueueCopy.Contains(\"four\") = {0}", 
            queueCopy.Contains("four"));

        Console.WriteLine("\nqueueCopy.Clear()");
        queueCopy.Clear();
        Console.WriteLine("\nqueueCopy.Count = {0}", queueCopy.Count);
    }
}

/* This code example produces the following output:

one
two
three
four
five

Dequeuing 'one'
Peek at next item to dequeue: two
Dequeuing 'two'

Contents of the copy:
three
four
five

Contents of the second copy, with duplicates and nulls:



three
four
five

queueCopy.Contains("four") = True

queueCopy.Clear()

queueCopy.Count = 0
 */
Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New Queue(Of String)
        numbers.Enqueue("one")
        numbers.Enqueue("two")
        numbers.Enqueue("three")
        numbers.Enqueue("four")
        numbers.Enqueue("five")

        ' A queue can be enumerated without disturbing its contents.
        For Each number As String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Dequeuing '{0}'", numbers.Dequeue())
        Console.WriteLine("Peek at next item to dequeue: {0}", _
            numbers.Peek())    
        Console.WriteLine("Dequeuing '{0}'", numbers.Dequeue())

        ' Create a copy of the queue, using the ToArray method and the
        ' constructor that accepts an IEnumerable(Of T).
        Dim queueCopy As New Queue(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As String In queueCopy
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the queue, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the queue, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second queue, using the constructor that accepts an
        ' IEnumerable(Of T).
        Dim queueCopy2 As New Queue(Of String)(array2)

        Console.WriteLine(vbLf & _
            "Contents of the second copy, with duplicates and nulls:")
        For Each number As String In queueCopy2
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "queueCopy.Contains(""four"") = {0}", _
            queueCopy.Contains("four"))

        Console.WriteLine(vbLf & "queueCopy.Clear()")
        queueCopy.Clear()
        Console.WriteLine(vbLf & "queueCopy.Count = {0}", _
            queueCopy.Count)
    End Sub
End Module

' This code example produces the following output:
'
'one
'two
'three
'four
'five
'
'Dequeuing 'one'
'Peek at next item to dequeue: two
'
'Dequeuing 'two'
'
'Contents of the copy:
'three
'four
'five
'
'Contents of the second copy, with duplicates and nulls:
'
'
'
'three
'four
'five
'
'queueCopy.Contains("four") = True
'
'queueCopy.Clear()
'
'queueCopy.Count = 0

Commenti

Questa classe implementa una coda generica come matrice circolare.This class implements a generic queue as a circular array. Gli oggetti archiviati in Queue<T> un vengono inseriti in un'unica estremità e rimossi dall'altro.Objects stored in a Queue<T> are inserted at one end and removed from the other. Le code e gli stack sono utili quando è necessaria l'archiviazione temporanea per informazioni. ovvero, quando potrebbe essere necessario rimuovere un elemento dopo il recupero del relativo valore.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. Usare Queue<T> se è necessario accedere alle informazioni nello stesso ordine in cui sono archiviate nella raccolta.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Usare Stack<T> se è necessario accedere alle informazioni in ordine inverso.Use Stack<T> if you need to access the information in reverse order. Usare ConcurrentQueue<T> oConcurrentStack<T> se è necessario accedere alla raccolta da più thread contemporaneamente.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

È possibile eseguire tre operazioni principali su un Queue<T> oggetto e sui relativi elementi:Three main operations can be performed on a Queue<T> and its elements:

La capacità di un Queue<T> oggetto è il numero di Queue<T> elementi che può essere in attesa.The capacity of a Queue<T> is the number of elements the Queue<T> can hold. Quando gli elementi vengono aggiunti a Queue<T>un oggetto, la capacità viene aumentata automaticamente in base alle esigenze riallocando la matrice interna.As elements are added to a Queue<T>, the capacity is automatically increased as required by reallocating the internal array. La capacità può essere ridotta TrimExcesschiamando.The capacity can be decreased by calling TrimExcess.

Queue<T>accetta null come valore valido per i tipi di riferimento e consente elementi duplicati.Queue<T> accepts null as a valid value for reference types and allows duplicate elements.

Costruttori

Queue<T>()

Inizializza una nuova istanza della classe Queue<T> vuota e con capacità iniziale predefinita.Initializes a new instance of the Queue<T> class that is empty and has the default initial capacity.

Queue<T>(IEnumerable<T>)

Inizializza una nuova istanza della classe Queue<T> che contiene gli elementi copiati dalla raccolta specificata e ha la capacità sufficiente per contenere il numero di elementi copiati.Initializes a new instance of the Queue<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.

Queue<T>(Int32)

Inizializza una nuova istanza della classe Queue<T> vuota e con capacità iniziale specificata.Initializes a new instance of the Queue<T> class that is empty and has the specified initial capacity.

Proprietà

Count

Ottiene il numero di elementi contenuti in Queue<T>.Gets the number of elements contained in the Queue<T>.

Metodi

Clear()

Rimuove tutti gli oggetti da Queue<T>.Removes all objects from the Queue<T>.

Contains(T)

Determina se un elemento è incluso in Queue<T>.Determines whether an element is in the Queue<T>.

CopyTo(T[], Int32)

Copia gli elementi di Queue<T> in un oggetto Array unidimensionale esistente, partendo dall'indice della matrice specificata.Copies the Queue<T> elements to an existing one-dimensional Array, starting at the specified array index.

Dequeue()

Consente di rimuovere e restituire l'oggetto all'inizio della Queue<T>.Removes and returns the object at the beginning of the Queue<T>.

Enqueue(T)

Aggiunge un oggetto alla fine di Queue<T>.Adds an object to the end of the Queue<T>.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione di Queue<T>.Returns an enumerator that iterates through the Queue<T>.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Peek()

Restituisce l'oggetto all'inizio della Queue<T> senza rimuoverlo.Returns the object at the beginning of the Queue<T> without removing it.

ToArray()

Consente di copiare gli elementi della Queue<T> in una nuova matrice.Copies the Queue<T> elements to a new array.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
TrimExcess()

Imposta la capacità dell'insieme sul numero reale di elementi contenuti nell'oggetto Queue<T>, se questo numero è inferiore al 90 per cento della capacità corrente.Sets the capacity to the actual number of elements in the Queue<T>, if that number is less than 90 percent of current capacity.

TryDequeue(T)
TryPeek(T)

Implementazioni dell'interfaccia esplicita

ICollection.CopyTo(Array, Int32)

Copia gli elementi di ICollection in Array a partire da un particolare indice Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso a ICollection è sincronizzato (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ICollection.Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.Returns an enumerator that iterates through a collection.

Metodi di estensione

CopyToDataTable<T>(IEnumerable<T>)

Restituisce un oggetto DataTable che contiene copie degli oggetti DataRow, dato un oggetto IEnumerable<T> di input dove il parametro generico DataRow è T.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Thread safety

I membri staticiShared pubblici (in Visual Basic) di questo tipo sono thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. I membri di istanza non sono garantiti come thread-safe.Any instance members are not guaranteed to be thread safe.

Un Queue<T> oggetto può supportare più lettori contemporaneamente, purché la raccolta non venga modificata.A Queue<T> can support multiple readers concurrently, as long as the collection is not modified. Anche in questo caso, l'enumerazione di una raccolta non è intrinsecamente una procedura thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Per una coda thread-safe, vedere ConcurrentQueue<T>.For a thread-safe queue, see ConcurrentQueue<T>.