MessageEnumerator Třída

Reference

Definice

Obor názvů:: System.Messaging

Sestavení:: System.Messaging.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Poskytuje kurzor jen pro přeposlání pro výčet zpráv ve frontě zpráv.

public ref class MessageEnumerator : MarshalByRefObject, IDisposable, System::Collections::IEnumerator

public class MessageEnumerator : MarshalByRefObject, IDisposable, System.Collections.IEnumerator

type MessageEnumerator = class
    inherit MarshalByRefObject
    interface IEnumerator
    interface IDisposable

Public Class MessageEnumerator
Inherits MarshalByRefObject
Implements IDisposable, IEnumerator

Dědičnost: Object

MarshalByRefObject
MessageEnumerator

Implementuje: IEnumerator IDisposable

Příklady

Následující příklad získá dynamický seznam zpráv ve frontě a spočítá všechny zprávy s vlastností nastavenou Priority na MessagePriority.Lowest.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   void CountLowestPriority()
   {
      
      // Holds the count of Lowest priority messages.
      UInt32 numberItems = 0;
      
      // Connect to a queue.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      
      // Get a cursor into the messages in the queue.
      MessageEnumerator^ myEnumerator = myQueue->GetMessageEnumerator();
      
      // Specify that the messages's priority should be read.
      myQueue->MessageReadPropertyFilter->Priority = true;
      
      // Move to the next message and examine its priority.
      while ( myEnumerator->MoveNext() )
      {
         
         // Increase the count if priority is Lowest.
         if ( myEnumerator->Current->Priority == MessagePriority::Lowest )
                  numberItems++;
      }

      
      // Display final count.
      Console::WriteLine( "Lowest priority messages: {0}", numberItems );
      return;
   }

};

int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Output the count of Lowest priority messages.
   myNewQueue->CountLowestPriority();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example uses a cursor to step through the
        // messages in a queue and counts the number of
        // Lowest priority messages.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Output the count of Lowest priority messages.
            myNewQueue.CountLowestPriority();
                        
            return;
        }

        //**************************************************
        // Iterates through messages in a queue and examines
        // their priority.
        //**************************************************
        
        public void CountLowestPriority()
        {
            // Holds the count of Lowest priority messages.
            uint numberItems = 0;

            // Connect to a queue.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
    
            // Get a cursor into the messages in the queue.
            MessageEnumerator myEnumerator =
                myQueue.GetMessageEnumerator();

            // Specify that the messages's priority should be read.
            myQueue.MessageReadPropertyFilter.Priority = true;

            // Move to the next message and examine its priority.
            while(myEnumerator.MoveNext())
            {
                // Increase the count if priority is Lowest.
                if(myEnumerator.Current.Priority ==
                    MessagePriority.Lowest)
                    
                    numberItems++;
            }

            // Display final count.
            Console.WriteLine("Lowest priority messages: " +
                numberItems.ToString());
            
            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example uses a cursor to step through the
        ' messages in a queue and counts the number of 
        ' Lowest priority messages.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Output the count of Lowest priority messages.
            myNewQueue.CountLowestPriority()

            Return

        End Sub


        
        ' Iterates through messages in a queue and examines
        ' their priority.
        

        Public Sub CountLowestPriority()

            ' Holds the count of Lowest priority messages.
            Dim numberItems As Int32 = 0

            ' Connect to a queue.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Get a cursor into the messages in the queue.
            Dim myEnumerator As MessageEnumerator = _
                myQueue.GetMessageEnumerator()

            ' Specify that the messages's priority should be read.
            myQueue.MessageReadPropertyFilter.Priority = True

            ' Move to the next message and examine its priority.
            While myEnumerator.MoveNext()

                ' Increase the count if the priority is Lowest.
                If myEnumerator.Current.Priority = _
                    MessagePriority.Lowest Then
                    numberItems += 1
                End If

            End While

            ' Display final count.
            Console.WriteLine(("Lowest priority messages: " + _
                numberItems.ToString()))

            Return

        End Sub

End Class

Poznámky

Slouží MessageEnumerator k dynamické interakci se zprávami ve frontě. Metody dostupné prostřednictvím MessageQueue třídy mohou vrátit buď MessageEnumerator odkazující na dynamický seznam zpráv ve frontě, nebo pole, které obsahuje kopii v daném okamžiku - snímek - fronty v době, kdy byla zadaná metoda volána.

Na rozdíl od statického snímku vám enumerátor umožňuje upravit kolekci. MessageEnumeratorPomocí můžete zprávy z fronty odebrat a změna se okamžitě projeví ve frontě.

Enumerátor neodebere zprávy z fronty při dotazech na frontu. Vrátí informace o zprávě na aktuální pozici kurzoru, ale zprávu ponechá ve frontě.

A MessageEnumerator je kurzor inicializovaný v čele dynamického seznamu. Pořadí seznamu je stejné jako pořadí zpráv ve frontě podle priority zprávy. Kurzor na první zprávu ve frontě můžete přesunout voláním MoveNextmetody . Po inicializaci enumerátoru můžete použít MoveNext k procházení zbývajících zpráv. Můžete určit, zda se má čekat na zpřístupnění zprávy předáním časového limitu do MoveNext metody .

Vzhledem k tomu, že enumerátor je dynamický, může enumerátor získat přístup ke zprávě, která je připojena za aktuální pozici kurzoru (například kvůli nízké prioritě). Zpráva vložená před aktuální pozici kurzoru není přístupná. Pomocí není možné krokovat zpět.MessageEnumerator Kurzor umožňuje pohyb pouze dopředu. Metoda Reset umožňuje umístit kurzor zpět na začátek fronty.

Instance pro MessageEnumerator danou frontu fungují nezávisle. Můžete vytvořit dvě MessageEnumerator instance, které platí pro stejnou frontu. Změny provedené ve MessageEnumerator zprávách ve frontě se okamžitě projeví v druhém výčtu, pokud je druhý enumerátor umístěn před prvním. Pokud však dva enumerátory mají stejnou pozici a jeden z nich odebere zprávu na této pozici, je vyvolán výjimka, pokud se druhý enumerátor pokusí získat hodnotu Current vlastnosti v nyní odstraněné zprávě.

Poznámka

Pokud vytvoříte instanci MessageQueue s MessageQueue.DenySharedReceive nastavenou na true, žádná jiná aplikace nemůže upravovat zprávy v enumerátoru, dokud máte připojení k frontě.

Vlastnosti

Current	Získá proud Message , na který odkazuje tento enumerátor.
CursorHandle	Získá nativní popisovač kurzoru služby Řízení front zpráv používaný k procházení zpráv ve frontě.

Metody

Close()	Uvolní prostředky přidružené k enumerátoru.
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy sloužící ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
Dispose()	Uvolní všechny prostředky používané nástrojem MessageEnumerator.
Dispose(Boolean)	Uvolní nespravované prostředky používané nástrojem MessageEnumerator a volitelně uvolní spravované prostředky.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Finalize()	Toto rozhraní API podporuje produktovou infrastrukturu a není určené k použití přímo z uživatelského kódu. Uvolní prostředky, které obsahuje enumerátor.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte aktuální životnost objektu služby, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá životnost objektu služby, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
MoveNext()	Posune enumerátor na další zprávu ve frontě, pokud je aktuálně k dispozici.
MoveNext(TimeSpan)	Posune enumerátor na další zprávu ve frontě. Pokud je enumerátor umístěn na konci fronty, počká na MoveNext() dostupnost zprávy nebo vypršení daného časového limitu.
RemoveCurrent()	Odebere aktuální zprávu z transakční nebo neaktuální fronty a vrátí zprávu volající aplikaci. Pro doručení zprávy do fronty není zadaný žádný časový limit.
RemoveCurrent(MessageQueueTransaction)	Odebere aktuální zprávu z transakční fronty a vrátí zprávu volající aplikaci. Pro doručení zprávy do fronty není zadaný žádný časový limit.
RemoveCurrent(MessageQueueTransactionType)	Odebere aktuální zprávu z fronty a vrátí zprávu volající aplikaci. Pro doručení zprávy do fronty není zadaný žádný časový limit.
RemoveCurrent(TimeSpan)	Odebere aktuální zprávu z fronty a vrátí ji volající aplikaci. Pokud existuje zpráva k odebrání, vrátí ji metoda okamžitě. V opačném případě metoda počká na doručení nové zprávy po zadaném časovém limitu.
RemoveCurrent(TimeSpan, MessageQueueTransaction)	Odebere aktuální zprávu z transakční fronty a vrátí zprávu volající aplikaci. Pokud existuje zpráva k odebrání, vrátí ji metoda okamžitě. V opačném případě metoda počká na doručení nové zprávy po zadaném časovém limitu.
RemoveCurrent(TimeSpan, MessageQueueTransactionType)	Odebere aktuální zprávu z fronty a vrátí zprávu volající aplikaci. Pokud existuje zpráva k odebrání, vrátí ji metoda okamžitě. V opačném případě metoda počká na doručení nové zprávy po zadaném časovém limitu.
Reset()	Resetuje aktuální enumerátor tak, aby odkazovat na začátek fronty.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Explicitní implementace rozhraní

IEnumerator.Current

Vrátí hodnotu Message , která odkazuje na zprávu na aktuální pozici kurzoru.

Platí pro