IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

NamedPipeServer Instance existante


Sujet :

C#

  1. #1
    Membre régulier
    Inscrit en
    Avril 2005
    Messages
    9
    Détails du profil
    Informations forums :
    Inscription : Avril 2005
    Messages : 9
    Par défaut 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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  2. #2
    Membre éclairé
    Profil pro
    Inscrit en
    Octobre 2007
    Messages
    1 002
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2007
    Messages : 1 002
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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...

  3. #3
    Membre régulier
    Inscrit en
    Avril 2005
    Messages
    9
    Détails du profil
    Informations forums :
    Inscription : Avril 2005
    Messages : 9
    Par défaut 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?.....

Discussions similaires

  1. Réponses: 2
    Dernier message: 23/11/2012, 15h25
  2. Réponses: 6
    Dernier message: 22/04/2010, 12h54
  3. Réponses: 1
    Dernier message: 28/09/2007, 09h42
  4. [Stratégie] Récupérer une instance existante
    Par cmoulin dans le forum Général Java
    Réponses: 14
    Dernier message: 11/05/2004, 15h48
  5. Réponses: 2
    Dernier message: 26/02/2003, 11h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo