GESTION D'UNE MQ SERIES ( MESSAGE QUEUE SERIES ) D'IBM AVEC C#.NET

using System;
using System.IO;
using System.Text;
using IBM.WMQ;

namespace MQManager
{
	/// <summary>
	/// Description résumée de mqp.
	/// </summary>
	public class MQManagerClass
	{
		MQQueueManager queueManager; 
		MQQueue queue; 
		MQMessage queueMessage; 
		MQPutMessageOptions queuePutMessageOptions;
		MQGetMessageOptions queueGetMessageOptions;

		public string QueueName;
		public string QueueManagerName;
		public string ChannelInfo;
		public string transportType,connectionName,channelName;
		public string MSGERROR;



		/// <summary>
		/// Constructeur de la classe MQManagerClass qui contient les attributs de notre MQ
		/// </summary>
		/// <param name="sQueueName"></param>
		/// <param name="sQueueManagerName"></param>
		/// <param name="sChannelInfo"></param>
		public MQManagerClass(string sQueueName,string sQueueManagerName,string sChannelInfo)
		{
			char[] separator = {'/'};
			string[] ChannelParams;

			QueueName			= sQueueName;
			QueueManagerName	= sQueueManagerName;
			ChannelInfo			= sChannelInfo;


			ChannelParams = ChannelInfo.Split( separator );
			channelName = ChannelParams[0];
			transportType = ChannelParams[1];
			connectionName = ChannelParams[2];
		}



		/// <summary>
		/// Connection et renvois un pointeur sur la queue
		/// </summary>
		/// <returns></returns>
		public MQQueueManager ConnectQueue(MQManagerClass mqtest)
		{
			try 
			{ 
 
				//Create a connection to the queue manager 
 
				queueManager = new MQQueueManager(mqtest.QueueManagerName, mqtest.channelName, mqtest.connectionName); 
				return queueManager;
			} 
			catch (MQException ex) 
			{ 
				MSGERROR = ex.ReasonCode +"-"+ ex.Message;
				try 
				{ 
					if (queueManager != null) 
						queueManager.Disconnect(); 
				} 
				catch (MQException mqexp) 
				{ 
					MSGERROR = mqexp.ReasonCode +"-"+ mqexp.Message;
					return null;
				} 
				return null;
			} 
		}



		/// <summary>
		/// determine si on a un accees à la queue et renvoi un objet de la classe MQQueue si oui, sinon null
		/// +spécification des options pour l'accès à la queue
		/// </summary>
		/// <returns></returns>
		public MQQueue MQ_AccessQueue(MQQueueManager queueManager, string Mode)
		{
			int options ;
			if(Mode == "R")
				options = MQC.MQOO_BROWSE + MQC.MQOO_INQUIRE+ MQC.MQOO_FAIL_IF_QUIESCING + MQC.MQOO_INPUT_SHARED; //options d'ouverture de la queue en mode lecture et browse
			else //Mode W
                options = MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING; //option d'écriture

			try
			{
				queue = queueManager.AccessQueue(QueueName, options);
				return queue;
			}
			catch(MQException mqexp)
			{
				MSGERROR = mqexp.ReasonCode +"-"+ mqexp.Message;
				return null;
			}
		}


		/// <summary>
		/// écrire un message dans la file
		/// </summary>
		/// <param name="queue"></param>
		/// <param name="message"></param>
		/// <returns></returns>
		public bool putTheMessageIntoQueue(MQQueue queue, string message)
		{ 
			
			try
			{
				queueMessage = new MQMessage();
				queueMessage.WriteString( message );
				
				queueMessage.Format = MQC.MQFMT_STRING;
				queuePutMessageOptions = new MQPutMessageOptions();
				//queueMessage.MessageId = StringToByteArray(System.Console.ReadLine());
				//ecrire le message dans la queue
				queue.Put( queueMessage, queuePutMessageOptions );
				return true;
				//Console.WriteLine("Success fully entered the message into the queue");
			}
			catch(MQException mqexp)
			{
				MSGERROR = mqexp.ReasonCode +"-"+ mqexp.Message;
				return false;
			} 
		}

		/// <summary>
		/// écrire un message dans la file en spécifiant un identifiant
		/// </summary>
		/// <param name="queue"></param>
		/// <param name="message"></param>
		/// <param name="IdMessage"></param>
		/// <returns></returns>
		public bool putTheMessageIntoQueueWithId(MQQueue queue, string message, string IdMessage)
		{ 
			
			try
			{
				queueMessage = new MQMessage();
				queueMessage.WriteString( message );
				
				queueMessage.Format = MQC.MQFMT_STRING;
				queuePutMessageOptions = new MQPutMessageOptions();
				queueMessage.MessageId = StringToByteArray(IdMessage);
				//ecrire le message dans la queue
				queue.Put( queueMessage, queuePutMessageOptions );
				return true;
				//Console.WriteLine("Success fully entered the message into the queue");
			}
			catch(MQException mqexp)
			{
				MSGERROR = mqexp.ReasonCode +"-"+ mqexp.Message;
				return false;
			} 
		}



		/// <summary>
		/// lecture des messages de la MQ + dépilation, MQ FIFO --> renvoi un string avec (dep= true) pour lecture avec dépilation 
		/// (dep = false) pour lecture sans dépilation
		/// </summary>
		/// <param name="queue"></param>
		/// <param name="queue">dep</param> 
		/// <returns></returns>
		public string GetMessageFromTheQueue(MQQueue queue, bool dep)
		{
			
			queueMessage = new MQMessage();
			queueMessage.Format = MQC.MQFMT_STRING;
			queueGetMessageOptions = new MQGetMessageOptions();
			
			if(!dep)
				queueGetMessageOptions.Options = MQC.MQGMO_WAIT | MQC.MQGMO_BROWSE_FIRST;

			try 
			{
				queue.Get( queueMessage, queueGetMessageOptions );
				// Message recu.
				return queueMessage.ReadString(queueMessage.MessageLength);

			}
			catch (MQException MQExp) 
			{
				// report the error
				MSGERROR = MQExp.ReasonCode +"-"+ MQExp.Message;
				return "";
			}
		}


		/// <summary>
		/// Liste tous les messages d'une file donnée avec ou sans dépilation
		/// </summary>
		/// <param name="queue"></param>
		/// <param name="dep"></param>
		/// <returns></returns>
		public string ListAllMessageFromTheQueue(MQQueue queue, bool dep)
		{
			bool done = false;
			string all_message="";
			
			queueMessage = new MQMessage();
			queueMessage.Format = MQC.MQFMT_STRING;
			queueGetMessageOptions = new MQGetMessageOptions();
			queueGetMessageOptions.Options = MQC.MQGMO_WAIT | MQC.MQGMO_BROWSE_FIRST; 


			do 
			{
				try 
				{
               
					queueMessage.ClearMessage();
					queueMessage.CorrelationId = MQC.MQCI_NONE;
					queueMessage.MessageId = MQC.MQMI_NONE;
				
				
				
					queue.Get(queueMessage, queueGetMessageOptions);

					all_message+= queueMessage.ReadString(queueMessage.MessageLength)+"\n";

					if(dep == true)
					{
						queueGetMessageOptions.Options = MQC.MQGMO_MSG_UNDER_CURSOR;
						queue.Get(queueMessage, queueGetMessageOptions);
					}
					queueGetMessageOptions.Options =  MQC.MQGMO_WAIT | MQC.MQGMO_BROWSE_NEXT ;
				} 
				catch (MQException ex) 
				{
              
					MSGERROR = ex.ReasonCode +"-"+ ex.Message;
					done = true;

				} 
				catch (IOException ex) 
				{
					MSGERROR =  ex.Message;
					done = true;
				}

			} while (!done);

			return all_message;



		}



		/// <summary>
		/// recherche d'un message avec son identifiant , si dep=true on retourne le message est on l'enlève de la pile
		/// </summary>
		/// <param name="IdMessage"></param>
		public string BrowseMessageFromTheQueue(MQQueue queue,byte[] IdMessage, bool dep)
		{
			bool done = false;
			int lengthIdMessage = StringToHex(ByteArrayToString(IdMessage)).Length;
			queueMessage = new MQMessage();
			queueMessage.Format = MQC.MQFMT_STRING;
			queueGetMessageOptions = new MQGetMessageOptions();
			queueGetMessageOptions.Options = MQC.MQGMO_WAIT | MQC.MQGMO_BROWSE_FIRST; 


			do 
			{
				try 
				{
               
					queueMessage.ClearMessage();
					queueMessage.CorrelationId = MQC.MQCI_NONE;
					queueMessage.MessageId = MQC.MQMI_NONE;
 
				
					queue.Get(queueMessage, queueGetMessageOptions);
					String msg = queueMessage.ReadString(queueMessage.MessageLength); 
			
					int lengtMessageIdMQ	=	StringToHex(ByteArrayToString(queueMessage.MessageId)).Length;

					if(StringToHex(ByteArrayToString(queueMessage.MessageId)) == StringToHex(ByteArrayToString(IdMessage)).PadRight(lengtMessageIdMQ,'0'))
					{
						if(dep == true)
						{
							queueGetMessageOptions.Options = MQC.MQGMO_MSG_UNDER_CURSOR;
							queue.Get(queueMessage, queueGetMessageOptions);
						}
						return msg;
					}

					queueGetMessageOptions.Options = MQC.MQGMO_WAIT | MQC.MQGMO_BROWSE_NEXT;
				} 
				catch (MQException ex) 
				{
              
					MSGERROR = ex.ReasonCode +"-"+ ex.Message;
					done = true;
					return "";
				} 
				catch (IOException ex) 
				{
					MSGERROR = ex.Message;
					done = true;
					return "";
				}

			} while (!done);

			return "";



		}

		/// <summary>
		/// Convertir un String en un tableau de bytes
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static byte[] StringToByteArray(string str)
		{
			System.Text.ASCIIEncoding  encoding=new System.Text.ASCIIEncoding();
			return encoding.GetBytes(str);
		}

		/// <summary>
		/// Convertis un tableau de byte en string
		/// </summary>
		/// <param name="dBytes"></param>
		/// <returns></returns>
		public static string ByteArrayToString(byte[] dBytes)
		{
			System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
			return enc.GetString(dBytes);
		}

		
		/// <summary>
		/// Convertir String en Hexa
		/// </summary>
		/// <param name="sChaineAConvertir"></param>
		/// <returns></returns>
		public static string StringToHex(string sChaineAConvertir)
		{

			byte[] bytes = Encoding.ASCII.GetBytes(sChaineAConvertir.ToCharArray());
			

		


			char[] charArray = { 'Ç', 'ü', 'ä', 'Ö', 'ö', 'Ü', 'Ä', 'é' , 'â' , 'à', 'ç', 'ê', 'ë', 'è'};
			int[] charArrayAsciiExt = { 128, 129, 132, 153, 148, 154, 142,130, 131, 133, 135, 136, 137 , 138};

			char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7','8', '9', 'A', 'B', 'C', 'D', 'E', 'F',};
			char[] chars = new char[bytes.Length * 2];


			for (int i = 0; i < bytes.Length; i++) 
			{
				int b = bytes[i];
				
				if(b == 63)//c'est un caractère special avec trème
				{
					for(int j=0;j<charArray.Length;j++)
					{
						if(sChaineAConvertir[i] == charArray[j])
							b = charArrayAsciiExt[j];
					}
				}

				chars[i * 2] = hexDigits[b >> 4];
				chars[i * 2 + 1] = hexDigits[b & 0xF];
			}

			return new string(chars);
		}//StringToHex


	}
}