Receiving Messages in .NET framework

Generate QR Code 2d barcode in .NET framework Receiving Messages

An application can read the messages in a queue by using one of the following two techniques: the Receive method for synchronous retrieval of messages, or the ReceiveCompleted event of the MessageQueue object for asynchronous retrieval of messages. Retrieving a message synchronously is trivial:

Get a reference to the queue. (QUEUE_NAME has been defined previously.)

Dim queue As New MessageQueue(QUEUE_NAME)

Dim m As Message = queue.Receive(New TimeSpan(0, 0, 10))

Dim targetTypes() As Type = {GetType(String)}

m.Formatter = New XmlMessageFormatter(targetTypes)

txtMessage.Text = CStr(m.Body)

Catch ex As Exception Often this is a MessageQueueException caused by a timeout. MsgBox(ex.Message, MsgBoxStyle.Critical) End Try

The formatter being used to retrieve the body of the message BinaryMessageFormatter or XmlMessageFormatter must match the formatter applied when sending the message.

31:

The constructors of these two formatter classes take an array of System.Type objects that represent the types expected in the message s body. (In the previous example, we expect only strings.) The receiver application can discern among different types using the TypeOf operator, as in the following:

Dim targetTypes() As Type = {GetType(String), GetType(DataSet)}

m.Formatter = New XmlMessageFormatter(targetTypes)

txtMessage.Text = CStr(body) Else Display the DataSet as XML. txtMessage.Text = CType(body, DataSet).GetXml End If

The Receive method extracts the message from the queue, and you can t undo its action. Alternatively, you can use the Peek method to get the next message in the queue while leaving it in the queue:

Peek the next message, wait up to 5 seconds. Dim m As Message = queue.Peek(New TimeSpan(0, 0, 5))

You aren t limited to reading messages one at a time. If you expect to find several mes sages in the queue, you can collect all of them more efficiently in one operation by means of the GetAllMessages method:

Dim messages() As Message = queue.GetAllMessages()

Retrieving messages in an asynchronous fashion requires that you set up a handler for the ReceiveCompleted event of a MessageQueue object by using either a WithEvents variable or the AddHandler keyword and then start listening for events by means of the BeginReceive method:

Dim queue As New MessageQueue(Form1.QUEUE_NAME)

queue.BeginReceive()

The handler for the event can access the incoming message by using one of the prop erties of the ReceiveCompletedEventArgs object passed to its second argument:

Private Sub NewMessage(ByVal sender As Object, ByVal e As ReceiveCompletedEventArgs) Dim m As Message = e.Message Dim targetTypes() As Type = {GetType(String)} m.Formatter = New XmlMessageFormatter(targetTypes) Dim body As String = CStr(m.Body) Just display body and label in this demo program. MsgBox(body, MsgBoxStyle.Information, m.Label) Wait for the next message. queue.BeginReceive() End Sub

Part VII:

As the previous routine illustrates, the code in the event handler must call the BeginReceive method to receive subsequent events. (The MessageQueue object also exposes a PeekCompleted event, which you activate with a BeginPeek method.)

MSMQ supports transactional queues, which can take part in two types of transactions: internal transactions and external transactions. Internal transactions are managed directly by MSMQ, are more efficient, and have a simple programming model. External transactions require the presence of MS DTC (or another transaction coordinator), add more overhead, and are more complex. Only external transactions can involve other types of resources, such as databases. (For information about external transactions, read the MSDN documentation.) Regardless of the transition type, MSMQ can guarantee either that all the messages in the transaction are sent (or received), or that none of them is sent (or received). Additionally, MSMQ guarantees that all the messages inside a transaction are received in the same order in which they were sent. The following example shows how you can create a transac tional queue, send a group of messages, and then commit or roll back the transaction: