Quitter un Thread TCPListener

Version imprimable

Bonjours,

dans mon programme je lance un Thread qui va faire l'écoute d'un port TCP et va attendre un connexion. (Il répète les connexions en boucle)
Code:

1 2 3 4 5 6 7 8 9 10 11 IPAddress localAddr = IPAddress.Parse(m_ipEcoute); m_serveur = new TcpListener(localAddr, m_port); m_serveur.Start(); m_client = m_serveur.AcceptTcpClient(); try { m_stream = m_client.GetStream(); } catch { }
Comment on fait pour arrêter proprement l'écoute de ce serveur (qui se trouve sur un autre thread)?

- Stop() sur l'objet de fonctionne pas
- Tuer le processus ne fonctionne pas non plus
Peu importe ce que je fais, le thread reste toujours ouvert même quand je ferme le programme. (Ça empêche même la fermeture de Windows)

Merci de votre aide

10/04/2009, 08h53
Immobilis

Salut,

Y'a un bout de code ici tiré de la MSDN. Le listner.stop() est dans le finally. Peut-être la différence qui fera que ça marche. Il me semble qu'il faut aussi fermer le client.

A+
14/04/2009, 16h20
deejay2221

Merci Immobilis

En fais mon problème n'est pas là. J'ai 2 programmes complets qui fonctionnent bien. Je peut faire plusieurs connexions sans troubles.

Le problème est justement qu'une fois que la connexion est finie, la boucle recommence et le Thread attend pour un nouveau client. Je dois alors fermer le serveur à partir d'un autre Thread (et Stop() ne fonctionne pas). Parce que même en quittant, le programme reste en mémoire à attendre des connexions. Pire que ça, le système ne se ferme pas (il y a un bug) lorsque le Thread est ouvert. On doit ouvrir le gestionnaire de tâche pour tuer le processus.

Je vais essayer une solution avec un serveur asynchrone. Je vais utiliser la fonction EndAcceptTcpClient. J'ai déjà régler des problèmes de Thread en changeant la méthode pour une méthode asynchrone. Alors on vera bien.

Je vous redonne des nouvelles
Merci d'avance si vous avez d'autres suggestions
14/04/2009, 22h59
deejay2221

Ça ne fonctionne pas plus en mode Asynchrone (ou je ne sais pas comment faire). La fonction EndAcceptTcpClient demande un résultat reçu du BeginAcceptTcpClient.

Je suis à court de ressource. Si quelqu'un à des idées ou un lien qui pourrais m'aider.
Merci.
14/04/2009, 23h23
Immobilis

Si c'est pas trop long, peux-tu montrer la totalité du code qui met ton serveur en écoute?

C'est en effet assez long comme code, mais voici ce que ça donne :

Quelques fonctions de la classe SERVEUR:

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
public class ClReseauTCPListener
{
    private string m_ipEcoute;
    private int m_port;
    private TcpListener m_serveur;
    private TcpClient m_client;
    private NetworkStream m_stream;
    Object myLockRead;
    Object myLockWrite;
 
    public ClReseauTCPListener(string p_ipEcoute, int p_port)
    {
        m_ipEcoute = p_ipEcoute;
        m_port = p_port;
        myLockRead = new Object();
        myLockWrite = new Object();
    }
 
    ~ClReseauTCPListener()
    {
        try
        {
            Terminer();
        }
        catch
        { }
    }
 
    public void Initialiser()
    {
        IPAddress localAddr = IPAddress.Parse(m_ipEcoute);
        m_serveur = new TcpListener(localAddr, m_port);
        m_serveur.Start();
 
        m_client = m_serveur.AcceptTcpClient();
        try
        {
            m_stream = m_client.GetStream();
        }
        catch
        { }
    }
 
    public void Terminer()
    {
        m_client.Close();
        m_serveur.Stop();
    }
 
    // Autres fonctions pour envoyer et recevoir (...)
}

Quelques fonctions de la classe de TRANSFERT :

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
private ClDocument m_doc;
private ClReseauTCPListenerAsync m_tcpListener;
private bool m_quitterThread;
private Thread m_threadReseau;
 
private void InitialiserServeur()
{
	// (...)
    m_tcpListener = new ClReseauTCPListener(ClReseauMachine.AdresseIPPrincipale(), m_doc.Configurations.NoPort);
}
 
public void AttendreConnexion()
{
    // Pour chaque connexion complète avec un client
    for(;;)
    {
        m_quitterThread = false;
        InitialiserServeur();
 
        m_tcpListener.Initialiser();
 
        try
        {
        	// Authentification avec mots de passe
            // À ce point-ci, la connexion est lancée.
            if (!AuthentifierClient())
            {
                // Échec d'authentification (...)
            }
            else
            {
                // Envoie des données (...)
            }
        }
        catch
        { 
            // Afficher message d'erreur (...)
        }
        finally
        {
            m_tcpListener.Terminer();
        }
 
        if (m_quitterThread)
            break;
    }
}
 
public void FermerServeur()
{
    try
    {
        m_quitterThread = true;
        m_tcpListener.Terminer();
    }
    catch
    { }
}
 
public void ConnexionServeur()
{
    Thread thread = new Thread(new ThreadStart(AttendreConnexion));
    m_threadReseau = thread;
    thread.Start();
}

Dans mon programme :

Code:

m_doc.TraficReseau.ConnexionServeur()

Donc ce qui ne fonctionne pas c'est de soit
- Appeler la fonction FermerServeur()
- Tuer le processus
- Utiliser la même méthode mais avec les fonctions asynchrones et d'essayer FermerServeur() ou tuer le processus

Merci d'avance pour vos réponses

20/04/2009, 21h49
deejay2221
Bon! Finalement, j'ai trouvé la solution.

Pour ceux qui sont intéressés :

Le thread des serveurs TCPListener sont dit "bloquants". Alors même si on quitte le programme, ça ne fait rien. Pour contourner ça, on a seulement à faire ceci :
Code:

1 2 3 TCPListener serveur; //... serveur.Server.Blocking = false
Détail supplémentaire : Je ne sais pas si ça fait une différence mais j'ai créé un serveur en mode asynchrone.
09/08/2010, 23h35
neylud

Bon, je remonte ce topic d’une année, mais il vient de m’être utile.

Je viens d’avoir le même soucis avec un System.Net.Sockets Socket où j’utilise la methode accept() dans un Thread. C’est cette méthode qui bloquait tout, et qui empêchait de tuer proprement le Thread.

Passer la propriété Blocking à false a été la solution, même en mode synchrone pour ma part.

Voila merci pour ce topic, ça m’a fait gagner un temps précieux.
10/08/2010, 00h08
hegros

Le plus simple et efficace pour arrêter un thread est de lui envoyer le message abort. Dans le code de thread attrapait l'exception et quitter proprement votre thread(libération des ressources,..)