Le MSMQ

Le MSMQ Version 1.0

Z

Pierre-Franck Chauvet

Dotnet France Association

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


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).


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


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 :

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.

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.


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 »


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.


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.


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.


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 ».


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).


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).

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

(BeginPeek) Permet de lancer une opération de réception asynchrone d’un 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)

//C#

using System.Messaging;

‘VB.NET

Imports System.Messaging


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

EndReceive

(EndPeek) Permet de terminer la réception asynchrone spécifiée.

GetAllMessages Permet de retourner tous les messages de la liste d’attente GetPrivateQueueBy

Machine Permet de récupérer les files d’attente privées sur l’ordinateur spécifié.

GetPublicQueue Permet de récupérer les files d’attente publiques sur le réseau. GetPublicQueueByM

achine Permet de récupérer les files d’attente publiques sur l’ordinateur 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.

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.

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.

//C#

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

‘VB.NET

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

//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


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

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,

String) Envoi d’un objet à une file non d’attente transactionnelle et avec une étiquette (Label).

Send (Object,

MessageQueueTrans

action)

Envoi d’un objet à une file d’attente transactionnelle.

Send (Object,

String,

MessageQueueTrans

action)

Envoi d’un objet à une file d’attente transactionnelle et avec une étiquette (Label).

Send (Object,

MessageQueueTrans

actionType)

Envoi d’un objet à une file d’attente.

Send (Object,

String,

MessageQueueTrans

actionType)

Envoi d’un objet à une file d’attente et avec une étiquette (Label).

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é.

//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")


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

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

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

ive () Reçoit le premier message disponible.

MessageQueue.Rece

ive

(MessageQueueTran

saction)

Reçoit le premier message disponible dans une file transactionnelle.

MessageQueue.Rece

ive

(MessageQueueTran

sactionType)

Reçoit le premier message disponible avec spécification du type de la transaction.

Où l’on peut ajouter comme paramètre TimeSpan Attend de recevoir un message dans le temps indiqué, sinon

//C#

System.Messaging.Message msgin = new System.Messaging.Message();

msgin = MessageQ1.Receive();

‘VB.NET

Dim msgin As New System.Messaging.Message()

msgin = MessageQ1.Receive()

//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)


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

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.

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().

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.

//C#

msgin.ResponseQueue.Send(msgout);

‘VB.NET

msgin.ResponseQueue.Send(msgout)

//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")

//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)


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) :


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

//C#

using System;

using System.Text;

using System.Windows.Forms;


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);

}

}

}


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

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

‘VB.NET

Imports System

Imports System.Text

Imports System.Windows.Forms


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


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

//C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;


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;

}

}

}


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

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.

Imports System

Imports System.Collections.Generic

Imports System.Linq

Imports System.Text


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


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


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


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.

Le MSMQ

Documents

files dattente et

msmq date

client et

messages sur

msmq est lchange

msmq est denlever

msmq va

et server2008