NamedPipeServer Instance existante

Bonjour tout le monde,
j'ai besoin de votre aide. Je suis en train de travailler sur les NamedPipe server et client.

dans mon cas, j'ai besoin d'un seul couple client/server, c'est à dire un server a un client.
Quand je crée mon namedpipeserver stream je fais

Code:

new NamedPipeServerStream(pipeName, PipeDirection.InOut,1,PipeTransmissionMode.Message);

1 pour dire qu'il y a qu'une seule instance.

Cependant quand je fais mes tests que je lance plusieurs fois, il me dit impossible vous avez atteint le nombre maximum d'instance, cela signifie que quelque part mon autre pipeserver exist encore....
Je ne comprends pas pourquoi.
J'ai fait disconnect()
close(), dispose()....
Comment détruire un NamedPipeServerStream....

Voilà si qq1 a une idée pour m'aider je suis preneuse.
Merci d'avance:(

Je pense que la bonne approche est d'isoler le server par un mutex afin qu'il soit unique. Apres il faut definir une class derivant de MarshalByRefObject avec une méthode pour communiquer

un pti exemple qui fait client et server (selon le mutex):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using System.Windows.Forms;
using System.Threading;
using System.Diagnostics;
using System.Runtime.Remoting.Channels.Ipc;
using System.Runtime.Remoting.Channels;
 
namespace Example.IPC
{
    public static class Communication
    {
        static Mutex mutex;
 
        static private string ChannelName
        {
            get { return "Example.IPC" + Process.GetCurrentProcess().SessionId.ToString(); }
        }
 
        private const string ListenerName = "Listener";
        static private object m_listener;
 
        static public void Run(string sMsg)
        {
            bool createNew = false;
            // Si le try échoue, l’application se met en mode serveur, sinon elle communique en IPC avec celui-ci
            try
            {
                mutex = Mutex.OpenExisting(ChannelName);
            }
            catch (WaitHandleCannotBeOpenedException)
            {
                mutex = new Mutex(true, ChannelName, out createNew);
            }
 
            if (createNew)
            {
                CreateServer(sMsg);
 
                // une fois le serveur IPC créé, on libère le mutex
                mutex.ReleaseMutex();
            }
            else
            {
                if (String.IsNullOrEmpty(sMsg)) return; 
                try
                {
                    // On attend la libération du mutex
                    mutex.WaitOne();
                    CreateClient(sMsg);
                }
                catch (Exception) { }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
        }
 
        static private void CreateServer(string sMsg)
        {
            InitServer();
            ProcessMessage(sMsg);
        }
 
        static private void InitServer()
        {
            IpcServerChannel ch = new IpcServerChannel(ChannelName);
            ChannelServices.RegisterChannel(ch, false);
            Listener o = new Listener();
            m_listener = o;
            RemotingServices.Marshal(o, ListenerName);
        }
 
        static private void CreateClient(string sMsg)
        {
            if (String.IsNullOrEmpty(sMsg)) return;
 
            string uri = "ipc://" + ChannelName + "/" + ListenerName;
            Listener o = Activator.GetObject(typeof(Listener), uri) as Listener;
            o.SendMessage(sMsg);
        }
 
        static internal void ProcessMessage(string sMsg)
        {
            // faire un truc
        }
 
        public class Listener : MarshalByRefObject
        {
            public void SendMessage(string sMsg)
            {
                Communication.ProcessMessage(sMsg);
            }
 
            //Permet de garder en vie le server IPC jusqu'a la fin du programme (par defaut, en release il est detruit au bout de 5min)
            public override object InitializeLifetimeService()
            {
                return null;
            }
        }
    }
}

le server est unique et permanent, plusieurs clients peuvent l'attaquer.

j'espere que ca va t'aider...

IPC - NamedPipe

A quoi correspond la communication en IPC?
C'est identique aux pipe nommés?
C'est juste le principe des mutex que tu crois que je dois appliquer?
Merci d'avance.

Personne a déjà eu ce problème avec les NamedPipe?.....:(