Bonjour a tous.

Je suis à la recherche de cours ou tutos traitant sérieusement de l'utilisation de pipes. des documents où on apprend à connaitre et pas de document où l'auteur montre seulement que lui sait faire LOL. Je plaisante ce que je veux dire que je recherche des document de base pour apprendre. Le but du jeu est de faire communiquer deux exe entre eux. le premier est une appli console et l'autre une appli winform. Le ou les pipes doivent permettre la communication dans les deux sens. j'ai déja trouvé des exemples mais ils ne correspondent pas exactement à ce que je veux et dès que je les modifie ca ne fonctionne pas. le meilleur exemples était l'équivalent d'un tchat (message => Reponse) avec attente de la réponse qui bloque l'appli. Je veux travailler avec des threads. Je veux que la réception des messages soit observé par un thread mais qui ne bloque pas l'appli ni la possibilité d'envoyer un message que se soit sur le serveur ou sur le client. 

J'ai surtout travailler sur des pipes nommés IN/OUT mais j'ai toujours un blocage qui apparait. J'écris ma fonction de lecture qui marche si je l'exécute dan mon MAIN() mais dès que je la passe en thread .... plus d'accès au READ sur le pipe. Je joint le code coté serveur ... ca plante quand il n'y a plus de message à recevoir du client mais sans retour d'exeption ... Merci pour l'aide que vous pourrez m'apporter sur ce sujet.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.IO.Pipes;

using System.Threading;

using System.Windows.Forms;

using System.IO;

namespace SERVEUR

{

    class Program

    {

        public static string MESSAGE_TO_SEND;                     // Contient le message à envoyer

        public static bool MESSAGE_TO_SEND_STATUS = false;        // Flag indiquant qu'un message est à envoyer 1 = message à envoyé ; 0 = aucun message à envoyer

        public static string MESSAGE_RECEIVED;                    // Contient le message reçu

        public static bool END_INIT_SERVER_THREAD = false;        // indique la fin d'initialisation du thread server   

        public static byte[] messageBytes;

        public static NamedPipeServerStream namedPipeServer = new NamedPipeServerStream("test-pipe", PipeDirection.InOut,

                1, PipeTransmissionMode.Message);

        static void Main(string[] args)

        {

            ConversationWithTheClient();   

            while (!END_INIT_SERVER_THREAD) { }                     // On attend la fin de l'initialisation du thread server

            MESSAGE_TO_SEND = "COUCOU";

            MESSAGE_TO_SEND_STATUS = true;

            while (MESSAGE_TO_SEND_STATUS) { }                     // On attend la fin de l'emmission du message précedent

            MESSAGE_TO_SEND = "BONJOUR A TOUS";

            MESSAGE_TO_SEND_STATUS = true;

            while (MESSAGE_TO_SEND_STATUS) { }                     // On attend la fin de l'emmission du message précedent

            MESSAGE_TO_SEND = "C'est un message de test";

            MESSAGE_TO_SEND_STATUS = true;

            Console.ReadLine();

        }

        private static void ConversationWithTheClient()

        {

                Console.WriteLine("[Server :] Waiting for a connection...\n");

                namedPipeServer.WaitForConnection();

                Console.Write("[Server:] A client has connected !\n");

            Thread WRITING_PIPE_THREAD = new Thread(WRITING_PIPE);     // Création du thread d'ecriture sur le pipe

            WRITING_PIPE_THREAD.Start();

            Thread READING_PIPE_THREAD = new Thread(READING_PIPE);     // Création du thread de lecture sur le pipe

            READING_PIPE_THREAD.Start();

            MESSAGE_TO_SEND = "welcome message";

            MESSAGE_TO_SEND_STATUS = true;

            while (MESSAGE_TO_SEND_STATUS) { }                     // On attend la fin de l'emmission du message précedent

            string response = ProcessSingleReceivedMessage(namedPipeServer);

                Console.WriteLine("[Client] send reponse : {0}", response);

                END_INIT_SERVER_THREAD = true;

        }

        private static string ProcessSingleReceivedMessage(NamedPipeServerStream namedPipeServer)

        {

            StringBuilder messageBuilder = new StringBuilder();

            string messageChunk = string.Empty;

            byte[] messageBuffer = new byte[5];

                do

                {

                Application.DoEvents();

                namedPipeServer.Read(messageBuffer, 0, messageBuffer.Length);

                    messageChunk = Encoding.UTF8.GetString(messageBuffer);

                    messageBuilder.Append(messageChunk);

                    messageBuffer = new byte[messageBuffer.Length];

                }

                while (!namedPipeServer.IsMessageComplete);

                return messageBuilder.ToString();

        }

        public static void WRITING_PIPE()

        {

            while (true)

            {

                Application.DoEvents();

                if (MESSAGE_TO_SEND_STATUS)

                {

                    messageBytes = Encoding.UTF8.GetBytes(MESSAGE_TO_SEND);

                    namedPipeServer.Write(messageBytes, 0, messageBytes.Length);

                    Console.WriteLine("[Server] send message : {0}\n", MESSAGE_TO_SEND);

                    MESSAGE_TO_SEND_STATUS = false;

                }

            }

        }

        public static void READING_PIPE()

        {       

            while (true)

            {

               Application.DoEvents();

            MESSAGE_RECEIVED = ProcessSingleReceivedMessage(namedPipeServer);

            Console.WriteLine("[Client] send message : {0}\n", MESSAGE_RECEIVED);

                while (MESSAGE_TO_SEND_STATUS) { };

                MESSAGE_TO_SEND = "Y";

                MESSAGE_TO_SEND_STATUS = true;

            }

        }

    }  

}

Bonjour,

Le message qui suit est une réponse automatique activée par un membre de l'équipe de modération. Les réponses automatiques leur permettent d'éviter d'avoir à répéter de nombreuses fois la même chose, ce qui leur fait gagner du temps et leur permet de s'occuper des sujets qui méritent plus d'attention.
Nous sommes néanmoins ouverts et si vous avez une question ou une remarque, n'hésitez pas à contacter la personne en question par Message Privé.
Pour plus d'informations, nous vous invitons à lire les règles générales du forum

Merci de colorer votre code à l'aide du bouton Code

Les forums d'Openclassrooms disposent d'une fonctionnalité permettant de colorer et mettre en forme les codes source afin de les rendre plus lisibles et faciles à manipuler par les intervenants. Pour cela, il faut utiliser le bouton de l'éditeur, choisir un des langages proposés et coller votre code dans la zone prévue. Si vous utilisez l'éditeur de messages en mode Markdown, il faut utiliser les balises <pre class="brush: vb;">Votre code ici</pre>.

Merci de modifier votre message d'origine en fonction.

Liens conseillés

• Charte de bonne conduite
• Règles générales du forum

Ce code sent bon la patchouli des années 70.

- Utilisation erratique de convention de nommage désuet

- Utilisation de variables statiques pour cacher des globales qui non rien à faire dans un code moderne et encore moins dans un code multi-thread

- Utilisation de boucles d'attente active en lieu et place des primitives asynchrones

- Etc

Vous donnez des tentatives de solutions (multi-treading, etc...) mais pas le besoin initiale autre que de faire communiquer des programmes autonomes.

Des IPC (Inter Programm Ccommunication), il en existe des dizaines, et les pipes, c'est ni les plus communs, ni les plus souples.

Je sais pas où vous avez chopé cet exemple, mais prenez en une qui repompe (mal) des machins d'il y a 50 ans.