Vous êtes sur la page 1sur 24

Le MSMQ

Version 1.0

Pierre-Franck Chauvet
2 [Le MSMQ] [Date : 10/10/09]

Sommaire

1 Introduction ..................................................................................................................................... 3
2 Le Concept ....................................................................................................................................... 5
2.1 Les messages ........................................................................................................................... 5
2.2 Les files d’attentes ................................................................................................................... 5
2.3 WorkGroup .............................................................................................................................. 7
2.4 Active Directory ....................................................................................................................... 7
3 Utilisation ........................................................................................................................................ 9
3.1 Activer le service ..................................................................................................................... 9
3.2 Dans le code .......................................................................................................................... 12
3.2.1 Création d’une file d’attente privée .............................................................................. 13
3.2.2 Déclaration de la file d’attente ...................................................................................... 13
3.2.3 Création de message ..................................................................................................... 13
3.2.4 Envoi d’un message ....................................................................................................... 14
3.2.5 Réception d’un message ............................................................................................... 15
3.2.6 Répondre à un message ................................................................................................ 16
3.3 Exemple ................................................................................................................................. 16
4 Conclusion ..................................................................................................................................... 24

Dotnet France Association


3 [Le MSMQ] [Date : 10/10/09]

1 Introduction
Le MSMQ (MicroSoft Message Queuing) est la technologie proposée par Microsoft pour gérer
les files d’attente en programmation interprocessus. Cette technologie est le MOM (Message
Oriented Middleware) par Microsoft ; c’est l’infrastructure qui permet un couplage d’application
grâce à des files d’attente et des messages.

Cette technologie est implantée depuis Windows 95 avec MSMQ v1.0, v2.0 sur Windows 2000,
v3.0 sur Windows X et Serveur 2003, actuellement la v4.0 pour Windows Vista, 7 et Server2008. Les
files d’attente de messages sont des liaisons asynchrones entre plusieurs processus.

Dans ce chapitre, nous allons étudier les files d’attente MSMQ Microsoft et comment interagir
avec dans nos programme .NET. L’utilisation du message queuing est asynchrone : en effet le client
n’attend pas la réponse au message pour continuer sur la suite du programme, ce qui apporte tous
les avantages exposés dans le cours précédant (voir le chapitre sur Le .NET Remoting One-Way et
Asynchrone). Mais le Remoting asynchrone impliquait le fait que le client et le serveur s’exécutent en
même temps. Ici, MSMQ va plus loin car il permet en plus de garder les messages sur le Système
d’exploitation même si le programme n’est pas lancé. Du coup, le Message Queuing peut s’exécuter
dans un environnement déconnecté. Ainsi un programme qui n’aura pas besoin d’une connexion
continue au serveur pourra créer des messages à chaque demande auprès du serveur, et les envoyer
une fois le serveur connecté. De même, si les calculs serveur prennent du temps et que le client se
déconnecte, il sera toujours possible de récupérer les résultats lors de la prochaine connexion.

L’exemple le plus simple est de le comparer à un système de messagerie électronique (e-mail).


En effet, on peut assimiler les messages e-mail aux messages MSMQ, les boîtes e-mail aux files
d’attente MSMQ, et les utilisateurs aux applications. Attention, ceci est un exemple général, en effet
les services de messagerie électronique sont centralisés et n’utilisent pas plusieurs chemins d’accès
tels que MSMQ, de plus l’un des principes de MSMQ est d’enlever les messages reçus de la file
d’attente (notion qui peut être modifiée), dans les messageries e-mail, l’utilisateur choisi ce qu’il fait
de ses mails (archivage, suppression).

Dotnet France Association


4 [Le MSMQ] [Date : 10/10/09]

Dotnet France Association


5 [Le MSMQ] [Date : 10/10/09]

2 Le Concept
Le concept du MSMQ est l’échange de messages entre plusieurs parties (processus). Pour cela
on rajoute une application tiers (où on l’intègre au client/serveur) qui gérera la communication entre
le client et le serveur. Il existe plusieurs types de messages ainsi que différentes files d’attentes pour
gérer toutes les possibilités.

2.1 Les messages


La bonne compréhension des messages ett essentielle. Ils sont donc envoyés aux files
d’attente et comportent plusieurs paramètres tels que :

Paramètre Description
Body Corps du message comprenant les données.
Label Ou étiquette du message qui peut correspondre à l’objet sur un
mail.
ID Permet d’identifier le message.
AdministrationQueue Obtient ou définit la file d’attente d’administration.
DestinationQueue Obtient la file d’attente de destination.
Formater Obtient ou définit le formateur utilisé pour sérialiser et
désérialiser l’objet.
Priority Obtient ou définit la priorité du message.
ReponseQueue Obtient ou définit la file d’attente de réponse du message.
TimeToBeReceived Obtient ou définit le délai d’attente pour la réception du message
à partir de la file d’attente de destination.
TimeToReachQueue Obtient ou définit le délai accordé à un message pour atteindre la
file d’attente.
UseJournal Obtient ou définit si on utilise une file d’attente journal avec copie
des messages.

De plus, il en existe différents types :

 Message dit normal, envoyé par l’application à une file d’attente.


 Message d’accusé de réception, qui indique l’état d’un message dit normal, ils sont
envoyés à la file d’attente d’administration.
 Message de réponse, est envoyé lorsque l’expéditeur attend une certaine réponse.
 Message de rapport, qui est généré en interne par Message Queuing. C’est un
message test.

2.2 Les files d’attentes


Une file d’attente est un réservoir à messages ; tout message reçu ou stocké sera
obligatoirement compris dans une file d’attente. On retrouve ces files d’attente dans le répertoire
« C:\Windows\System32\msmq\storage ». Il existe différents types de files d’attente disponibles
avec MSMQ.

Type de file d’attente Description


Publique Est publiée dans active directory. Avec des files publiques il n’y a
pas obligation de créer
Privée N’est pas publiée dans Active Directory. Ces files d’attente
peuvent être consultées avec le chemin d’accès complet
Journal Est utilisée pour conserver des copies des messages après envoi
ou réception.

Dotnet France Association


6 [Le MSMQ] [Date : 10/10/09]

Dead-letter Est la file d’attente où finissent les messages erronés. En effet


message queuing dispose d’une gestion des erreurs
Administration Peut être paramétrée pour recevoir les accusés de réception et
gérer ainsi les différents échanges. Reçoit les messages de type
« Acknowledgement »
Réponse Peut être paramétrée pour recevoir les réponses de certains
messages.
Rapport Files qui peut être créée en changeant le type d’une file d’attente
privée ou publique
Système Files d’attente privées, elles sont utilisées pour des messages
d’administration, d’archivage de notification ou pour garantir
l’ordre correct des messages transactionnels.

La dénomination des files d’attente peut s’effectuer de deux façons différentes:

 Le nom de chemin : assez similaire à une adresse de répertoire partagée, il peut être
utilisé le plus souvent pour des files d’attente local (le nom de la machine est donc
remplacé par un simple point)
« NomDeLaMachine\NomDeLaQueuePublique »
Exemple d’une file d’attente privée local
« .\Private$\NomDeLaQueuePrivée »
 Le nom de format : à privilégier pour de la programmation, le nom de format existe
sous plusieurs formes. Le plus courant est celui direct qui permet d’accéder à des files
d’attentes aussi bien publiques que privées sans passer par le service Active directory.
« DIRECT=AdresseDeLaMachine\NomDeLaQueuePublique »
Pour spécifier l’adresse de la machine on peut utiliser les techniques suivantes :
 OS : Il permet de spécifier le nom de la machine directement
« DIRECT=OS :PFCH5-Laptop\$Private\NomDeLaQueuePrivée »
 TCP : Il permet de spécifier l’IP de la machine
« DIRECT=TCP :192.168.0.5\$Private\NomDeLaQueuePrivée »
 http : permet de spécifier l’adresse URL.
Remarque : pour le protocole http (et seulement ce protocole) il est possible
d’utiliser des slashes ou des antislashes.
« DIRECT=http://AdresseURL/msmq/NomDeLaQueuePublique »
« DIRECT=http://AdresseURL\msmq\NomDeLaQueuePublique »

Il existe aussi le format public qui permet de référencer une file d’attente publique en
utilisant le routage interne à MSMQ : « PUBLIC= GUIDDeLaQueuePublique »

Le format privé dont le fonctionnement est assez similaire sauf qu’ici il faut spécifier le
GUID de la machine et non de la queue (les queues privée n’utilisant pas l’Active
Directory)
« PRIVATE=GUIDDeLaMachine\NomDeLaQueue »

Enfin il est possible d’utiliser plusieurs files d’attente à l’aide d’une virgule
« DIRECT=OS :PFCH5-
Laptop\NomDeLaQueuePublique,DIRECT =TCP :192.168.0.5\Private$\ NomDeLaQueue
Privée »

Dotnet France Association


7 [Le MSMQ] [Date : 10/10/09]

Type de file d’attente Syntaxe


Publique NomDelaMachine\NomDeLaQueuePublique
Privée NomDelaMachine\Private$\NomDeLaQueuePrivée
Journal NomDelaMachine\NomDelaQueue\Journal$
Dead-letter NomDeLaMAchine\Deadletter$

2.3 WorkGroup
L’utilisation de MSMQ peut se faire selon 3 modes distincts :

 Domaines d’application (Windows Serveur) : utilise l’active directory.


 WorkGroup : utilisé dans les domaines n’utilisant pas l’active directory
 Offline : utilisé pour des machines en mode domaine d’application mais n’étant pas
connectées.

Chacun de ces modes présente des particularités et restrictions propres. Nos ordinateurs utiliseront
la plupart du temps le mode WorkGroup ce qui implique donc les contraintes suivantes :

 Une liaison directe entre l’expéditeur et le destinataire (due à une impossibilité d’utiliser les
serveurs de routage).
 les files d’attente privées ne sont créées et gérées qu’en local et les files d’attente publique
sont impossibles d’accès (il est néanmoins possible d’accéder à une file d’attente privée avec
une liaison directe : voir première contrainte).
 obligation d’utiliser des certificats externes pour l’envoi de message avec authentification
 l’encryption des messages est impossible
 ainsi que l’envoi des messages vers une file d’attente étrangère (n’utilisant pas le MSMQ) ou
vers des connecteurs.

2.4 Active Directory


Active Directory est la mise en en œuvre des services d’annuaires dans un environnement
Windows. Il permet des services de centralisation et d’authentification sur un réseau utilisant
Windows. Ainsi les différents postes Windows, Imprimantes ou autres machines réseau sont
répertoriées. De plus, Active Directory prend aussi en compte les Comptes utilisateurs, et dossier
partagés.

Mis en place avec Windows Server 2000, il équipe depuis Windows 2003 et 2008. Il comprend les
domaines classés selon une arborescence :

 La Forêt représente l’ensemble de tous les sous domaines Active Directory (et regroupe les
Arbres).
 L’Arbre représente l’ensemble des conteneurs et feuilles de l’Active Directory.
 Domaine représente un conteneur ou une feuille.

Dotnet France Association


8 [Le MSMQ] [Date : 10/10/09]

Dans un environnement de domaine, des objets Message Queuing sont créés dans l’Active Directory,
pour tous types d’ordinateurs utilisant Message Queuing (sauf un client dépendant). Ces objets
contiennent des informations Message Queuing.

Dotnet France Association


9 [Le MSMQ] [Date : 10/10/09]

3 Utilisation

3.1 Activer le service


Avant de commencer à examiner et programmer des applications MSMQ, il est impératif,
d’activer le service dans votre Windows. En effet, une fois le service mis en place, il vous sera
possible d’utiliser toutes les possibilités MSMQ citées avant. Pour cela, rendez vous dans le panneau
de configuration de votre Windows (ici Windows 7), puis dans la Catégorie « Programmes », «
Programmes et fonctionnalités », « Activer ou désactiver des fonctionnalités Windows ». Ici vous
pourrez trouver une case « Serveur de mise en file d’attente Microsoft (MSMQ) » qu’il suffira de
cocher.

Dotnet France Association


10 [Le MSMQ] [Date : 10/10/09]

Remarque : il est possible de dérouler le menu est de trouver des fonctionnalités supplémentaires
qui ne seront pas utilisées dans ce cours.

Une fois ce service coché, on peut le retrouver dans le panneau « gestion de l’ordinateur »
(accessible depuis le menu démarrer avec un clic droit sur « Ordinateur » puis « Gérer » , ou en
tapant « MMC » dans le champs de recherche, puis fichier, ouvrir « compmgmt.msc ».

Dotnet France Association


11 [Le MSMQ] [Date : 10/10/09]

D’ici, il vous sera possible de gérer les file d’attentes à votre convenance, les créer ou voir les
contenus, ainsi que de leur associer des triggers (déclencheurs).

Dotnet France Association


12 [Le MSMQ] [Date : 10/10/09]

3.2 Dans le code


Il est possible d’utiliser le Message Queuing dans les programmes .NET. Pour cela il est
essentiel d’ajouter la référence « System.Messaging » qui donnera accès à tous les outils de
gestion des messages.

Il faut ensuite ajouter le using (Import).

//C#
using System.Messaging;

‘VB.NET
Imports System.Messaging

On trouve ensuite dans cette bibliothèque beaucoup de méthodes telles que les suivantes :

Type de file d’attente Description


Create Permet de créer une file d’attente avec un chemin spécifié.
Existe Permet de vérifier l’existence ou non d’une file d’attente avec le
chemin spécifié.
Delete Permet de supprimer une file d’attente.
Send Permet l’envoi d’un objet dans une file d’attente.
Receive Permet la réception d’un message et donc la suppression de
l’objet de la file d’attente
Peek Permet la réception d’un message de la file d’attente sans le
supprimer de celle-ci.
Purge Permet de supprimer tous les messages de la file d’attente
ReceiveById Permet de recevoir le message correspondant à l’Id donné
PeekById Permet de recevoir le message correspondant à l’Id sans le
supprimer de la file d’attente
BeginReceive Permet de lancer une opération de réception asynchrone d’un
(BeginPeek) message de la file d’attente, le supprime de celle ci et avertit le
gestionnaire d’évènement une fois terminé (sans le supprimer
pour BeginPeek)

Dotnet France Association


13 [Le MSMQ] [Date : 10/10/09]

EndReceive Permet de terminer la réception asynchrone spécifiée.


(EndPeek)
GetAllMessages Permet de retourner tous les messages de la liste d’attente
GetPrivateQueueBy Permet de récupérer les files d’attente privées sur l’ordinateur
Machine spécifié.
GetPublicQueue Permet de récupérer les files d’attente publiques sur le réseau.
GetPublicQueueByM Permet de récupérer les files d’attente publiques sur l’ordinateur
achine spécifié.

3.2.1 Création d’une file d’attente privée


Pour créer une file d’attente privée, il faut au préalable vérifier si elle existe déjà ; si ce n’est le
cas il convient de la créer.

//C#
if (!MessageQueue.Exists(@".\Private$\MaFilePrivee"))
{
MessageQueue.Create(@".\Private$\MaFilePrivee");
}
‘VB.NET
If Not MessageQueue.Exists(".\Private$\MaFilePrivee") Then
MessageQueue.Create(".\Private$\MaFillePrivee")
End If

Ici, on teste l’existence de la file d’attente privée « MaFilePrivee » avant de la créer. En se


rendant dans l’onglet service puis message queuing et enfin file d’attente privée. Dans l’onglet
« MaFilePrivee », on retrouve « Message de file d’attente » qui est la file d’attente pour les messages
dit normaux, puis « Message journal » qui reçoit les messages journaux.

Remarque : Ici la file créée est privée pour la création d’une file d’attente publique il suffira
simplement d’enlever le « Private$ » et donc « .\MaFilePublique ».

3.2.2 Déclaration de la file d’attente


Avant de commencer à utiliser la file d’attente, il faut la déclarer. En effet, cette déclaration
permet d’utiliser simplement toutes les méthodes et propriétés pour chaque file d’attente. Il faut
donner en paramètre le chemin d’accès vers notre file d’attente préalablement créée.

//C#
MessageQ1 = new MessageQueue(@".\Private$\MaFilePrivee");

‘VB.NET
MessageQ1 = New MessageQueue(".\Private$\MaFilePrivee")

3.2.3 Création de message


Avant d’envisager l’envoi d’un message, il faut le créer. Pour cela il suffit d’initialiser le
message et de remplir certains champs tels que Body, Label ou encore ReponseQueue.

Dotnet France Association


14 [Le MSMQ] [Date : 10/10/09]

//C#
System.Messaging.Message msg = new System.Messaging.Message();
msg.Body = "Corps de mon message";
msg.Label = "Entete de mon message";
msg.ResponseQueue = new MessageQueue(@".\private$\MaFileReponse");

‘VB.NET
Dim msg As New System.Messaging.Message()
msg.Body = "Corps de mon message"
msg.Label = "Entete de mon message"
msg.ResponseQueue = New MessageQueue(".\private$\MaFileReponse")

Ici notre message « msgsend » a un string comme corps, « Entete de mon message » comme Label et
comme reponseQueue, la file d’attente privée « reponseq »

Remarque : dès cet exemple, j’utilise l’Espace de nom complet, car il existe d’autres classes message
qui pourraient dérouter l’ordinateur lors de la compilation (c’est notamment le cas en Windows
Form).

3.2.4 Envoi d’un message


Pour l’envoi d’un message, rien de plus simple : il suffit d’utiliser la méthode Send(…) comme
vu précédemment. Il existe plusieurs surcharges à cette méthode. On en dénombre cinq, celles-ci
diffèrent au niveau des paramètres.

Type de Send Description


Send(Object) Envoi d’un objet à une file d’attente non transactionnelle
Send (Object, Envoi d’un objet à une file non d’attente transactionnelle et avec
String) une étiquette (Label).
Send (Object, Envoi d’un objet à une file d’attente transactionnelle.
MessageQueueTrans
action)
Send (Object, Envoi d’un objet à une file d’attente transactionnelle et avec une
String, étiquette (Label).
MessageQueueTrans
action)
Send (Object, Envoi d’un objet à une file d’attente.
MessageQueueTrans
actionType)
Send (Object, Envoi d’un objet à une file d’attente et avec une étiquette (Label).
String,
MessageQueueTrans
actionType)

Remarque : le label, mentionné ici est un Label visible dans la console Management Microsoft
dans l’onglet MessageQueuing, le Label du message lui correspond à une propriété du message qui
peut être récupéré.

Dotnet France Association


15 [Le MSMQ] [Date : 10/10/09]

//C#
System.Messaging.Message msgout = new System.Messaging.Message();
msgout.Body = "Wahouuu";
msgout.Label = "Mon Premier Message";

MessageQ1.Send(msgout);

‘VB.NET
Dim msgout As New System.Messaging.Message()
msgout.Body = "Wahouuu"
msgout.Label = "Mon Premier Message"
MessageQ1.Send(msgout)

3.2.5 Réception d’un message


Pour la réception d’un message, nous allons voir les différentes méthodes avec Receive(), il faut
noter que c’est très similaire avec Peek(). La réception d’un message par un programme est l’un des
aspects essentiels de MSMQ. Pour recevoir les messages d’une file d’attente, il faut commencer par
déclarer la file d’attente comme vu précédemment, puis ensuite faire appel à la méthode
Receive(). Ainsi on peut récupérer le message le plus ancien de la file d’attente (ou avec une plus
grande priorité ; pour rappel, les priorités ne sont pas disponibles en mode WorkGroup).

Voici l’exemple le plus simple de réception de message

//C#
System.Messaging.Message msgin = new System.Messaging.Message();
msgin = MessageQ1.Receive();

‘VB.NET
Dim msgin As New System.Messaging.Message()
msgin = MessageQ1.Receive()

On peut donc récupérer les informations telles que le corps ou le Label et les afficher dans
notre programme.

Cette méthode qui est la plus simple et rapide, comporte néanmoins quelques failles. En
effet, s’il n’existe pas de message dans la file, le programme va se bloquer dans l’attente d’un
message. Il provoquera tel un appel de service synchrone, un ralentissement voire une fenêtre
« votre programme a cessé de fonctionner ».Pour cela, il existe plusieurs types de méthode
Receive() :

Type de Send Description


MessageQueue.Rece Reçoit le premier message disponible.
ive ()
MessageQueue.Rece Reçoit le premier message disponible dans une file transactionnelle.
ive
(MessageQueueTran
saction)
MessageQueue.Rece Reçoit le premier message disponible avec spécification du type de
ive la transaction.
(MessageQueueTran
sactionType)
Où l’on peut ajouter comme paramètre
TimeSpan Attend de recevoir un message dans le temps indiqué, sinon

Dotnet France Association


16 [Le MSMQ] [Date : 10/10/09]

renvoie une exception.


TimeSpan, Cursor Attend de recevoir un message dans le temps indiqué, sinon
renvoie une exception. Cursor conserve une position spécifique
dans la file d’attente.

Comme vu dans le chapitre précédent, il existe une autre solution, que l’on trouve dans
l’asynchrone ; pour cela MSMQ a directement les outils nécessaires, avec la présence de
BeginReceive et EndReceive.

L’utilisation de ces deux méthodes est en tout point similaire à BeginInvoke et EndInvoke.
Là encore on utilise le using « System.Treading » et l’on crée un objet IAsyncResult

//C#
IAsyncResult iarR = MessageQ1.BeginReceive();
//code exécuter durant la réception du message.
System.Messaging.Message msgin = MessageQ1.EndReceive(iarR);
‘VB.NET
Dim iarR As IAsyncResult = MessageQ1.BeginReceive()
'code exécuter durant la réception du message.
Dim msgin As System.Messaging.Message = MessageQ1.EndReceive(iarR)

3.2.6 Répondre à un message


Lorsque le client attend une réponse précise à un message qu’il a envoyé, il peut ajouter une
propriété ReponseQueue et donner ainsi au serveur une file d’attente dans laquelle il récupèrera la
réponse.

//C#
System.Messaging.Message msg = new System.Messaging.Message();
msg.ResponseQueue = new MessageQueue(@".\private$\MaFileReponse");

‘VB.NET
Dim msg As New System.Messaging.Message()
msg.ResponseQueue = New MessageQueue(".\private$\MaFileReponse")

Le serveur peut travailler sur le message puis le renvoyer au client sur la file d’attente indiquée
par le client, grâce à la méthode suivante qui remplace la méthode Send().

//C#
msgin.ResponseQueue.Send(msgout);

‘VB.NET
msgin.ResponseQueue.Send(msgout)

Ainsi on pourra récupérer des messages réponse dans la file d’attente privée
« MaFileReponse ».

3.3 Exemple
Pour notre exemple, nous allons utiliser deux ordinateurs sur un même réseau LAN. Notre
programme est conçu en Winform. L’interface utilisateur Winform propose une ListBox pour
l’affichage des résultats, et une TextBox pour créer de nouveaux messages. Le nouveau message
contiendra un nom ou pseudo et sera envoyé par message queuing à un serveur qui rajoutera
« hello » et répondra sur la file réponse prédéfini dans le message.

Dotnet France Association


17 [Le MSMQ] [Date : 10/10/09]

Mon premier ordinateur a pour IP : 192.168.0.5, le second a pour IP : 192.168.0.6. Si vous ne


disposez que d’un ordinateur avec MSMQ, vous pouvez remplacer les IP par un « . » qui indiquera
localhost au programme et utilisera des chaines locales.

Ma fenêtre Winform (Form1) est constituée de la manière suivante :

Et voici le code Client (application Winform) :

Dotnet France Association


18 [Le MSMQ] [Date : 10/10/09]

//C#
using System;
using System.Text;
using System.Windows.Forms;
using System.Messaging;
using System.Threading;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace testmsqn
{
public partial class Form1 : Form
{
private MessageQueue MessageQ1;
private MessageQueue MessageQ2;

public Form1()
{
InitializeComponent();

if (!MessageQueue.Exists(@".\Private$\reponseq"))
{
MessageQueue.Create(@".\Private$\reponseq");
}
MessageQ1 = new MessageQueue(@".\Private$\reponseq");
MessageQ2 = new
MessageQueue(@"FormatName:DIRECT=TCP:192.168.0.6\myqueue");
listBox1.Items.Clear();
}

private void button1_Click(object sender, EventArgs e)


{
try
{
MessageQ1.Formatter = new XmlMessageFormatter(new
String[] { "System.String" });

IAsyncResult iarR =
MessageQ2.BeginReceive(TimeSpan.FromMilliseconds(500));
System.Messaging.Message msg =
MessageQ2.EndReceive(iarR);
listBox1.Items.Add(msg.Body);
}
catch
{
listBox1.Items.Add("Temps d'attente dépassé");
}
}

private void button2_Click(object sender, EventArgs e)


{
System.Messaging.Message msgsend = new
System.Messaging.Message();
msgsend.Body = textBox1.Text;
msgsend.ResponseQueue = new
MessageQueue(@"FormatName:DIRECT=TCP:192.168.0.5\private$\reponseq");
MessageQ2.Send(msgsend);
}
}
}

Dotnet France Association


19 [Le MSMQ] [Date : 10/10/09]

‘VB.NET

Imports System
Imports System.Text
Imports System.Windows.Forms
Imports System.Messaging
Imports System.Threading
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels
Imports System.Runtime.Remoting.Channels.Tcp

Namespace testmsqn
Partial Public Class Form1
Inherits Form
Private MessageQ1 As MessageQueue
Private MessageQ2 As MessageQueue

Public Sub New()


InitializeComponent()

If Not MessageQueue.Exists(".\Private$\reponseq") Then


MessageQueue.Create(".\Private$\reponseq")
End If
MessageQ1 = New MessageQueue(".\Private$\reponseq")
MessageQ2 = New
MessageQueue("FormatName:DIRECT=TCP:192.168.0.6\myqueue")
listBox1.Items.Clear()
End Sub

Private Sub button1_Click(ByVal sender As Object, ByVal e As


EventArgs)
Try
MessageQ1.Formatter = New XmlMessageFormatter(New
[String]() {"System.String"})

Dim iarR As IAsyncResult =


MessageQ2.BeginReceive(TimeSpan.FromMilliseconds(500))
Dim msg As System.Messaging.Message =
MessageQ2.EndReceive(iarR)
listBox1.Items.Add(msg.Body)
Catch
listBox1.Items.Add("Temps d'attente dépassé")
End Try
End Sub

Private Sub button2_Click(ByVal sender As Object, ByVal e As


EventArgs)
Dim msgsend As New System.Messaging.Message()
msgsend.Body = textBox1.Text
msgsend.ResponseQueue = New
MessageQueue("FormatName:DIRECT=TCP:192.168.0.5\private$\reponseq")
MessageQ2.Send(msgsend)
End Sub
End Class
End Namespace

Notre serveur est lui un programme console qui rajoutera à la chaine de départ « hello » et « !!! » :

Dotnet France Association


20 [Le MSMQ] [Date : 10/10/09]

//C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Messaging;
using System.Threading;

namespace testmsmqS
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("GO Serveur");

if (!MessageQueue.Exists(@".\Private$\myqueue"))
{
MessageQueue.Create(@".\Private$\myqueue");
}

MessageQueue MessageQ = new


MessageQueue(@".\Private$\myqueue");

while (true)
{
Thread.Sleep(500);
MessageQ.Formatter = new XmlMessageFormatter(new String[]
{ "System.String" });
try
{
IAsyncResult iarR =
MessageQ.BeginReceive(TimeSpan.FromMilliseconds(500));
System.Messaging.Message msgin =
MessageQ.EndReceive(iarR);
msgin.Body = Helloman(msgin.Body.ToString());
Console.WriteLine(msgin.Body.ToString());
msgin.ResponseQueue.Send(msgin);
}
catch { }
}
}

static string Helloman(string msg)


{
msg = "Hello " + msg + " !!!";
return msg;
}
}
}

Dotnet France Association


21 [Le MSMQ] [Date : 10/10/09]

Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Text
Imports System.Messaging
Imports System.Threading

Namespace testmsmqS
Class Program
Private Shared Sub Main(ByVal args As String())

Console.WriteLine("GO Serveur")

If Not MessageQueue.Exists(".\Private$\myqueue") Then


MessageQueue.Create(".\Private$\myqueue")
End If

Dim MessageQ As New MessageQueue(".\Private$\myqueue")

While True
Thread.Sleep(500)
MessageQ.Formatter = New XmlMessageFormatter(New
[String]() {"System.String"})
Try
Dim iarR As IAsyncResult =
MessageQ.BeginReceive(TimeSpan.FromMilliseconds(500))
Dim msgin As System.Messaging.Message =
MessageQ.EndReceive(iarR)
msgin.Body = Helloman(msgin.Body.ToString())
Console.WriteLine(msgin.Body.ToString())
msgin.ResponseQueue.Send(msgin)
Catch
End Try
End While
End Sub

Private Shared Function Helloman(ByVal msg As String) As String


msg = "Hello " & msg & " !!!"
Return msg
End Function
End Class

End Namespace

Une fois le programme lancé plusieurs situations peuvent se présenter :

 On clique sur le bouton recevoir mais la file d’attente ne contient aucun message ou on
envoie un message au serveur, qui lui n’est pas lancé, puis on fait recevoir : dans ce cas la
ListBox affiche « Délai d’attente dépassé »
 Si au contraire on envoie un message à un serveur lancé, et que celui-ci répond, un clic sur
recevoir permet de l’afficher.

Dotnet France Association


22 [Le MSMQ] [Date : 10/10/09]

Dotnet France Association


23 [Le MSMQ] [Date : 10/10/09]

Dotnet France Association


24 [Le MSMQ] [Date : 10/10/09]

4 Conclusion
Dans ce chapitre, nous avons vu comment utiliser le MSMQ, le message Queuing proposé par
Microsoft.

Nous avons parcouru les différents types de message et de file d’attente et, à l’aide d’un
exemple final, montré comment en tirer profit.

Dotnet France Association

Vous aimerez peut-être aussi