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