Queue Třída

Definice

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

Public Class Queue
Implements ICollection

Public Class Queue
Implements ICloneable, ICollection

Dědičnost

Object

Queue

Atributy

SerializableAttribute ComVisibleAttribute

Implementuje

ICollection IEnumerable ICloneable

Příklady

Následující příklad ukazuje, jak vytvořit a přidat hodnoty do objektu Queue a jak vytisknout jeho hodnoty.

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    !

Poznámky

Tato třída implementuje frontu jako kruhové pole. Objekty uložené v objektu Queue se vkládají na jeden konec a z druhého se odeberou.

Fronty a zásobníky jsou užitečné, pokud potřebujete dočasné úložiště pro informace; to znamená, když můžete chtít zahodit prvek po načtení jeho hodnoty. Použijte Queue , pokud potřebujete získat přístup k informacím ve stejném pořadí, v jakém jsou uložené v kolekci. Použijte Stack , pokud potřebujete získat přístup k informacím v obráceném pořadí. Pokud potřebujete přistupovat ke kolekci z více vláken současně, použijte ConcurrentQueue<T> nebo ConcurrentStack<T> .

Se objektem Queue a jeho prvky lze provádět tři hlavní operace:

• Enqueue přidá prvek na konec objektu Queue.

• Dequeue odebere nejstarší prvek ze začátku objektu Queue.

• Peek vrátí nejstarší prvek, který je na začátku objektu , Queue ale neodebere ho z objektu Queue.

Kapacita objektu Queue je počet prvků, které Queue může obsahovat. Při přidání prvků do objektu Queuese kapacita automaticky zvýší podle potřeby prostřednictvím přerozdělení. Kapacitu lze snížit voláním TrimToSizemetody .

Faktor růstu je číslo, kterým se aktuální kapacita vynásobí, pokud je vyžadována větší kapacita. Faktor růstu se určí při vytváření objektu Queue . Výchozí faktor růstu je 2,0. Kapacita vždy Queue vzroste minimálně o čtyři, bez ohledu na faktor růstu. Například Queue s faktorem růstu 1,0 se kapacita vždy zvýší o čtyři, pokud je vyžadována větší kapacita.

Queue přijímá null jako platnou hodnotu a umožňuje duplicitní prvky.

Obecnou verzi této kolekce najdete v tématu System.Collections.Generic.Queue<T>

Konstruktory

Vlastnosti

Metody

Metody rozšíření

Platí pro

Bezpečný přístup z více vláken

Veřejné statické členy (Shared v jazyce Visual Basic) tohoto typu jsou bezpečné pro přístup z více vláken. U členů instancí není zaručena bezpečnost pro přístup z více vláken.

Aby byla zajištěna bezpečnost Queuevlákna , musí být všechny operace prováděny prostřednictvím obálky vrácené metodou Synchronized(Queue) .

Výčet prostřednictvím kolekce nemůže být procedurou bezpečnou pro přístup z více vláken. I v případě, že jde o synchronizovanou kolekci, mohou úpravy provádět i ostatní vlákna, což způsobuje vyvolání výjimky enumerátorem. K zaručení bezpečnosti přístupu z více vláken můžete buďto zamknout kolekci na celou dobu práce s výčtem, nebo zachycovat výjimky vzniklé v důsledku změn prováděných ostatními vlákny.

Viz také

• Queue<T>