Fermer une application qui écoute sur un port

Version imprimable

Bonjour à tous,

J'ai creer une petite application qui écoute sur un port en udp pour l'entreprise dans laquelle je travail. Ce soft ce lance à chaque démarrage.

Mais lorsque l'utilisateur veut fermer sa session, il lui marque le message "Termer maintenant" enfin vous voyez :p L'application ne se ferme pas. Le problème se pose sur 300 pc alors si vous pouviez m'aider :-)

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
public partial class Form1 : Form
    {
        public bool Continue = true;
 
        public UdpClient udpClient;
 
        public Form1()
        {
            InitializeComponent();
            this.FormClosing += new FormClosingEventHandler(Form1_FormClosing);
        }
 
        void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            ((Form1)sender).Continue = false;
            udpClient.Send(Encoding.UTF8.GetBytes("Close"), Encoding.UTF8.GetBytes("Close").Length, "127.0.0.1", 46870);
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            udpClient = new UdpClient(46870);
            //IPEndPoint object will allow us to read datagrams sent from any source.
            IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 46870);
            while (this.Continue == true)
            {
                // Blocks until a message returns on this socket from a remote host.
                Byte[] receiveBytes = udpClient.Receive(ref RemoteIpEndPoint);
 
                string returnData = Encoding.UTF8.GetString(receiveBytes);
 
                if (returnData != "Close")
                {
                    // Uses the IPEndPoint object to determine which of these two hosts responded.
                    MessageForm mf = new MessageForm();
                    mf.richTextBox1.Rtf = returnData;
                    mf.ShowDialog(this);
                    this.ShowInTaskbar = false;
                    this.Visible = false;
                }
            }
            udpClient.Close();
        }
    }

22/11/2011, 10h25
tomlev

Euh... et à part qu'elle se ferme pas, elle fonctionne ton appli ? 8O

Non parce que là tu fais une boucle infinie dans le Load, donc le thread UI est tout le temps occupé à traiter cette boucle, et ne traite donc jamais les messages envoyés à la fenêtre... et donc elle ne reçoit pas le message indiquant la fermeture, et ne se ferme pas.

Il faut effectuer le traitement dans un autre thread, par exemple en utilisant un BackgroundWorker.
22/11/2011, 10h57
dogua

Bonjour,

Oui l'application remplis son rôle.
En faite cette application sert à afficher un message avec une certaine présentation dans une fenêtre modal sur tout notre parc informatique pour avertir les employés d'une information urgente.

Donc oui l'application tourne bien, mais l'utilisation de udpclient.receive() block le thread en cours...

Pourrais tu m'expliquer ton idée avec le background worker ?

Merci,
22/11/2011, 11h03
tomlev

Citation:

Envoyé par dogua

Donc oui l'application tourne bien, mais l'utilisation de udpclient.receive() block le thread en cours...

Effectivement UdpClient.Receive est un appel bloquant, mais même sans ça il ne faut pas mettre une boucle infinie dans le thread UI.

Citation:

Envoyé par dogua

Pourrais tu m'expliquer ton idée avec le background worker ?

Bah tu fais la même chose, mais dans une tâche d'arrière plan (dans l'évènement DoWork du BackgroundWorker). Désolé mais je ne vais pas te faire un cours sur le BackgroundWorker, il y a des infos à ce sujet partout sur le net... Si tu as des questions plus précises, je peux essayer d'y répondre.
22/11/2011, 11h59
Pol63

urgent donc j'imagine important, auquel cas pourquoi l'udp, un protocole qui accepte la perte de paquet ?

Citation:

Envoyé par Pol63

urgent donc j'imagine important, auquel cas pourquoi l'udp, un protocole qui accepte la perte de paquet ?

En effet, c'est urgent. Même l'implémentation du soft devait être faite rapidement, c'est pourquoi j'ai utiliser udp pour plus de facilité. Cependant maintenant que l'application est déployée, je travaille à implementer une solution utilisant le protocole TCP.

Pour revenir au Sujet, j'ai résolu le problème en utilisant des threads :)

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
static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
 
            Worker workerObject = new Worker();
            Thread workerThread = new Thread(workerObject.DoWork);
 
            workerThread.Start();
        }
    }
 
    public class Worker
    {
        private UdpClient udpClient = new UdpClient(46870);
        private IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 46870);
 
        public void DoWork()
        {
 
            while (!_shouldStop)
            {
                try
                {
                    Byte[] receiveBytes = udpClient.Receive(ref RemoteIpEndPoint);
                    MessageForm.Message = Encoding.UTF8.GetString(receiveBytes);
 
                    Thread thread = new Thread(ShowMessage);
                    thread.Start();
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message);
                }
            }
        }
 
        public void RequestStop()
        {
            _shouldStop = true;
        }
 
        private void ShowMessage()
        {
            MessageForm foo = new MessageForm();
            foo.richTextBox1.Rtf = MessageForm.Message;
 
            foo.Shown += (sender, e) => 
            {
                Control.CheckForIllegalCrossThreadCalls = false; 
                Control.CheckForIllegalCrossThreadCalls = true; 
                foo.TopMost = true;
            }; 
 
            Application.Run(foo);
        }
 
        private volatile bool _shouldStop;
    }