Discussion :

[dIwAmIb]

Bonjour à toutes et à tous.

Je vais essayer de faire simple pour décrire mon problème :

J'ai un service dans laquelle j'appelle une méthode à travers un thread se trouvant dans une autre classe qui fait ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
serverThread = new Thread(HttpServer.StartListening);
 
public static void StartListening()
{    
     while(run)
     {
          ....
          TcpClient client = server.AcceptTcpClient();
          ....
     }
}

Le problème est que quoi qu'il arrive je me retrouve avec un appel bloquant puisque meme si ma variable run est a false l'appel à déjà était fait.

Du coup je n'arrive pas à arrêter mon thread, et je ne peut pas arréter proporement mon service.

Comment faire pour arreter ce thread quand i lest en appel bloquant ??

Merci d'avance.

[smyley]

Peut être du côté de BeginAcceptTcpClient ?

[dIwAmIb]

Oui merci j'ai utilisé cela , me reste des problèmes à corriger car il reste toujours quel que chose qui s'arrête mal. je vous tiens au courant.

Merci

[OjBarbare]

Salut
j'ai le meme souci, et je ne pense pas que BeginAccept puisse regler le probleme, car dans une boucle d'ecoute il y aura toujours un blocage au niveau de la socket.
J'ai essayé de mettre en reference globale ma socket (qui est plutot un UdpClient dans mon cas) pour qu'elle soit accessible depuis le thread principale pour la fermer, mais ça ne marche pas correctement...

[OjBarbare]

en fait ça marche bien, mais la fonction bloquante de reception tombe en erreur... donc c'est pas très propre, faut intercepter l'erreur pour pas que ça plante

[dIwAmIb]

J'ai réussi à faire en sorte de ne pas devoir intercepter l'erreur et mon service s'arrête enfin parfaitement après 2 3 modifs.

Voici comment j'ai fait pour eviter de devoir l'intercepter :

J'ai utilisé simplement un boolean qui des que j'invoque ma méthode OnStop du service il appel une méthode se trouvant dans ma classe listener qui passe mon boolean a false.

il ne te reste plus donc qu'a faire un petit if avant d'écouter une connexion entrante :

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
public static void DoAcceptTcpClientCallback(IAsyncResult ar)
        {
            if (run)
            {
                Tracer.Trace("Connexion détectée");
 
                // Appel bloquant pour accepter les requêtes
                using (TcpClient client = ((TcpListener)ar.AsyncState).EndAcceptTcpClient(ar))
......
            }
            else
            {
                tcpClientConnected.Set();
            }
                {

Pour bien arrêter ton service fais comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
            HttpServer.Arret(); // méthode qui passe le boolean a false;
 
 
            Dispose();
            Tracer.Trace("Canstop");
            CanStop = true;

la méthode arrêt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
        public static void Arret()
        {
            run = false;
            tcpClientConnected.Set();
            listener.Stop();
        }

l'utilisation de l'espèce de mutex :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
       // Permet de faire un genre de mutex.
        private static readonly ManualResetEvent tcpClientConnected = new ManualResetEvent(false);

la méthode StartListening :

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
       public static void StartListening()
        {
 
            IPAddress localAddr = IPAddress.Any;
            // TcpListener server = new TcpListener(port);
            listener = new TcpListener(localAddr, Port);
            Tracer.Trace("Création du listener");
            // Start listening for client requests.
            listener.Start();
            try
            {
                while (run)
                {
                    tcpClientConnected.Reset();
                    listener.BeginAcceptTcpClient(DoAcceptTcpClientCallback, listener);
                    // Wait until a connection is made and processed before
                    tcpClientConnected.WaitOne();
 
                }
            }
            catch (Exception e)
            {
                Tracer.Error("Exception: {0}", e);
            }
        }

Dis moi si tu as réussis !