Queue<T> Klasa

Definicja

Reprezentuje pierwszą kolekcję obiektów w pierwszej kolejności.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)

Parametry typu

T

Określa typ elementów w kolejce.Specifies the type of elements in the queue.

Dziedziczenie
Queue<T>
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu ilustruje kilka metod Queue<T> klasy generycznej.The following code example demonstrates several methods of the Queue<T> generic class. Przykładowy kod tworzy kolejkę ciągów z pojemnością domyślną i używa Enqueue metody do kolejki pięciu ciągów.The code example creates a queue of strings with default capacity and uses the Enqueue method to queue five strings. Elementy kolejki są wyliczane, co nie powoduje zmiany stanu kolejki.The elements of the queue are enumerated, which does not change the state of the queue. Dequeue Metoda jest używana do usuwania z kolejki pierwszego ciągu.The Dequeue method is used to dequeue the first string. Metoda jest używana do przeszukiwania następnego elementu w kolejce, a Dequeue następnie jest używana do usuwania z kolejki. PeekThe Peek method is used to look at the next item in the queue, and then the Dequeue method is used to dequeue it.

Metoda jest używana do tworzenia tablicy i kopiowania do niej elementów kolejki, a następnie tablica jest przenoszona Queue<T> do konstruktora, który pobiera IEnumerable<T>, tworząc kopię kolejki. ToArrayThe 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. Zostaną wyświetlone elementy kopiowane.The elements of the copy are displayed.

Tworzona jest podwójna tablica rozmiaru kolejki, a CopyTo Metoda jest używana do kopiowania elementów tablicy, zaczynając od środka tablicy.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. Queue<T> Konstruktor jest ponownie używany do utworzenia drugiej kopii kolejki zawierającej trzy elementy o wartości null na początku.The Queue<T> constructor is used again to create a second copy of the queue containing three null elements at the beginning.

Metoda służy do pokazywania, że ciąg "cztery" znajduje się w pierwszej kopii kolejki, po Clear której Metoda czyści kopię, a Count Właściwość wskazuje, że kolejka jest pusta. ContainsThe 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

Uwagi

Ta klasa implementuje kolejkę ogólną jako tablicę cykliczną.This class implements a generic queue as a circular array. Obiekty przechowywane w a Queue<T> są wstawiane na jednym końcu i usuwane z innych.Objects stored in a Queue<T> are inserted at one end and removed from the other. Kolejki i stosy są przydatne, gdy potrzebujesz tymczasowego magazynu, aby uzyskać informacje; oznacza to, że jeśli chcesz odrzucić element po pobraniu jego wartości.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. Użyj Queue<T> , jeśli chcesz uzyskać dostęp do informacji w takiej samej kolejności, w jakiej są przechowywane w kolekcji.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Użyj Stack<T> , jeśli chcesz uzyskać dostęp do informacji w odwrotnej kolejności.Use Stack<T> if you need to access the information in reverse order. Użyj ConcurrentQueue<T> lubConcurrentStack<T> , jeśli chcesz uzyskać dostęp do kolekcji z wielu wątków jednocześnie.Use ConcurrentQueue<T> or ConcurrentStack<T> if you need to access the collection from multiple threads concurrently.

Trzy główne operacje można wykonać na Queue<T> i jego elementach:Three main operations can be performed on a Queue<T> and its elements:

Pojemność a to liczba Queue<T> elementów, które Queue<T> mogą być przechowywane.The capacity of a Queue<T> is the number of elements the Queue<T> can hold. Gdy elementy są dodawane do Queue<T>, pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez ponowną alokację tablicy wewnętrznej.As elements are added to a Queue<T>, the capacity is automatically increased as required by reallocating the internal array. Wydajność można zmniejszyć, wywołując TrimExcessmetodę.The capacity can be decreased by calling TrimExcess.

Queue<T>akceptuje null jako prawidłową wartość dla typów odwołań i umożliwia duplikowanie elementów.Queue<T> accepts null as a valid value for reference types and allows duplicate elements.

Konstruktory

Queue<T>()

Inicjuje nowe wystąpienie Queue<T> klasy, która jest pusta i ma domyślną pojemność początkową.Initializes a new instance of the Queue<T> class that is empty and has the default initial capacity.

Queue<T>(IEnumerable<T>)

Inicjuje nowe wystąpienie Queue<T> klasy zawierające elementy skopiowane z określonej kolekcji i ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów.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)

Inicjuje nowe wystąpienie Queue<T> klasy, która jest pusta i ma określoną pojemność początkową.Initializes a new instance of the Queue<T> class that is empty and has the specified initial capacity.

Właściwości

Count

Pobiera liczbę elementów zawartych w Queue<T>.Gets the number of elements contained in the Queue<T>.

Metody

Clear()

Usuwa wszystkie obiekty z Queue<T>.Removes all objects from the Queue<T>.

Contains(T)

Określa, Queue<T>czy element znajduje się w.Determines whether an element is in the Queue<T>.

CopyTo(T[], Int32)

Kopiuje elementy do istniejących jednowymiarowych Array, rozpoczynając od określonego indeksu tablicy. Queue<T>Copies the Queue<T> elements to an existing one-dimensional Array, starting at the specified array index.

Dequeue()

Usuwa i zwraca obiekt na początku Queue<T>.Removes and returns the object at the beginning of the Queue<T>.

Enqueue(T)

Dodaje obiekt na końcu Queue<T>.Adds an object to the end of the Queue<T>.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetEnumerator()

Zwraca moduł wyliczający, który wykonuje iterację przez Queue<T>.Returns an enumerator that iterates through the Queue<T>.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Peek()

Zwraca obiekt na początku Queue<T> bez usuwania go.Returns the object at the beginning of the Queue<T> without removing it.

ToArray()

Queue<T> Kopiuje elementy do nowej tablicy.Copies the Queue<T> elements to a new array.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TrimExcess()

Ustawia pojemność na rzeczywistą liczbę elementów w Queue<T>, jeśli ta liczba jest mniejsza niż 90% bieżącej pojemności.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)

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection Arraydo, zaczynając od określonego Array indeksu.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Pobiera wartość wskazującą, ICollection czy dostęp do elementu jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do ICollection.Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

Metody rozszerzania

CopyToDataTable<T>(IEnumerable<T>)

DataRow T IEnumerable<T> Zwraca obiekt, DataRow który zawiera kopie obiektów, z uwzględnieniem obiektu wejściowego, w którym parametr generyczny jest. DataTableReturns 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)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.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)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

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

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) członkowie tego typu są bezpieczne wątkowo.Public static (Shared in Visual Basic) members of this type are thread safe. Wystąpienia elementów członkowskich nie dają gwarancji bezpieczeństwa wątków.Any instance members are not guaranteed to be thread safe.

Queue<T> Może obsługiwać wielu czytników współbieżnie, o ile kolekcja nie jest modyfikowana.A Queue<T> can support multiple readers concurrently, as long as the collection is not modified. Nawet w ten sposób Wyliczanie za pomocą kolekcji nie jest w sposób wewnętrzny bezpieczny dla wątków.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. W przypadku kolejki z obsługą wątków należy ConcurrentQueue<T>zapoznać się z tematem.For a thread-safe queue, see ConcurrentQueue<T>.