Acknowledgment-Enumeration

Artikel
08/20/2007

Gibt das Ergebnis der versuchten Übermittlung einer Meldung an.

Namespace: System.Messaging
Assembly: System.Messaging (in system.messaging.dll)

Syntax

'Declaration
Public Enumeration Acknowledgment
'Usage
Dim instance As Acknowledgment

public enum Acknowledgment

public enum class Acknowledgment

public enum Acknowledgment

public enum Acknowledgment

Member

	Membername	Beschreibung
	AccessDenied	Eine negative Eingangsbestätigung, die angibt, dass die sendende Anwendung nicht über die erforderlichen Rechte zum Senden einer Meldung an die Zielwarteschlange verfügt.
	BadDestinationQueue	Eine negative Eingangsbestätigung, die angibt, dass die Zielwarteschlange nicht für die sendende Anwendung verfügbar ist.
	BadEncryption	Eine negative Eingangsbestätigung, die angibt, dass der Zielwarteschlangen-Manager eine private Meldung nicht entschlüsseln konnte.
	BadSignature	Eine negative Eingangsbestätigung, die angibt, dass die digitale Signatur der ursprünglichen Meldung ungültig ist und von Message Queuing nicht authentifiziert werden konnte.
	CouldNotEncrypt	Eine negative Eingangsbestätigung, die angibt, dass der Quellwarteschlangen-Manager eine private Meldung nicht verschlüsseln konnte.
	HopCountExceeded	Eine negative Eingangsbestätigung, die angibt, dass die Anzahl der Hops für die ursprüngliche Meldung (mit der die Anzahl der zwischengeschalteten Server angegeben wird) überschritten wurde. Die maximale Anzahl der Hops (15) wird von Message Queuing festgelegt. Dieser Wert ist unveränderlich.
	None	Die Meldung ist keine Bestätigungsmeldung.
	NotTransactionalMessage	Eine negative Eingangsbestätigung, die angibt, dass eine nicht transaktionale Meldung an eine transaktionale Warteschlange gesendet wurde.
	NotTransactionalQueue	Eine negative Eingangsbestätigung, die angibt, dass eine transaktionale Meldung an eine nicht transaktionale Warteschlange gesendet wurde.
	Purged	Eine negative Eingangsbestätigung, die angibt, dass die Meldung vor dem Eingang in die Zielwarteschlange dauerhaft gelöscht wurde.
	QueueDeleted	Eine negative Lesebestätigung, die angibt, dass die Warteschlange gelöscht wurde, bevor die Meldung gelesen werden konnte.
	QueueExceedMaximumSize	Eine negative Eingangsbestätigung, die angibt, dass die ursprüngliche Meldung nicht übermittelt wurde, weil die Zielwarteschlange voll ist.
	QueuePurged	Eine negative Lesebestätigung, die angibt, dass die Warteschlange permanent gelöscht wurde, bevor die Meldung gelesen werden konnte.
	ReachQueue	Eine positive Eingangsbestätigung, die angibt, dass die ursprüngliche Meldung in der Zielwarteschlange eingegangen ist.
	ReachQueueTimeout	Eine negative Eingangsbestätigung, die angibt, dass das Zeitlimit für den Eingang in der Warteschlange bzw. das Zeitlimit für den Empfang abgelaufen ist, bevor die ursprüngliche Meldung die Zielwarteschlange erreichen konnte.
	Receive	Eine positive Lesebestätigung, die angibt, dass die ursprüngliche Meldung von der empfangenden Anwendung empfangen wurde.
	ReceiveTimeout	Eine negative Lesebestätigung, die angibt, dass die ursprüngliche Meldung von der Warteschlange nicht empfangen werden konnte, bevor ihr Zeitlimit für den Empfang abgelaufen ist.

Hinweise

Die Acknowledgment-Klasse definiert die Typen von Bestätigungsmeldungen, die Message Queuing an die Verwaltungswarteschlange sendet, sowie die Bedingungen, die zum Senden einer Bestätigungsmeldung führen. Bestätigungstypen können in vier Gruppen unterteilt werden: positive Eingangsbestätigungen, positive Lesebestätigungen, negative Eingangsbestätigungen und negative Lesebestätigungen.

Die der Meldung zugeordnete Verwaltungswarteschlange ist in der Message.AdministrationQueue-Eigenschaft angegeben.

Message Queuing legt beim Erstellen einer Bestätigungsmeldung die Message.Acknowledgment-Eigenschaft auf einen der Acknowledgment-Enumerationswerte fest. Der Message.Acknowledgment-Eigenschaftenwert ist i. d. R. nur dann sinnvoll, wenn die Instanz auf eine vom System gesendete Bestätigungsmeldung verweist. Wenn die Message.Acknowledgment-Eigenschaft für eine andere Meldung als eine Bestätigungsmeldung gelesen wird, wird eine Ausnahme ausgelöst.

Message Queuing sendet nur dann eine Bestätigungsmeldung, wenn die sendende Anwendung dies anfordert. Die Anwendung fordert dies an, indem der entsprechende Wert für die Message.AcknowledgeType-Eigenschaft festgelegt wird. Message Queuing sendet alle Bestätigungsmeldungen an die Verwaltungswarteschlange, die in der AdministrationQueue-Eigenschaft der ursprünglichen Message angegeben ist.

Beispiel

Im folgenden Codebeispiel wird eine Meldung an eine Warteschlange gesendet und aus dieser empfangen. Eine positive Bestätigung wird ausdrücklich angefordert, wenn die ursprüngliche Meldung die Warteschlange erreicht oder aus dieser abgerufen wird.

Imports System
Imports System.Messaging


' Provides a container class for the example.

Public Class MyNewQueue
   
   

   ' Provides an entry point into the application.       
   ' This example sends and receives a message from
   ' a queue.
      
   Public Shared Sub Main()
         ' Create a new instance of the class.
         Dim myNewQueue As New MyNewQueue()
         
         ' Create new queues.
         CreateQueue(".\myQueue")
         CreateQueue(".\myAdministrationQueue")
         
         ' Send messages to a queue.
         myNewQueue.SendMessage()
         
         ' Receive messages from a queue.
         Dim messageId As String = myNewQueue.ReceiveMessage()
         
         ' Receive acknowledgment message.
         If Not (messageId Is Nothing) Then
            myNewQueue.ReceiveAcknowledgment(messageId, ".\myAdministrationQueue")
         End If
         
         Return
   End Sub 'Main
      
      
      ' Creates a new queue.

   Public Shared Sub CreateQueue(queuePath As String)
         Try
            If Not MessageQueue.Exists(queuePath) Then
               MessageQueue.Create(queuePath)
            Else
               Console.WriteLine((queuePath + " already exists."))
            End If
         Catch e As MessageQueueException
            Console.WriteLine(e.Message)
         End Try
   End Sub 'CreateQueue
       
      
      
 
      ' Sends a string message to a queue.
 
   Public Sub SendMessage()
         
         ' Connect to a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         ' Create a new message.
         Dim myMessage As New Message("Original Message")
         
         myMessage.AdministrationQueue = New MessageQueue(".\myAdministrationQueue")
         myMessage.AcknowledgeType = AcknowledgeTypes.PositiveReceive Or AcknowledgeTypes.PositiveArrival
         
         ' Send the Order to the queue.
         myQueue.Send(myMessage)
         
         Return
   End Sub 'SendMessage
      
      
      
 
      ' Receives a message containing an Order.
 
   Public Function ReceiveMessage() As String
         ' Connect to the a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         myQueue.MessageReadPropertyFilter.CorrelationId = True
         
         
         ' Set the formatter to indicate body contains an Order.
         myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(String)})
         
         Dim returnString As String = Nothing
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            
            
            ' Display message information.
            Console.WriteLine("____________________________________________")
            Console.WriteLine("Original message information--")
            Console.WriteLine(("Body: " + myMessage.Body.ToString()))
            Console.WriteLine(("Id: " + myMessage.Id.ToString()))
            Console.WriteLine("____________________________________________")
            
            returnString = myMessage.Id
         
         
                  
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return returnString
   End Function 'ReceiveMessage
      
      
 
      ' Receives a message containing an Order.
 
   Public Sub ReceiveAcknowledgment(messageId As String, queuePath As String)
         Dim found As Boolean = False
         Dim queue As New MessageQueue(queuePath)
         queue.MessageReadPropertyFilter.CorrelationId = True
         queue.MessageReadPropertyFilter.Acknowledgment = True
         
         Try
            While Not (queue.PeekByCorrelationId(messageId) Is Nothing)
               Dim myAcknowledgmentMessage As Message = queue.ReceiveByCorrelationId(messageId)
               
               ' Output acknowledgment message information. The correlation Id is identical
               ' to the id of the original message.
               Console.WriteLine("Acknowledgment Message Information--")
               Console.WriteLine(("Correlation Id: " + myAcknowledgmentMessage.CorrelationId.ToString()))
               Console.WriteLine(("Id: " + myAcknowledgmentMessage.Id.ToString()))
               Console.WriteLine(("Acknowledgment Type: " + myAcknowledgmentMessage.Acknowledgment.ToString()))
               Console.WriteLine("____________________________________________")
               
               found = True
            End While
         Catch e As InvalidOperationException
            ' This exception would be thrown if there is no (further) acknowledgment message
            ' with the specified correlation Id. Only output a message if there are no messages;
            ' not if the loop has found at least one.
            If found = False Then
               Console.WriteLine(e.Message)
            End If
         End Try 
   End Sub 'ReceiveAcknowledgment ' Handle other causes of invalid operation exception.
 End Class 'MyNewQueue

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 sends and receives a message from
        // a queue.
        //**************************************************

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

            // Create new queues.
            CreateQueue(".\\myQueue");
            CreateQueue(".\\myAdministrationQueue");

            // Send messages to a queue.
            myNewQueue.SendMessage();

            // Receive messages from a queue.
            string messageId = myNewQueue.ReceiveMessage(); 

            // Receive acknowledgment message.
            if(messageId != null)
            {
                myNewQueue.ReceiveAcknowledgment(messageId, ".\\myAdministrationQueue");
            }

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try 
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
            
        }


        //**************************************************
        // Sends a string message to a queue.
        //**************************************************
        
        public void SendMessage()
        {

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Create a new message.
            Message myMessage = new Message("Original Message"); 

            myMessage.AdministrationQueue = new MessageQueue(".\\myAdministrationQueue");
            myMessage.AcknowledgeType = AcknowledgeTypes.PositiveReceive | AcknowledgeTypes.PositiveArrival;

            // Send the Order to the queue.
            myQueue.Send(myMessage);

            return;
        }


        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  string ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            myQueue.MessageReadPropertyFilter.CorrelationId = true;


            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(string)});

            string returnString = null;
            
            try
            {
                // Receive and format the message. 
                Message myMessage = myQueue.Receive(); 


                // Display message information.
                Console.WriteLine("____________________________________________");
                Console.WriteLine("Original message information--");
                Console.WriteLine("Body: " +myMessage.Body.ToString());
                Console.WriteLine("Id: " + myMessage.Id.ToString());
                Console.WriteLine("____________________________________________");

                returnString =  myMessage.Id;
                
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return returnString;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public void ReceiveAcknowledgment(string messageId, string queuePath)
        {
            bool found = false;
            MessageQueue queue = new MessageQueue(queuePath);
            queue.MessageReadPropertyFilter.CorrelationId = true;
            queue.MessageReadPropertyFilter.Acknowledgment = true;

            try
            {
                while(queue.PeekByCorrelationId(messageId) != null)
                {
                    Message myAcknowledgmentMessage = queue.ReceiveByCorrelationId(messageId);
            
                    // Output acknowledgment message information. The correlation Id is identical
                    // to the id of the original message.
                    Console.WriteLine("Acknowledgment Message Information--");
                    Console.WriteLine("Correlation Id: " + myAcknowledgmentMessage.CorrelationId.ToString());
                    Console.WriteLine("Id: " + myAcknowledgmentMessage.Id.ToString());
                    Console.WriteLine("Acknowledgment Type: " + myAcknowledgmentMessage.Acknowledgment.ToString());
                    Console.WriteLine("____________________________________________");

                    found = true;
                }
            }
            catch (InvalidOperationException e)
            { 
                // This exception would be thrown if there is no (further) acknowledgment message
                // with the specified correlation Id. Only output a message if there are no messages;
                // not if the loop has found at least one.
                if(found == false)
                {   
                    Console.WriteLine(e.Message);
                }

                // Handle other causes of invalid operation exception.
            }

        }
    }
}

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   void SendMessage()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Create a new message.
      Message^ myMessage = gcnew Message( "Original Message" );
      myMessage->AdministrationQueue = gcnew MessageQueue( ".\\myAdministrationQueue" );
      myMessage->AcknowledgeType = (AcknowledgeTypes)(AcknowledgeTypes::PositiveReceive | AcknowledgeTypes::PositiveArrival);

      // Send the Order to the queue.
      myQueue->Send( myMessage );
      return;
   }

   String^ ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->MessageReadPropertyFilter->CorrelationId = true;
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      String^ returnString = nullptr;
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();

         // Display message information.
         Console::WriteLine( "____________________________________________" );
         Console::WriteLine( "Original message information--" );
         Console::WriteLine( "Body: {0}", myMessage->Body );
         Console::WriteLine( "Id: {0}", myMessage->Id );
         Console::WriteLine( "____________________________________________" );
         returnString = myMessage->Id;
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return returnString;
   }

   void ReceiveAcknowledgment( String^ messageId, String^ queuePath )
   {
      bool found = false;
      MessageQueue^ queue = gcnew MessageQueue( queuePath );
      queue->MessageReadPropertyFilter->CorrelationId = true;
      queue->MessageReadPropertyFilter->Acknowledgment = true;
      try
      {
         while ( queue->PeekByCorrelationId( messageId ) != nullptr )
         {
            Message^ myAcknowledgmentMessage = queue->ReceiveByCorrelationId( messageId );

            // Output acknowledgment message information. The correlation Id is identical
            // to the id of the original message.
            Console::WriteLine( "Acknowledgment Message Information--" );
            Console::WriteLine( "Correlation Id: {0}", myAcknowledgmentMessage->CorrelationId );
            Console::WriteLine( "Id: {0}", myAcknowledgmentMessage->Id );
            Console::WriteLine( "Acknowledgment Type: {0}", myAcknowledgmentMessage->Acknowledgment );
            Console::WriteLine( "____________________________________________" );
            found = true;
         }
      }
      catch ( InvalidOperationException^ e ) 
      {
         // This exception would be thrown if there is no (further) acknowledgment message
         // with the specified correlation Id. Only output a message if there are no messages;
         // not if the loop has found at least one.
         if ( found == false )
         {
            Console::WriteLine( e->Message );
         }

         // Handle other causes of invalid operation exception.
      }

   }

};

int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Create new queues.
   MyNewQueue::CreateQueue( ".\\myQueue" );
   MyNewQueue::CreateQueue( ".\\myAdministrationQueue" );

   // Send messages to a queue.
   myNewQueue->SendMessage();

   // Receive messages from a queue.
   String^ messageId = myNewQueue->ReceiveMessage();

   // Receive acknowledgment message.
   if ( messageId != nullptr )
   {
      myNewQueue->ReceiveAcknowledgment( messageId, ".\\myAdministrationQueue" );
   }

   return 0;
}

package MyProject;

import System.*;
import System.Messaging.*;

/// <summary>
/// Provides a container class for the example.
/// </summary>
public class MyNewQueue
{
    //**************************************************
    // Provides an entry point into the application.
    //         
    // This example sends and receives a message from
    // a queue.
    //**************************************************
    public static void main(String[] args)
    {
        // Create a new instance of the class.
        MyNewQueue myNewQueue = new MyNewQueue();

        // Create new queues.
        CreateQueue(".\\myQueue");
        CreateQueue(".\\myAdministrationQueue");

        // Send messages to a queue.
        myNewQueue.SendMessage();

        // Receive messages from a queue.
        String messageId = myNewQueue.ReceiveMessage();

        // Receive acknowledgment message.
        if (messageId != null) {
            myNewQueue.ReceiveAcknowledgment(messageId, 
                ".\\myAdministrationQueue");
        }
        return;
    } //main

    //**************************************************
    // Creates a new queue.
    //**************************************************
    public static void CreateQueue(String queuePath)
    {
        try {
            if (!(MessageQueue.Exists(queuePath))) {
                MessageQueue.Create(queuePath);
            }
            else {
                Console.WriteLine(queuePath + " already exists.");
            }
        }
        catch (MessageQueueException e) {
            Console.WriteLine(e.get_Message());
        }
    } //CreateQueue

    //**************************************************
    // Sends a string message to a queue.
    //**************************************************
    public void SendMessage()
    {
        // Connect to a queue on the local computer.
        MessageQueue myQueue = new MessageQueue(".\\myQueue");

        // Create a new message.
        Message myMessage = new Message("Original Message");
        myMessage.set_AdministrationQueue(
            new MessageQueue(".\\myAdministrationQueue"));
        myMessage.set_AcknowledgeType(AcknowledgeTypes.PositiveReceive 
            | AcknowledgeTypes.PositiveArrival);

        // Send the Order to the queue.
        myQueue.Send(myMessage);
        return;
    } //SendMessage

    //**************************************************
    // Receives a message containing an Order.
    //**************************************************
    public String ReceiveMessage()
    {
        // Connect to the a queue on the local computer.
        MessageQueue myQueue = new MessageQueue(".\\myQueue");

        myQueue.get_MessageReadPropertyFilter().set_CorrelationId(true);

        // Set the formatter to indicate body contains an Order.
        myQueue.set_Formatter(new XmlMessageFormatter(
            new Type[] { String.class.ToType() }));

        String returnString = null;
        try {
            // Receive and format the message. 
            Message myMessage = myQueue.Receive();

            // Display message information.
            Console.WriteLine("____________________________________________");
            Console.WriteLine("Original message information--");
            Console.WriteLine("Body: " + myMessage.get_Body().ToString());
            Console.WriteLine("Id: " + myMessage.get_Id().ToString());
            Console.WriteLine("____________________________________________");

            returnString = myMessage.get_Id();
        }
        catch (MessageQueueException exp) {
            // Handle Message Queuing exceptions.
        }
        // Handle invalid serialization format.
        catch (InvalidOperationException e) {
            Console.WriteLine(e.get_Message());
        }
        // Catch other exceptions as necessary.
        return returnString;
    } //ReceiveMessage

    //**************************************************
    // Receives a message containing an Order.
    //**************************************************
    public void ReceiveAcknowledgment(String messageId, String queuePath)
    {
        boolean found = false;
        MessageQueue queue = new MessageQueue(queuePath);
        queue.get_MessageReadPropertyFilter().set_CorrelationId(true);
        queue.get_MessageReadPropertyFilter().set_Acknowledgment(true);
        try {
            while (queue.PeekByCorrelationId(messageId) != null) {
                Message myAcknowledgmentMessage 
                    = queue.ReceiveByCorrelationId(messageId);

                // Output acknowledgment message information. 
                // The correlation Id is identical
                // to the id of the original message.
                Console.WriteLine("Acknowledgment Message Information--");
                Console.WriteLine("Correlation Id: " 
                    + myAcknowledgmentMessage.get_CorrelationId().ToString());
                Console.WriteLine("Id: " 
                    + myAcknowledgmentMessage.get_Id().ToString());
                Console.WriteLine("Acknowledgment Type: " 
                    + myAcknowledgmentMessage.get_Acknowledgment().ToString());
                Console.WriteLine("____________________________________________");

                found = true;
            }
        }
        catch (InvalidOperationException e) {
            // This exception would be thrown if there is no (further) 
            // acknowledgment message with the specified correlation Id. 
            // Only output a message if there are no messages;
            // not if the loop has found at least one.
            if (found == false) {
                Console.WriteLine(e.get_Message());
            }
            // Handle other causes of invalid operation exception.
        }
    } //ReceiveAcknowledgment
} //MyNewQueue

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

Acknowledgment-Enumeration

Syntax

Member

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen