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 der versuchten Übermittlung einer Meldung an.
public enum class Acknowledgmentpublic enum Acknowledgmenttype Acknowledgment = Public Enum Acknowledgment- Vererbung
Felder
| AccessDenied | 32772 | 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 | 32768 | Eine negative Eingangsbestätigung, die angibt, dass die Zielwarteschlange nicht für die sendende Anwendung verfügbar ist. |
| BadEncryption | 32775 | Eine negative Eingangsbestätigung, die angibt, dass der Zielwarteschlangen-Manager eine private Meldung nicht entschlüsseln konnte. |
| BadSignature | 32774 | 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 | 32776 | Eine negative Eingangsbestätigung, die angibt, dass der Quellwarteschlangen-Manager eine private Meldung nicht verschlüsseln konnte. |
| HopCountExceeded | 32773 | 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 von 15 Hops wird von Message Queuing festgelegt und ist unveränderlich. |
| None | 0 | Die Meldung ist keine Bestätigungsmeldung. |
| NotTransactionalMessage | 32778 | Eine negative Eingangsbestätigung, die angibt, dass eine nicht transaktionale Meldung an eine transaktionale Warteschlange gesendet wurde. |
| NotTransactionalQueue | 32777 | Eine negative Eingangsbestätigung, die angibt, dass eine transaktionale Meldung an eine nicht transaktionale Warteschlange gesendet wurde. |
| Purged | 32769 | Eine negative Eingangsbestätigung, die angibt, dass die Meldung vor dem Eingang in die Zielwarteschlange dauerhaft gelöscht wurde. |
| QueueDeleted | 49152 | Eine negative Lesebestätigung, die angibt, dass die Warteschlange gelöscht wurde, bevor die Meldung gelesen werden konnte. |
| QueueExceedMaximumSize | 32771 | Eine negative Eingangsbestätigung, die angibt, dass die ursprüngliche Meldung nicht übermittelt wurde, weil die Zielwarteschlange voll ist. |
| QueuePurged | 49153 | Eine negative Lesebestätigung, die angibt, dass die Warteschlange permanent gelöscht wurde, bevor die Meldung gelesen werden konnte. |
| ReachQueue | 2 | Eine positive Eingangsbestätigung, die angibt, dass die ursprüngliche Meldung in der Zielwarteschlange eingegangen ist. |
| ReachQueueTimeout | 32770 | 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 | 16384 | Eine positive Lesebestätigung, die angibt, dass die ursprüngliche Meldung von der empfangenden Anwendung empfangen wurde. |
| ReceiveTimeout | 49154 | 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. |
Beispiele
Im folgenden Codebeispiel wird eine Nachricht mit einer Bestellung an und aus einer Warteschlange gesendet und empfangen. Es fordert insbesondere eine positive Bestätigung an, wenn die ursprüngliche Nachricht die Warteschlange 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 == 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;
}
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.
}
}
}
}
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 Typen von Bestätigungsmeldungen, die Message Queuing in der Verwaltungswarteschlange postet, und die Bedingungen, die dazu führen, dass eine Bestätigungsnachricht gesendet wird. Bestätigungstypen können grob in vier Gruppen unterteilt werden: positive Eingangsbestätigungen, positive Lesebestätigungen, negative Eingangsbestä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 von Bedeutung, wenn der instance auf eine vom System gesendete Bestätigungsnachricht verweist. Das Lesen der Message.Acknowledgment Eigenschaft für eine andere Nachricht als eine Bestätigungsmeldung löst eine Ausnahme aus.
Message Queuing sendet keine Bestätigungsnachricht, es sei denn, die sendende Anwendung fordert dies an. Ihre Anwendung stellt diese Anforderung, indem sie den entsprechenden Wert für die Message.AcknowledgeType Eigenschaft festlegt. Message Queuing sendet alle Bestätigungsmeldungen an die Verwaltungswarteschlange, die in der AdministrationQueue Eigenschaft des ursprünglichen Messageangegeben ist.
