Acknowledgment Enumeration
Definition
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.
Gibt das Ergebnis einer versuchten Nachrichtenübermittlung an.
public enum class Acknowledgmentpublic enum Acknowledgmenttype Acknowledgment = Public Enum Acknowledgment- Vererbung
Felder
| Name | Wert | Beschreibung |
|---|---|---|
| None | 0 | Die Nachricht ist keine Bestätigungsnachricht. |
| ReachQueue | 2 | Eine positive Bestätigung der Ankunft, die angibt, dass die ursprüngliche Nachricht ihre Zielwarteschlange erreicht hat. |
| Receive | 16384 | Eine positive Lesebestätigung, die angibt, dass die ursprüngliche Nachricht von der empfangenden Anwendung empfangen wurde. |
| BadDestinationQueue | 32768 | Eine negative Empfangsbestätigung, die angibt, dass die Zielwarteschlange für die sendende Anwendung nicht verfügbar ist. |
| Purged | 32769 | Eine negative Bestätigung der Ankunft, die angibt, dass die Nachricht gelöscht wurde, bevor sie die Zielwarteschlange erreicht hat. |
| ReachQueueTimeout | 32770 | Eine negative Bestätigung der Ankunft, die angibt, dass die Zeit-zu-Reichweite-Warteschlange oder -zeit-to-beempfangene Zeitgeber abgelaufen ist, bevor die ursprüngliche Nachricht die Zielwarteschlange erreichen konnte. |
| QueueExceedMaximumSize | 32771 | Eine negative Bestätigung zur Ankunft, die angibt, dass die ursprüngliche Nachricht nicht übermittelt wurde, weil ihre Zielwarteschlange voll ist. |
| AccessDenied | 32772 | Eine negative Empfangsbestätigung, die angibt, dass die sendende Anwendung nicht über die erforderlichen Rechte zum Senden einer Nachricht an die Zielwarteschlange verfügt. |
| HopCountExceeded | 32773 | Eine negative Bestätigung der Ankunft, die angibt, dass die Hopanzahl der ursprünglichen Nachricht (was die Anzahl der Zwischenserver angibt) überschritten wurde. Die maximale Hopanzahl, 15, wird von Message Queuing festgelegt und ist unveränderlich. |
| BadSignature | 32774 | Eine bestätigung der negativen Ankunft, die angibt, dass die digitale Signatur der ursprünglichen Nachricht ungültig ist und von Message Queuing nicht authentifiziert werden konnte. |
| BadEncryption | 32775 | Eine negative Bestätigung der Ankunft, die angibt, dass der Zielwarteschleifen-Manager keine private Nachricht entschlüsseln konnte. |
| CouldNotEncrypt | 32776 | Eine negative Bestätigung der Ankunft, die angibt, dass der Quellwarteschlangen-Manager eine private Nachricht nicht verschlüsseln konnte. |
| NotTransactionalQueue | 32777 | Eine negative Empfangsbestätigung, die angibt, dass eine Transaktionsnachricht an eine nicht transaktionsbezogene Warteschlange gesendet wurde. |
| NotTransactionalMessage | 32778 | Eine negative Empfangsbestätigung, die angibt, dass eine nicht transaktionsbezogene Nachricht an eine Transaktionswarteschlange gesendet wurde. |
| QueueDeleted | 49152 | Eine negative Lesebestätigung, die angibt, dass die Warteschlange gelöscht wurde, bevor die Nachricht gelesen werden konnte. |
| QueuePurged | 49153 | Eine negative Lesebestätigung, die angibt, dass die Warteschlange gelöscht wurde, bevor die Nachricht gelesen werden konnte. |
| ReceiveTimeout | 49154 | Eine negative Lesebestätigung, die angibt, dass die ursprüngliche Nachricht nicht von der Warteschlange empfangen wurde, bevor der Zeitgeberto-be-empfangene Zeitgeber abgelaufen ist. |
Beispiele
Im folgenden Codebeispiel wird eine Nachricht gesendet und empfangen, die eine Bestellung an und von einer Warteschlange enthält. Sie fordert eine positive Bestätigung an, wenn die ursprüngliche Nachricht erreicht oder aus der Warteschlange abgerufen wird.
#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 )
{
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;
}
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)
{
Console.WriteLine(e.Message);
}
// Handle other causes of invalid operation exception.
}
}
}
}
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
' 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
' 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
' 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
End Class
Hinweise
Die Acknowledgment Klasse definiert die Arten von Bestätigungsnachrichten, die Message Queuing in der Verwaltungswarteschlange veröffentlicht, und die Bedingungen, die dazu führen, dass eine Bestätigungsnachricht gesendet wird. Anerkennungstypen können allgemein in vier Gruppen unterteilt werden: positive Empfangsbestätigungen, positive Lesebestätigungen, negative Empfangsbestätigungen und negative Lesebestätigungen.
Die der Nachricht zugeordnete Verwaltungswarteschlange wird in der Message.AdministrationQueue Eigenschaft angegeben.
Message Queuing legt die Message.Acknowledgment Eigenschaft auf einen der Acknowledgment Enumerationswerte fest, wenn eine Bestätigungsmeldung erstellt wird. Der Message.Acknowledgment Eigenschaftswert ist in der Regel nur dann sinnvoll, wenn sich die Instanz auf eine vom System gesendete Bestätigungsnachricht bezieht. Das Lesen der Message.Acknowledgment Eigenschaft für eine andere Nachricht als eine Bestätigungsnachricht löst eine Ausnahme aus.
Message Queuing sendet keine Bestätigungsnachricht, es sei denn, die sendende Anwendung fordert dies an. Ihre Anwendung führt diese Anforderung aus, indem Sie den entsprechenden Wert für die Message.AcknowledgeType Eigenschaft festlegen. Message Queuing sendet alle Bestätigungsnachrichten an die Verwaltungswarteschlange, die in der AdministrationQueue Eigenschaft des Originals Messageangegeben ist.
