h2. Creating and Closing Sessions

All of the examples have been written using the Apache Qpid .NEt 0.10 API. The examples use the same skeleton code to initialize the program, create a session, and clean up before exiting:

{code}
using System;
using System.IO;
using System.Text;
using System.Threading;
using org.apache.qpid.client;
using org.apache.qpid.transport;

...

        private static void Main(string[] args)
        {
            string host = args.Length > 0 ? args[0] : "localhost";
            int port = args.Length > 1 ? Convert.ToInt32(args[1]) : 5672;
            Client connection = new Client();
            try
            {
                connection.connect(host, port, "test", "guest", "guest");
                ClientSession session = connection.createSession(50000);

                //--------- Main body of program --------------------------------------------

                connection.close();
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: \n" + e.StackTrace);
            }
        }
...

public class MessageListener : IMessageListener
{
        private readonly ClientSession _session;
        private readonly RangeSet _range = new RangeSet();


First it creates a queue named message_queue, then binds it to the amq.direct exchange using the binding key routing_key.

{code}
//--------- Main body of program --------------------------------------------
// Create a queue named "message_queue", and route all messages whose
// routing key is "routing_key" to this newly created queue.
session.queueDeclare("message_queue");
session.exchangeBind("message_queue", "amq.direct", "routing_key");    
{code}

The queue created by this program continues to exist after the program exits, and any message whose routing key matches the key specified in the binding will be routed to the corresponding queue by the broker. Note that the queue could have been be deleted using the following code: 

{code}
session.queueDelete("message_queue");
{code}

To create a message listener, create a class derived from IMessageListener, and override the messageTransfer method, providing the code that should be executed when a message is received. 

public class MessageListener : IMessageListener
{
  ......
  public void messageTransfer(IMessage m)
  {
  .....
}
{code}

The main body of the program creates a listener for the subscription; attaches the listener to a message queue; and
subscribe to the queue to receive messages from the queue.

{code}
lock (session)
{
  // Create a listener and subscribe it to the queue named "message_queue"
  IMessageListener listener = new MessageListener(session);
  session.attachMessageListener(listener, "message_queue");        public MessageListener(ClientSession session)
        {            
  session.messageSubscribe("message_queue");
  // Receive messages until all messages are received
  _session = session;
        }

        public void messageTransfer(IMessage m)
        {
            Monitor.Wait(session);
}
{code}

The MessageListener's messageTransfer() function is called whenever a message is received. In this example the message is printed and tested to see if it is the final message. Once the final message is received, the messages are acknowledged. 

{code}
BinaryReader reader = new BinaryReader(m.Body, Encoding.UTF8);
            byte[] body = new byte[m.Body.Length - m.Body.Position];
            reader.Read(body, 0, body.Length);
             0, body.Length);
ASCIIEncoding enc = new ASCIIEncoding();
            string message = enc.GetString(body);
            Console.WriteLine("Message: " + message);
            // Add this message to the list of message to be acknowledged 
             be acknowledged 
_range.add(m.Id);       
            if( message.Equals("That's all, folks!") )
{
  // Acknowledge all the received messages 
  _session.messageAccept(_range);     
  lock(_session)
  {
      Monitor.Pulse(_session);
    {
                // Acknowledge all the received messages 
                _session.messageAccept(_range);     
                lock(_session)}
}
{code}

h3. Publishing Messages to a Direct Exchange

The second program in the direct example, Producer.cs, publishes messages to the amq.direct exchange using the routing key routing_key.

First, create a message and set a routing key. The same routing key will be used for each message we send, so you only need to set this property once.
           
{code}
IMessage message = new  {
                    Monitor.Pulse(_session);
                }
            }
        }
    }
}

lock (session)
{
  // Create a listener and subscribe it to the queue named "message_queue"
  IMessageListener listener = new MessageListener(session);
  session.attachMessageListener(listener, "message_queue"Message();
// The routing key is a message property. We will use the same
// routing key for each message, so we'll set this property
// just once. (In most simple cases, there is no need to set
// other message properties.)
message.DeliveryProperties.setRoutingKey("routing_key"); 
{code}

Now send some messages:

{code}
// Asynchronous transfer sends messages as quickly as
// possible without waiting for confirmation.
for (int i = 0; i < 10; i++)
{
  message.clearData();
  message.appendData(Encoding.UTF8.GetBytes("Message " + i));                  
  session.messageTransfer("amq.direct", message);                    
}
{code}

Send a final synchronous message to indicate termination:

{code}
// And send a syncrhonous final message to indicate termination.
message.clearData();
message.appendData(Encoding.UTF8.GetBytes("That's    
  session.messageSubscribe("message_queue");
  // Receive messages until all messages are received
  Monitor.Wait(session);
}all, folks!"));
session.messageTransfer("amq.direct", "routing_key", message); 
session.sync();
{code}

h2. Writing Fanout Applications