Queue Klasse

Definition

Namespace:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Quelle:

Queue.cs

Stellt eine FIFO-Auflistung (First-In-First-Out) von Objekten dar.

public ref class Queue : ICloneable, System::Collections::ICollection

public class Queue : ICloneable, System.Collections.ICollection

type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

Public Class Queue
Implements ICloneable, ICollection

Vererbung

Object

Queue

Implementiert

ICollection IEnumerable ICloneable

Beispiele

Das folgende Beispiel zeigt, wie Sie Werte erstellen und zu einem Queue hinzufügen und wie die Werte ausgegeben werden.

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    !

Hinweise

Diese Klasse implementiert eine Warteschlange als zirkuläres Array. In einem Queue gespeicherte Objekte werden an einem Ende eingefügt und vom anderen entfernt.

Wichtig

Es wird nicht empfohlen, die Queue -Klasse für neue Entwicklungen zu verwenden. Stattdessen wird empfohlen, die generische Queue<T> Klasse zu verwenden. Weitere Informationen finden Sie unter Nicht generische Sammlungen sollten nicht auf GitHub verwendet werden.

Warteschlangen und Stapel sind nützlich, wenn Sie temporären Speicher für Informationen benötigen. Das heißt, wenn Sie ein Element nach dem Abrufen des Werts verwerfen möchten. Verwenden Sie Queue , wenn Sie auf die Informationen in der gleichen Reihenfolge zugreifen müssen, in der sie in der Sammlung gespeichert sind. Verwenden Sie Stack , wenn Sie in umgekehrter Reihenfolge auf die Informationen zugreifen müssen. Verwenden Sie ConcurrentQueue<T> oder ConcurrentStack<T> , wenn Sie von mehreren Threads gleichzeitig auf die Sammlung zugreifen müssen.

Drei Standard Vorgänge können für ein Queue und seine Elemente ausgeführt werden:

• Enqueue fügt am Ende von Queueein -Element hinzu.

• Dequeue entfernt das älteste Element vom Anfang von Queue.

• Peek gibt das älteste Element zurück, das sich am Anfang von Queue befindet, entfernt es jedoch nicht aus dem Queue.

Die Kapazität eines Queue ist die Anzahl der Elemente, die enthalten Queue können. Wenn Elemente zu einem Queuehinzugefügt werden, wird die Kapazität automatisch bei Bedarf durch Neuzuweisung erhöht. Die Kapazität kann verringert werden, indem Sie aufrufen TrimToSize.

Der Wachstumsfaktor ist die Zahl, mit der die aktuelle Kapazität multipliziert wird, wenn eine größere Kapazität erforderlich ist. Der Wachstumsfaktor wird bestimmt, wenn der Queue erstellt wird. Der Standardwachstumsfaktor ist 2.0. Die Kapazität des Queue wird immer mindestens um mindestens vier erhöht, unabhängig vom Wachstumsfaktor. Beispielsweise wird ein Queue mit einem Wachstumsfaktor von 1,0 die Kapazität immer um vier erhöht, wenn eine größere Kapazität erforderlich ist.

Queue akzeptiert null als gültigen Wert und lässt doppelte Elemente zu.

Die generische Version dieser Sammlung finden Sie unter System.Collections.Generic.Queue<T>

Konstruktoren

Queue()	Initialisiert eine neue, leere Instanz der Queue-Klasse, die anfänglich über die Standardkapazität verfügt und den Standardzuwachsfaktor verwendet.
Queue(ICollection)	Initialisiert eine neue Instanz der Queue-Klasse, die aus der angegebenen Auflistung kopierte Elemente enthält und über eine der Anzahl der kopierten Elemente entsprechende anfängliche Kapazität verfügt sowie den Standardzuwachsfaktor verwendet.
Queue(Int32)	Initialisiert eine neue, leere Instanz der Queue-Klasse mit der angegebenen anfänglichen Kapazität und dem Standardzuwachsfaktor.
Queue(Int32, Single)	Initialisiert eine neue, leere Instanz der Queue-Klasse mit den angegebenen Werten für die anfängliche Kapazität und den Zuwachsfaktor.

Eigenschaften

Count	Ruft die Anzahl der Elemente ab, die in Queue enthalten sind.
IsSynchronized	Ruft einen Wert ab, der angibt, ob der Zugriff auf die Queue synchronisiert (threadsicher) ist.
SyncRoot	Ruft ein Objekt ab, mit dem der Zugriff auf Queue synchronisiert werden kann.

Methoden

Clear()	Entfernt alle Objekte aus dem Queue.
Clone()	Erstellt eine flache Kopie von Queue.
Contains(Object)	Bestimmt, ob sich ein Element in Queue befindet.
CopyTo(Array, Int32)	Kopiert die Queue-Elemente in ein vorhandenes eindimensionales Array, beginnend beim angegebenen Arrayindex.
Dequeue()	Entfernt das Objekt am Anfang der Queue und gibt es zurück.
Enqueue(Object)	Fügt am Ende der Queue ein Objekt hinzu.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetEnumerator()	Gibt einen Enumerator zurück, der die Queue durchläuft.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Peek()	Gibt das Objekt am Anfang der Queue zurück, ohne es zu entfernen.
Synchronized(Queue)	Gibt eine neue Queue zurück, die die ursprüngliche Warteschlange umschließt und threadsicher ist.
ToArray()	Kopiert die Queue-Elemente in ein neues Array.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TrimToSize()	Legt die Kapazität auf die Anzahl der tatsächlich in der Queue enthaltenen Elemente fest.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um
OfType<TResult>(IEnumerable)	Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs
AsParallel(IEnumerable)	Ermöglicht die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Konvertiert einen IEnumerable in einen IQueryable.

Threadsicherheit

Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Um die Threadsicherheit des Queuezu gewährleisten, müssen alle Vorgänge über den von der Synchronized(Queue) -Methode zurückgegebenen Wrapper ausgeführt werden.

Die Enumeration einer Auflistung ist systemintern keine threadsichere Prozedur. Selbst wenn eine Auflistung synchronisiert wird, besteht die Möglichkeit, dass andere Threads sie ändern. Dies führt dazu, dass der Enumerator eine Ausnahme auslöst. Um während der Enumeration Threadsicherheit zu gewährleisten, können Sie entweder die Auflistung während der gesamten Enumeration sperren oder die Ausnahmen, die aus von anderen Threads stammenden Änderungen resultieren, abfangen.

Weitere Informationen

• Queue<T>