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.