Discussion :

[elmcherqui]

bonjour , je suis entrain de faire une application client/server avec des socket en asynchrone . je pense que tous est parfait sauf un petit probleme lorsque la connection veut se faire :

voila ce que le client me dit :

Une exception non gérée du type 'System.InvalidOperationException' s'est produite dans System.Windows.Forms.dll

Informations supplémentaires*: Opération inter-threads non valide*: le contrôle 'affichageClient' a fait l'objet d'un accès à partir d'un thread autre que celui sur lequel il a été créé.

et voila ce que me dit le server :

Une exception non gérée du type 'System.InvalidOperationException' s'est produite dans System.dll

Informations supplémentaires*: Opération inter-threads non valide*: le contrôle 'affichage' a fait l'objet d'un accès à partir d'un thread autre que celui sur lequel il a été créé.

j'ai souligne la partie du code qui pose probleme dans le client en rouge :


voila le code client :

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
namespace Client
{
    class client
    {
        
        private ListBox affichageClient;
        private Socket socketClient;
        private byte[] bufferEcriture = new byte[400];
        private byte[] bufferLecture  = new byte[400];


        public client(ListBox lbc)
        {
            affichageClient = lbc;
        }
        public void seConnecterAuServeur()
        {
            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socketClient.BeginConnect(new IPEndPoint(IPAddress.Parse("192.168.1.10"), 123), new AsyncCallback(connectCallback), socketClient);
        }
        private void connectCallback(IAsyncResult ar)
        {
            try
            {
                Socket socket = (Socket)ar.AsyncState;
                socketClient = socket;
                socket.EndConnect(ar);
                affichageClient.Items.Add("Connecte au serveur");  // erreur ici 

                socketClient.BeginReceive(bufferLecture, 0, bufferLecture.Length, SocketFlags.None,
                    new AsyncCallback(ReceiveCallback), socketClient);
            }
            catch (SocketException ex)
            {
                affichageClient.Items.Add(ex.Message);
            }

        }
        private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                Socket socket = (Socket)ar.AsyncState;
                int read = socket.EndReceive(ar);

                if (read > 0)
                {
                    affichageClient.Items.Add("Le serveur Dit : " + Encoding.ASCII.GetString(bufferLecture));
                    Buffer.SetByte(bufferLecture, 0, 0);
                    socketClient.BeginReceive(bufferLecture, 0, bufferLecture.Length, SocketFlags.None,
                    new AsyncCallback(ReceiveCallback), socketClient);
                }
            }
            catch (SocketException ex)
            {
                affichageClient.Items.Add(ex.Message);
            }
        }
        public void sendMessage(string Message)
        {
            bufferEcriture = Encoding.ASCII.GetBytes(Message);
            socketClient.BeginSend(bufferEcriture, 0, bufferEcriture.Length, SocketFlags.None,
                new AsyncCallback(sendCallback), socketClient);
        }
        private void sendCallback(IAsyncResult ar)
        {
            try
            {
                Socket socket = (Socket)ar.AsyncState;
                int send = socket.EndSend(ar);
                affichageClient.Items.Add("Message envoye " + send + " bytes envoyees{");
            }
            catch (SocketException ex)
            {
                affichageClient.Items.Add(ex.Message);
            }
        }
        public void Close()
        {
            socketClient.Shutdown(SocketShutdown.Both);
            socketClient.Close();
            affichageClient.Items.Add("Connexion fermee");
        }
    }
}

et le code serveur :

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
namespace server
{
    class serveur
    {
 
        private Socket server;
        private Socket client;
        private ListBox affichageServeur;
        private byte[] bufferLecture = new byte[400];
        private byte[] bufferEcriture= new byte[400];
 
 
        public serveur(ListBox ecranServeur)
        {
            affichageServeur = ecranServeur;
        }
        public void demmarrerLeServeur()
        {
            server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            server.Bind(new IPEndPoint(  IPAddress.Parse("192.168.1.10"), 123));
            server.Listen(20);
            server.BeginAccept(new AsyncCallback(acceptCallback), server);
        }
        private void acceptCallback(IAsyncResult ar)
        {
            try
            {
                Socket unClient = (Socket)ar.AsyncState;
                client = unClient;
                unClient.BeginReceive(bufferLecture, 0, bufferLecture.Length, SocketFlags.None, new AsyncCallback(ReceiveMessageCallback), unClient);
            }
            catch (SocketException ex)
            {
                affichageServeur.Items.Add(ex.Message);                              
            }
        }
        private void ReceiveMessageCallback(IAsyncResult ar)
        {
            Socket leClient = (Socket)ar.AsyncState;
            client = leClient;
            int read = leClient.EndReceive(ar);
            if (read > 0)
            {
                affichageServeur.Items.Add("Client dit : " + Encoding.ASCII.GetString(bufferLecture));
                Buffer.SetByte(bufferLecture, 0, 0);
                client.BeginSend(bufferEcriture, 0, bufferEcriture.Length, SocketFlags.None, new AsyncCallback(SendCallback), client);
                client.BeginReceive(bufferLecture, 0, bufferLecture.Length, SocketFlags.None, new AsyncCallback(ReceiveMessageCallback), client);
 
            }
        }
        public void Send(string message)
        {
 
            client.BeginSend(bufferEcriture, 0, bufferEcriture.Length, SocketFlags.None, new AsyncCallback(SendCallback), client);
 
        }
        private void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket socket = (Socket) ar.AsyncState;
                int send = socket.EndSend(ar);
                affichageServeur.Items.Add("Message Envoye " + send);
            }
            catch( SocketException ex)
            {
                affichageServeur.Items.Add(ex.Message);
            }
        }
 
        public void CloseClient()
        {
            client.Close();
            affichageServeur.Items.Add("Client arrete");
        }
        public void CloseServer()
        {
            CloseClient();
            server.Close();
            affichageServeur.Items.Add("Le serveur a ete arrete");
        }
    }
}

apparement c'est un probleme tres courant dans le reseau en mode asynchrone et la j'aimerais trouver le moyen de pas avoir de conflits entre les threads , j'ai entendu parler des delegues mais comment ?

Merci pour votre futur aide qui me sera tres tres precieuse et je vous souhaite une bonne soiree.

[meziantou]

En effet il n'est pas possible de modifier l'interface graphique à partir d'un autre thread que celui de la fenêtre. Il existe un composant BackgroundWorker qui permet de résoudre ton problème.

[elmcherqui]

merci d'avoir repondu , mais cette classe me parait comme une usine a gaz , tres radicale a utiliser en dernier recours .
y'aurais pas un moyen plus simple ?

[meziantou]

Essayes de te renseigner sur la méthode Invoke ou BeginInvoke et EndInvoke du ListBox.

[sevyc64]

Les 2 erreurs n'ont rien à voir l'une avec l'autre mais se sont 2 erreurs identiques, 2x la même erreur en fait.

Il faut passer par les delegate pour pouvoir communiquer entre les threads

Cherche les infos sur l'utilisation des méthodes delegate, et sur la communication inter-threads.

Tiens, regarde cette page sur MSDN : http://msdn.microsoft.com/fr-fr/library/ms171728.aspx

[Graffito]

Essayes de te renseigner sur la méthode Invoke ou BeginInvoke et EndInvoke du ListBox

+1 : BeginInvoke().

[elmcherqui]

merci beaucoup , beaucoup , probleme regle , avec beginInvoke sa marche super bien , utilisant les delegues . merci beaucoup

[meziantou]

de rien

[hichem147]

Bonjour

tu dis que le beginInvoke t'a résolu ton pb
est ce que tu peux donner la solution avec du code
parce que tous les codes sources avec les sockets et les forms
donnent TOUS la même erreur
c'est à se poser la question si
les codes sources ont été testés !!!

merci une autre fois pour donner le code qui t'a aider à résoudre le pb.