Queue Klasse

Referenz

Definition

Namespace:: System.Collections

Assemblys:: mscorlib.dll, System.Collections.NonGeneric.dll

Assembly:: System.Collections.NonGeneric.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

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.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class Queue : ICloneable, System.Collections.ICollection

type Queue = class
    interface ICollection
    interface IEnumerable

type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Queue = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Queue = class
    interface ICollection
    interface ICloneable
    interface IEnumerable

Public Class Queue
Implements ICollection

Public Class Queue
Implements ICloneable, ICollection

Vererbung: Object
Queue

Attribute: SerializableAttribute ComVisibleAttribute

Implementiert: ICollection IEnumerable ICloneable

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie Werte zu einem Queue Erstellen und Hinzufügen von Werten und zum Drucken ihrer Werte erstellen und hinzufügen.

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 Zirkelarray. Objekte, die in einem Queue Objekt gespeichert sind, werden an einem Ende eingefügt und aus dem anderen entfernt.

Wichtig

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

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 derselben Reihenfolge zugreifen müssen, in der sie in der Sammlung gespeichert ist. Verwenden Stack Sie, wenn Sie auf die Informationen in umgekehrter Reihenfolge zugreifen müssen. Verwenden ConcurrentQueue<T> Oder ConcurrentStack<T> wenn Sie gleichzeitig auf die Auflistung aus mehreren Threads zugreifen müssen.

Drei Hauptvorgänge können auf einer Queue und ihren Elementen ausgeführt werden:

Enqueue fügt dem Ende des QueueElements ein Element hinzu.
Dequeue entfernt das älteste Element vom Anfang des Queue.
Peek gibt das älteste Element zurück, das sich am Anfang des Queue Elements befindet, entfernt sie jedoch nicht aus dem Queue.

Die Kapazität eines Queue Elements ist die Anzahl der Elemente, die Queue gehalten werden können. Da Elemente zu einer Queuehinzugefügt werden, wird die Kapazität automatisch durch Eine Reallocation erhöht. Die Kapazität kann durch Aufrufen TrimToSizeverringert werden.

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 die Queue Konstruktion erfolgt. Der Standardwachstumsfaktor ist 2.0. Die Kapazität der Queue Funktion wird immer um mindestens vier erhöht, unabhängig vom Wachstumsfaktor. Beispielsweise wird ein Queue Wachstumsfaktor von 1,0 immer um vier Kapazität erhöht, wenn eine größere Kapazität erforderlich ist.

Queue akzeptiert null als gültiger Wert und ermöglicht doppelte Elemente.

Informationen zur generischen Version dieser Auflistung 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.

Gilt für

Threadsicherheit

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

Um die Threadsicherheit des Threads Queuezu gewährleisten, müssen alle Vorgänge über den von der Synchronized(Queue) Methode zurückgegebenen Wrapper durchgefü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.

Siehe auch

Queue<T>