Le MSMQ

Version 1.0
Z

Pierre-Franck Chauvet

2

[Le MSMQ]

[Date : 10/10/09]

Sommaire

1 2

Introduction ..................................................................................................................................... 3 Le Concept ....................................................................................................................................... 5 2.1 2.2 2.3 2.4 Les messages ........................................................................................................................... 5 Les files d’attentes ................................................................................................................... 5 WorkGroup .............................................................................................................................. 7 Active Directory ....................................................................................................................... 7

3

Utilisation ........................................................................................................................................ 9 3.1 3.2 Activer le service ..................................................................................................................... 9 Dans le code .......................................................................................................................... 12 Création d’une file d’attente privée .............................................................................. 13 Déclaration de la file d’attente ...................................................................................... 13 Création de message ..................................................................................................... 13 Envoi d’un message ....................................................................................................... 14 Réception d’un message ............................................................................................... 15 Répondre à un message ................................................................................................ 16

3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.2.6 3.3 4

Exemple ................................................................................................................................. 16

Conclusion ..................................................................................................................................... 24

Dotnet France Association

les boîtes e-mail aux files d’attente MSMQ. En effet. et les envoyer une fois le serveur connecté. ce qui apporte tous les avantages exposés dans le cours précédant (voir le chapitre sur Le . 7 et Server2008. si les calculs serveur prennent du temps et que le client se déconnecte. Mais le Remoting asynchrone impliquait le fait que le client et le serveur s’exécutent en même temps.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. actuellement la v4. l’utilisateur choisi ce qu’il fait de ses mails (archivage.0 sur Windows X et Serveur 2003. on peut assimiler les messages e-mail aux messages MSMQ. 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é. Les files d’attente de messages sont des liaisons asynchrones entre plusieurs processus. le Message Queuing peut s’exécuter dans un environnement déconnecté. nous allons étudier les files d’attente MSMQ Microsoft et comment interagir avec dans nos programme . L’exemple le plus simple est de le comparer à un système de messagerie électronique (e-mail). Attention. ceci est un exemple général.0 sur Windows 2000. Dotnet France Association .NET Remoting One-Way et Asynchrone). De même. Du coup. v2. il sera toujours possible de récupérer les résultats lors de la prochaine connexion. Cette technologie est le MOM (Message Oriented Middleware) par Microsoft . v3. 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). suppression). en effet les services de messagerie électronique sont centralisés et n’utilisent pas plusieurs chemins d’accès tels que MSMQ. Cette technologie est implantée depuis Windows 95 avec MSMQ v1. Dans ce chapitre.0. c’est l’infrastructure qui permet un couplage d’application grâce à des files d’attente et des messages. dans les messageries e-mail. et les utilisateurs aux applications. 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.NET. Ici.0 pour Windows Vista. 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.

4 [Le MSMQ] [Date : 10/10/09] Dotnet France Association .

2 Les files d’attentes Une file d’attente est un réservoir à messages . Il existe plusieurs types de messages ainsi que différentes files d’attentes pour gérer toutes les possibilités. ils sont envoyés à la file d’attente d’administration. DestinationQueue Obtient la file d’attente de destination. Type de file d’attente Publique Privée Journal Description Est publiée dans active directory. Message d’accusé de réception. UseJournal Obtient ou définit si on utilise une file d’attente journal avec copie des messages. 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. Message de réponse. Ces files d’attente peuvent être consultées avec le chemin d’accès complet Est utilisée pour conserver des copies des messages après envoi ou réception. envoyé par l’application à une file d’attente.1 Les messages La bonne compréhension des messages ett essentielle. TimeToReachQueue Obtient ou définit le délai accordé à un message pour atteindre la file d’attente. Body Label Paramètre De plus. 2. Message de rapport. Dotnet France Association . AdministrationQueue Obtient ou définit la file d’attente d’administration. Priority Obtient ou définit la priorité du message. On retrouve ces files d’attente dans le répertoire « C:\Windows\System32\msmq\storage ».5 [Le MSMQ] [Date : 10/10/09] 2 Le Concept Le concept du MSMQ est l’échange de messages entre plusieurs parties (processus). 2. qui indique l’état d’un message dit normal. Avec des files publiques il n’y a pas obligation de créer N’est pas publiée dans Active Directory. tout message reçu ou stocké sera obligatoirement compris dans une file d’attente. Formater Obtient ou définit le formateur utilisé pour sérialiser et désérialiser l’objet. est envoyé lorsque l’expéditeur attend une certaine réponse. qui est généré en interne par Message Queuing. TimeToBeReceived Obtient ou définit le délai d’attente pour la réception du message à partir de la file d’attente de destination. ReponseQueue Obtient ou définit la file d’attente de réponse du message. Il existe différents types de files d’attente disponibles avec MSMQ. Ou étiquette du message qui peut correspondre à l’objet sur un mail. C’est un message test. ID Permet d’identifier le message. Ils sont donc envoyés aux files d’attente et comportent plusieurs paramètres tels que : Description Corps du message comprenant les données. il en existe différents types :     Message dit normal.

le nom de format existe sous plusieurs formes. Remarque : pour le protocole http (et seulement ce protocole) il est possible d’utiliser des slashes ou des antislashes. « 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.5\$Private\NomDeLaQueuePrivée »  http : permet de spécifier l’adresse URL.\Private$\NomDeLaQueuePrivée » Le nom de format : à privilégier pour de la programmation.168. 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 « . Reçoit les messages de type « Acknowledgement » Peut être paramétrée pour recevoir les réponses de certains messages.6 [Le MSMQ] Dead-letter [Date : 10/10/09] Est la file d’attente où finissent les messages erronés. Files qui peut être créée en changeant le type d’une file d’attente privée ou publique Files d’attente privées. elles sont utilisées pour des messages d’administration. « 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 :PFCH5Laptop\NomDeLaQueuePublique.0.5\Private$\ NomDeLaQueue Privée »  Dotnet France Association .168. 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 =TCP :192.0. d’archivage de notification ou pour garantir l’ordre correct des messages transactionnels. Administration Réponse Rapport Système 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. En effet message queuing dispose d’une gestion des erreurs Peut être paramétrée pour recevoir les accusés de réception et gérer ainsi les différents échanges.

L’Arbre représente l’ensemble des conteneurs et feuilles de l’Active Directory. Imprimantes ou autres machines réseau sont répertoriées. Chacun de ces modes présente des particularités et restrictions propres.4 Active Directory Active Directory est la mise en en œuvre des services d’annuaires dans un environnement Windows.7 [Le MSMQ] [Date : 10/10/09] Syntaxe NomDelaMachine\NomDeLaQueuePublique NomDelaMachine\Private$\NomDeLaQueuePrivée NomDelaMachine\NomDelaQueue\Journal$ NomDeLaMAchine\Deadletter$ Type de file d’attente Publique Privée Journal Dead-letter 2. et dossier partagés. Ainsi les différents postes Windows.    2. il équipe depuis Windows 2003 et 2008.3 WorkGroup L’utilisation de MSMQ peut se faire selon 3 modes distincts :    Domaines d’application (Windows Serveur) : utilise l’active directory. Mis en place avec Windows Server 2000. Active Directory prend aussi en compte les Comptes utilisateurs. Il permet des services de centralisation et d’authentification sur un réseau utilisant Windows. 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). 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). 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. 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). Domaine représente un conteneur ou une feuille. 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. De plus. Dotnet France Association .

8 [Le MSMQ] [Date : 10/10/09] Dans un environnement de domaine. Dotnet France Association . des objets Message Queuing sont créés dans l’Active Directory. Ces objets contiennent des informations Message Queuing. pour tous types d’ordinateurs utilisant Message Queuing (sauf un client dépendant).

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

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 » . puis fichier. ou en tapant « MMC » dans le champs de recherche. Une fois ce service coché. ouvrir « compmgmt. 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.msc ».

il vous sera possible de gérer les file d’attentes à votre convenance. les créer ou voir les contenus.11 [Le MSMQ] [Date : 10/10/09] D’ici. ainsi que de leur associer des triggers (déclencheurs). Dotnet France Association .

Permet de supprimer tous les messages de la file d’attente Permet de recevoir le message correspondant à l’Id donné Permet de recevoir le message correspondant à l’Id sans le supprimer de la file d’attente Permet de lancer une opération de réception asynchrone d’un message de la file d’attente. Permet de supprimer une file d’attente. Permet la réception d’un message et donc la suppression de l’objet de la file d’attente Permet la réception d’un message de la file d’attente sans le supprimer de celle-ci. ‘VB.12 [Le MSMQ] [Date : 10/10/09] 3.Messaging » qui donnera accès à tous les outils de gestion des messages.Messaging On trouve ensuite dans cette bibliothèque beaucoup de méthodes telles que les suivantes : Type de file d’attente Create Existe Delete Send Receive Peek Purge ReceiveById PeekById BeginReceive (BeginPeek) Description Permet de créer une file d’attente avec un chemin spécifié.Messaging. Permet l’envoi d’un objet dans une file d’attente. Il faut ensuite ajouter le using (Import).NET Imports System. le supprime de celle ci et avertit le gestionnaire d’évènement une fois terminé (sans le supprimer pour BeginPeek) Dotnet France Association .2 Dans le code Il est possible d’utiliser le Message Queuing dans les programmes . Pour cela il est essentiel d’ajouter la référence « System.NET. //C# using System. Permet de vérifier l’existence ou non d’une file d’attente avec le chemin spécifié.

2 Déclaration de la file d’attente Avant de commencer à utiliser la file d’attente. Il faut donner en paramètre le chemin d’accès vers notre file d’attente préalablement créée. ‘VB.Exists(@".13 [Le MSMQ] [Date : 10/10/09] Permet de terminer la réception asynchrone spécifiée.\Private$\MaFilePrivee"). Label ou encore ReponseQueue.Create(".NET MessageQ1 = New MessageQueue(". Permet de récupérer les files d’attente publiques sur l’ordinateur spécifié. En se rendant dans l’onglet service puis message queuing et enfin file d’attente privée. si ce n’est le cas il convient de la créer.\Private$\MaFilePrivee") 3.Exists(". Dans l’onglet « MaFilePrivee ». En effet. EndReceive (EndPeek) GetAllMessages GetPrivateQueueBy Machine GetPublicQueue GetPublicQueueByM achine 3.\Private$\MaFilePrivee").2.\Private$\MaFillePrivee") End If Ici. Permet de retourner tous les messages de la liste d’attente Permet de récupérer les files d’attente privées sur l’ordinateur spécifié.\MaFilePublique ».\Private$\MaFilePrivee")) { MessageQueue. il faut la déclarer. Permet de récupérer les files d’attente publiques sur le réseau. } ‘VB. on teste l’existence de la file d’attente privée « MaFilePrivee » avant de la créer.1 Création d’une file d’attente privée Pour créer une file d’attente privée. il faut le créer.2. 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 « . //C# if (!MessageQueue. puis « Message journal » qui reçoit les messages journaux.3 Création de message Avant d’envisager l’envoi d’un message.NET If Not MessageQueue. Dotnet France Association .\Private$\MaFilePrivee") Then MessageQueue. //C# MessageQ1 = new MessageQueue(@".Create(@". Pour cela il suffit d’initialiser le message et de remplir certains champs tels que Body. cette déclaration permet d’utiliser simplement toutes les méthodes et propriétés pour chaque file d’attente. 3.2. on retrouve « Message de file d’attente » qui est la file d’attente pour les messages dit normaux. il faut au préalable vérifier si elle existe déjà .

Envoi d’un objet à une file d’attente transactionnelle. celles-ci diffèrent au niveau des paramètres.\private$\MaFileReponse").Label = "Entete de mon message" msg. MessageQueueTrans action) Send (Object. « Entete de mon message » comme Label et comme reponseQueue.ResponseQueue = New MessageQueue(". le Label du message lui correspond à une propriété du message qui peut être récupéré.14 [Le MSMQ] [Date : 10/10/09] //C# System.NET Dim msg As New System. Envoi d’un objet à une file d’attente. j’utilise l’Espace de nom complet.Body = "Corps de mon message" msg. rien de plus simple : il suffit d’utiliser la méthode Send(…) comme vu précédemment. Type de Send Send(Object) Send (Object.Messaging. Remarque : le label. 3.\private$\MaFileReponse") Ici notre message « msgsend » a un string comme corps. mentionné ici est un Label visible dans la console Management Microsoft dans l’onglet MessageQueuing.Message() msg. String) Send (Object. msg. Envoi d’un objet à une file d’attente et avec une étiquette (Label). 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).Message msg = new System.Messaging.4 Envoi d’un message Pour l’envoi d’un message.Body = "Corps de mon message". Il existe plusieurs surcharges à cette méthode. la file d’attente privée « reponseq » Remarque : dès cet exemple. msg. String.Message().2. Envoi d’un objet à une file d’attente transactionnelle et avec une étiquette (Label). Dotnet France Association . msg. On en dénombre cinq. MessageQueueTrans actionType) Send (Object. String. MessageQueueTrans action) Send (Object. MessageQueueTrans actionType) Description Envoi d’un objet à une file d’attente non transactionnelle Envoi d’un objet à une file non d’attente transactionnelle et avec une étiquette (Label).Messaging.ResponseQueue = new MessageQueue(@". ‘VB.Label = "Entete de mon message".

Message msgout = new System. Reçoit le premier message disponible dans une file transactionnelle.Messaging.NET Dim msgin As New System. Où l’on peut ajouter comme paramètre TimeSpan Attend de recevoir un message dans le temps indiqué.15 [Le MSMQ] [Date : 10/10/09] //C# System.Message(). s’il n’existe pas de message dans la file. puis ensuite faire appel à la méthode Receive(). pour rappel. Voici l’exemple le plus simple de réception de message //C# System.Rece ive () MessageQueue. il faut noter que c’est très similaire avec Peek().2.Rece ive (MessageQueueTran saction) MessageQueue. le programme va se bloquer dans l’attente d’un message.5 Réception d’un message Pour la réception d’un message. il faut commencer par déclarer la file d’attente comme vu précédemment. Pour recevoir les messages d’une file d’attente. ‘VB. comporte néanmoins quelques failles. Ainsi on peut récupérer le message le plus ancien de la file d’attente (ou avec une plus grande priorité .Send(msgout) 3. msgout.Body = "Wahouuu" msgout.Label = "Mon Premier Message".Message() msgout. les priorités ne sont pas disponibles en mode WorkGroup). il existe plusieurs types de méthode Receive() : Type de Send MessageQueue. msgin = MessageQ1.Receive().Messaging. La réception d’un message par un programme est l’un des aspects essentiels de MSMQ.Message msgin = new System. nous allons voir les différentes méthodes avec Receive().Messaging.Messaging. En effet.Receive() On peut donc récupérer les informations telles que le corps ou le Label et les afficher dans notre programme.Body = "Wahouuu". un ralentissement voire une fenêtre « votre programme a cessé de fonctionner ». sinon Dotnet France Association . MessageQ1.Label = "Mon Premier Message" MessageQ1. ‘VB. Cette méthode qui est la plus simple et rapide.Messaging.NET Dim msgout As New System.Rece ive (MessageQueueTran sactionType) Description Reçoit le premier message disponible. Il provoquera tel un appel de service synchrone. msgout.Message().Message() msgin = MessageQ1.Send(msgout).Pour cela.Messaging. Reçoit le premier message disponible avec spécification du type de la transaction.

Cursor conserve une position spécifique dans la file d’attente. grâce à la méthode suivante qui remplace la méthode Send(). L’interface utilisateur Winform propose une ListBox pour l’affichage des résultats.EndReceive(iarR). ‘VB.ResponseQueue.ResponseQueue = new MessageQueue(@".Send(msgout) Ainsi on pourra récupérer des messages réponse dans la file d’attente privée « MaFileReponse ».Messaging.ResponseQueue = New MessageQueue(".Message msg = new System.NET msgin.EndReceive(iarR) 3.Messaging.Messaging.\private$\MaFileReponse"). //C# System. 3. Cursor Comme vu dans le chapitre précédent. Attend de recevoir un message dans le temps indiqué.Messaging. Dotnet France Association . sinon renvoie une exception.ResponseQueue.NET Dim msg As New System.BeginReceive() 'code exécuter durant la réception du message. avec la présence de BeginReceive et EndReceive. que l’on trouve dans l’asynchrone .2. 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. System. msg.Message() msg.Message(). nous allons utiliser deux ordinateurs sur un même réseau LAN.Treading » et l’on crée un objet IAsyncResult //C# IAsyncResult iarR = MessageQ1. ‘VB. Dim msgin As System. TimeSpan. ‘VB.16 [Le MSMQ] [Date : 10/10/09] renvoie une exception.BeginReceive(). L’utilisation de ces deux méthodes est en tout point similaire à BeginInvoke et EndInvoke.NET Dim iarR As IAsyncResult = MessageQ1.Message msgin = MessageQ1.Messaging. Notre programme est conçu en Winform.3 Exemple Pour notre exemple. Là encore on utilise le using « System.6 Répondre à un message Lorsque le client attend une réponse précise à un message qu’il a envoyé.\private$\MaFileReponse") Le serveur peut travailler sur le message puis le renvoyer au client sur la file d’attente indiquée par le client. et une TextBox pour créer de nouveaux messages. //C# msgin.Send(msgout). //code exécuter durant la réception du message.Message = MessageQ1. pour cela MSMQ a directement les outils nécessaires. il existe une autre solution. 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.

6.17 [Le MSMQ] [Date : 10/10/09] Mon premier ordinateur a pour IP : 192.5.0.0. vous pouvez remplacer les IP par un « . Si vous ne disposez que d’un ordinateur avec MSMQ.168. » qui indiquera localhost au programme et utilisera des chaines locales.168. Ma fenêtre Winform (Form1) est constituée de la manière suivante : Et voici le code Client (application Winform) : Dotnet France Association . le second a pour IP : 192.

Clear().Messaging.Text.Body). System.168. System. MessageQ2. System.Messaging.BeginReceive(TimeSpan.Runtime.Exists(@".0. } } private void button2_Click(object sender.Runtime.String" }).Add("Temps d'attente dépassé"). System.\Private$\reponseq")) { MessageQueue.168.18 [Le MSMQ] [Date : 10/10/09] //C# using using using using using using using using System. EventArgs e) { try { MessageQ1.Add(msg. namespace testmsqn { public partial class Form1 : Form { private MessageQueue MessageQ1. } private void button1_Click(object sender.Tcp.Remoting.Runtime.Message msg = MessageQ2. System. } } } Dotnet France Association . System. if (!MessageQueue.Message msgsend = new System.\Private$\reponseq"). System.0. MessageQ2 = new MessageQueue(@"FormatName:DIRECT=TCP:192.6\myqueue"). } catch { listBox1. msgsend.Remoting. } MessageQ1 = new MessageQueue(@". EventArgs e) { System.Messaging. listBox1.Items. IAsyncResult iarR = MessageQ2.Create(@".Text.FromMilliseconds(500)).Channels. listBox1.Forms. msgsend.Items.5\private$\reponseq").ResponseQueue = new MessageQueue(@"FormatName:DIRECT=TCP:192.Windows. public Form1() { InitializeComponent().EndReceive(iarR).Message().Items.Threading.\Private$\reponseq").Remoting.Formatter = new XmlMessageFormatter(new String[] { "System.Body = textBox1.Messaging.Send(msgsend). System. private MessageQueue MessageQ2.Channels.

0.Messaging.0.Add(msg.Items.Forms System.Messaging.168.\Private$\reponseq") Then MessageQueue.Messaging System.Remoting.\Private$\reponseq") End If MessageQ1 = New MessageQueue(".Formatter = New XmlMessageFormatter(New [String]() {"System.19 [Le MSMQ] [Date : 10/10/09] ‘VB.ResponseQueue = New MessageQueue("FormatName:DIRECT=TCP:192.Message() msgsend.Runtime.5\private$\reponseq") MessageQ2. ByVal e As EventArgs) Dim msgsend As New System.Runtime.Channels System.Runtime.EndReceive(iarR) listBox1.Remoting.FromMilliseconds(500)) Dim msg As System.Clear() End Sub Private Sub button1_Click(ByVal sender As Object.\Private$\reponseq") MessageQ2 = New MessageQueue("FormatName:DIRECT=TCP:192.Create(".6\myqueue") listBox1.Threading System.Message = MessageQ2.Add("Temps d'attente dépassé") End Try End Sub Private Sub button2_Click(ByVal sender As Object.Body) Catch listBox1.Windows.Text msgsend.String"}) Dim iarR As IAsyncResult = MessageQ2. ByVal e As EventArgs) Try MessageQ1.Items.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 .Body = textBox1.Exists(".Items.Remoting System.168.NET Imports Imports Imports Imports Imports Imports Imports Imports System System.Text System.Tcp Namespace testmsqn Partial Public Class Form1 Inherits Form Private MessageQ1 As MessageQueue Private MessageQ2 As MessageQueue Public Sub New() InitializeComponent() If Not MessageQueue.Channels.BeginReceive(TimeSpan.

ToString()).\Private$\myqueue")) { MessageQueue. if (!MessageQueue.Exists(@".Linq. System. System. Console.Body = Helloman(msgin.String" }).ToString()).Body. while (true) { Thread.Messaging. System. return msg.Sleep(500).Collections.WriteLine("GO Serveur").Create(@".Message msgin = MessageQ.Generic.20 [Le MSMQ] [Date : 10/10/09] //C# using using using using using using System. } catch { } } } static string Helloman(string msg) { msg = "Hello " + msg + " !!!". } } } Dotnet France Association .Text.Body.Threading. namespace testmsmqS { class Program { static void Main(string[] args) { Console. System. msgin.FromMilliseconds(500)). msgin. } MessageQueue MessageQ = new MessageQueue(@".Send(msgin). MessageQ. System.\Private$\myqueue").\Private$\myqueue").Messaging.ResponseQueue.WriteLine(msgin. try { IAsyncResult iarR = MessageQ.EndReceive(iarR).Formatter = new XmlMessageFormatter(new String[] { "System. System.BeginReceive(TimeSpan.

un clic sur recevoir permet de l’afficher.\Private$\myqueue") End If Dim MessageQ As New MessageQueue(".Body.FromMilliseconds(500)) Dim msgin As System. et que celui-ci répond.  Dotnet France Association .ToString()) Console.ToString()) msgin.Message = MessageQ. 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é.WriteLine(msgin.Messaging System.BeginReceive(TimeSpan.Create(".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.EndReceive(iarR) msgin.\Private$\myqueue") While True Thread.Formatter = New XmlMessageFormatter(New [String]() {"System.ResponseQueue. qui lui n’est pas lancé.Text System.Messaging.Generic System.21 [Le MSMQ] [Date : 10/10/09] Imports Imports Imports Imports Imports Imports System System.WriteLine("GO Serveur") If Not MessageQueue.Exists(".String"}) Try Dim iarR As IAsyncResult = MessageQ.Sleep(500) MessageQ.Body = Helloman(msgin.Collections.\Private$\myqueue") Then MessageQueue.Threading Namespace testmsmqS Class Program Private Shared Sub Main(ByVal args As String()) Console.Linq System.Body.

22 [Le MSMQ] [Date : 10/10/09] Dotnet France Association .

23 [Le MSMQ] [Date : 10/10/09] Dotnet France Association .

Dotnet France Association .24 [Le MSMQ] [Date : 10/10/09] 4 Conclusion Dans ce chapitre. montré comment en tirer profit. 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.

Sign up to vote on this title
UsefulNot useful