Discussion :

[ridwan]

Bonjour,

Je suis sur un projet de Chat Serveur/Client.
Mon serveur est fait de tel sorte:
L'initialisation du 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
IPAddress[] addr = Dns.Resolve("").AddressList;
                label_ip.Text = addr[0].ToString();
                //Init socket serveur
                sock_serveur = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                sock_serveur.Bind(new IPEndPoint(addr[0], 8001));
                //On initialise la liste de clients
                liste_client = new List<Client>();
                //On initialise la liste de chatroom
                liste_chan = new List<ChatRoom>();
                //1èrer chatroom, celle qui servira de fil de discussion général
                ChatRoom general = new ChatRoom("general");
                text_chan.Text = "general";
                //On l'ajoute à la liste des chatroom
                liste_chan.Add(general);
                //param serveur
                sock_serveur.Listen(10);

Un thread qui gère la connexion des clients:

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
private void wait_client()
        {
            while (true)
            {
                //On accepte le Connect du client
                Socket buf_sock = sock_serveur.Accept();
                //On cré un client buffer que l'on ajoute ensuite à la liste des clients
                buf_client = new Client(buf_sock);
                liste_client.Add(buf_client);
                //On stocke le nombre pour le thread suivant
                nombre_sock_client = liste_client.Count;
                this.Invoke(this.recept_nb_client, new object[] { nombre_sock_client.ToString() });
                //Thread de communication
                Thread reception = new Thread(new ThreadStart(ThreadProcess));
                reception.IsBackground = true;
                reception.Start();
            }
        }

A chaque fois qu'un client se connecte, je stocke le socket via une liste de clients.
A chaque fois qu'un message est envoyé, je le gère via un système de flag.

Coté client, un Form demande le nom du client puis une fois saisie, il envoi un connect au serveur.
Tout se passe très bien pour un client, mais dès qu'un deuxième client se connecte, je n'arrive plus à envoyer de message depuis le 1er client. Et ainsi de suite, si un 3ème se connecte, le 2ème ne peut plus non plus écrire. Ils reçoivent pourtant tous les messages venant du dernier connecté.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// Ajouter un client
                    client = new Client(textBox_pseudo.Text, textBox_mdp.Text, null);
                    IPAddress[] addr = Dns.Resolve("").AddressList;
                    IPAddress ipAd = addr[0];
                    client._socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    client._socket.Connect(ipAd, 8001);
                    // Envoie du msg au serveur
                    Message msgbuf = new Message(0, "serveur", textBox_pseudo.Text, textBox_pseudo.Text);
                    msgbuf.envoi_msg(msgbuf, client);
                    // Ouverture du Chat Room
                    Form_Acceuil acceuil = new Form_Acceuil(client);
                    this.Visible = false;
                    acceuil.Visible = true;

La classe Client contient le nom d'un client le socket qui le lie au serveur.
Et voici la fonction permettant d'envoyer des messages:

Code :

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

1
2
string json = JsonConvert.SerializeObject(msg);
            int nbByteSent = client._socket.Send(Encoding.UTF8.GetBytes(json));

Quelqu'un aurait-il une idée de ce qui peut provoquer cela? D'après mes test personnels, les clients envoient bien les messages, mais ils ne sont pas reçus par le serveur (quand ils ne viennent pas du dernier connecté...)

Merci d'avance!

[Invité]

Bonjour,

Ton code m'a l'air bien écrit et bien organisé. Après je n'ai pas vérifié les différents paramètres...

Au vu de la description de ton problème il me semble que cela proviendrait peut-être de la fonction "ThreadProcess" dont tu ne nous as pas montré le code.
Peut-on voir le code de "ThreadProcess"?

[ridwan]

Bonjour,

merci de ta réponse :-)

Voici ma fonction ThreadProcess:

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
private bool ok = true;
        private void ThreadProcess()
        {
            while (ok)
            {
                try
                {
                    Byte[] rep = new Byte[40000];
                    clientbuf._socket.Receive(rep);
                    string srep = Encoding.ASCII.GetString(rep);
                    Message buf = JsonConvert.DeserializeObject<Message>(srep);
                    //Si on reçoit un message d'un autre user // CHAT
                    if (buf.flag == 2 )
                    {
                        Console.WriteLine("chez :" +buf.flag+ "et msg= "+buf._msg);
                        this.Invoke(this.receptMessageRecu, new object[] { buf.destinataire, buf.sender , buf.message });
                    } 
                    //Déconnexion du client
                    else if (buf._flag == 3 && buf.message == "deco")
                    {
                        Console.WriteLine("deco");
                        clientbuf._socket.Close();
                        try
                        {
                            ok = false;
                            this.Close();
                        }
                        catch (InvalidOperationException) { }
                    }
                    //Si on reçoit la liste des users et chatrooms
                    else if (buf._flag == 4)
                    {
                        this.Invoke(this.recept, new object[] { buf.obj, buf.liste_room });
                    }
                    //chat
                    else if (buf.flag == 9)
                    {
                        this.Invoke(this.receptActualiseListeUser, new object[] { buf.destinataire, buf.obj });
                    }
                    //chat
                    else if (buf.flag == 10)
                    {
                        //MemoryStream ms = new MemoryStream(buf.image);
                        //Image img = Image.FromStream(ms);
                        //Bitmap monImage = (Bitmap)img;
                        //this.Invoke(this.receptIm, new object[] { monImage });
                    }
                }
                catch (SocketException) 
                { 
                    Console.WriteLine("Erreur Socket");
                    this.Close();
                }
                catch (NullReferenceException) { Console.WriteLine("Erreur message null"); }
            }
            Console.WriteLine("adad Stop");
        }

Elle gère la redirection des messages reçues suivant le flag indiqué(messages qui sont tous envoyés depuis le serveur).

[Invité]

OK.
Peux-tu me dire maintenant où tu prends la valeur de ta variable "clientbuf"? Je n'arrive pas à trouver où tu l'affectes?

[ridwan]

J'initialise mon clientbuf dans le constructeur de mon Form, il est envoyé comme paramètre depuis le 1er Form qui initialise la connexion (le code est plus haut)

Voici le code qui reçoit le client et le stocke dans clientbuf:

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
public Form_Acceuil(Client client,Socket sock)
        {
            InitializeComponent();
            this.clientbuf = client;
            init_Variable();
        }
 
        public void init_Variable()
        {
            liste_client = new List<string>();
            liste_chat = new List<Form_Chat>();
            //Initialisation des delegates
            recept = new receptDelegate(updateList);
            receptMessageRecu = new receptDelegateMsg(afficheMessageRecu);
            receptActualiseListeUser = new receptDelegateActu(actualiseListeUserChan);
            //Thread de réception de messages
            t2 = new Thread(new ThreadStart(ThreadProcess));
            t2.Name = "Reception";
            t2.IsBackground = true;
            t2.Start();
        }

La socket qui est reçue en même temps est la même que celle présente dans l'objet clientbuf, c'est juste le restant d'un de mes tests pour voir où était le problème..

[Invité]

OK.
Eh bien je crois que c'est là qu'il y a un soucis : "ThreadProcess" est utilisé pour communiquer depuis le serveur vers un client. Si tu n'utilises pas l'objet client correspondant (le socket que tu as eu avec le "Accept" et que tu as encapsulé avec un Client), eh bien cela ne m'étonne pas que ça fasse ce que tu décris.

Idéalement, pour être tranquille il faudrait que tu passes à ThreadProcess l'objet de type "Client" que tu as eu avec ton "Accept" pour communiquer avec.

Car actuellement tu communiques uniquement avec le dernier objet "Client" créé, et c'est pour ça que les autres n'arrivent plus à communiquer.

[ridwan]

Je me suis questionné par rapport à cela en effet.. Pourtant, la fonction ThreadProcess ne sert qu'à la réception des messages qui elle s'effectue très bien puisque tout les clients reçoivent les messages envoyés.

Pour l'envoi, c'est plutôt cette partie ci du code:

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
public Client clientbuf;   
 
        public Form_Chat(Client monClient, String nom)
        {
            InitializeComponent();
            this.textBox_message.AllowDrop = true;
            this.textBox_message.DragEnter += new DragEventHandler(textBox_message_DragEnter);
            this.textBox_message.DragDrop += new DragEventHandler(textBox_message_DragDrop);
            this.Text = nom;
            textBox_message.Focus();
            this.Visible = true;
            clientbuf = monClient;
        }
 
        #region Envoyer le message
        private void btn_send_Click(object sender, EventArgs e)
        {
            //On envoi un message destiné à la chatroom du nom de la fenêtre
            Message buf = new Message(2, this.Text, textBox_message.Text, clientbuf._login);
            buf.envoi_msg(buf, clientbuf);
            textBox_message.Text = "";
        }

Il s'agit d'une autre Form propre aux chatrooms. L'envoi ce fait dans la fonction de click sur le bouton send.
Le clientbuf reçu est celui qui est stocké précédent (donc si je suis votre cheminement, c'est celui-ci qui poserait problème.

Petite question, le fait que je stocke le client (et donc le socket ? )que je reçoit dans mon clientbuf n'assure-t-il pas le fait que j'utilise le bon socket?

[ridwan]

Peut être devrais-je le préciser, pour lancer 2 clients, il faut que je lance deux fois l'appli client, je comprends donc encore moins ce qui se passe.. Pourquoi j'aurais des problèmes avec mon socket client -> serveur (j'aurais pu comprendre si j'avais eu des soucis avec un socket serveur -> client ...)

[Invité]

Il s'agit d'une autre Form propre aux chatrooms. L'envoi ce fait dans la fonction de click sur le bouton send.
Le clientbuf reçu est celui qui est stocké précédent (donc si je suis votre cheminement, c'est celui-ci qui poserait problème.

Alors en fait la forms des "chatrooms" partage la fonction "ThreadProcess" avec la partie serveur?
Je me souviens que lorsque j'ai testé ces objets, je communiquais toujours sur l'objet "Client" que le serveur m'avais renvoyé pour une connexion bien précise.

Petite question, le fait que je stocke le client (et donc le socket ? )que je reçoit dans mon clientbuf n'assure-t-il pas le fait que j'utilise le bon socket?

Je ne pense pas, si la méthode "Accept" renvoie un socket, ce n'est pas pour rien. De plus, ce ne sont pas les mêmes instances.

Je vais me refaire un petit projet rapide de test de client serveur entre midi et deux. Il me semble qu'en plus on peut fortement simplifier le code. Par exemple, au lieu de travailler avec des sockets, on peut travailler directement avec des instances de "Client"...

Mais je vais essayer de regarder tout ça entre midi et deux (si j'ai le temps...) comme ça il y aura peut-être des simplifications possibles.

N'hésites pas aussi à regarder les exemples MSDN sur les objets "Client" et "Server".

[ridwan]

Je suis d'accord, si la fonction Accept retourne un socket ce n'est pas pour rien, c'est pour cela que je le stocke dans mon objet client.

La fonction ThreadProcess utilise des delegates (et invoke) pour faire des appels de fonctions qui vont permettre d'afficher les messages reçus dans le Form_Chat

Voulez vous que je vous mail mon projet plutôt que de tout reprendre à zéro?

[Invité]

Ah oui, si cela ne pose pas de problème...

[Invité]

J'ai bien reçu ton projet.

Bon, ce n'est pas si bien écrit que cela et ce n'est pas très bien organisé.

Je me suis aperçu qu'il y avait 2 méthodes "ThreadProcess" et que tu ne m'avais pas montré la bonne au début : tu m'avais passé la méthode "ThreadProcess" de la partie client et je voulais celle de la partie serveur. Parce que dans ce ThreadProcess tu réutilises bien la liste des clients. Du coup ce que j'ai dit au sujet de "clientbuf" n'est pas d'actualité.

Maintenant j'ai plusieurs conseils (si je peux me permettre) :
- Tu devrais le réécrire en utilisant les classes "TcpClient" et "TcpListener" au lieu de la classe "Socket" ce sera beaucoup plus lisible et tu t'y retrouveras mieux.
- Utilises plutôt la classe "Task" à la place de la classe "Thread" (puisque apparamment tu utilises le Framework 4.5). La classe "Thread" c'est hasbeen.
- Attention aussi aux avertissements de compilation, et entre autres, tu ne devrais pas utiliser des méthodes obsolètes.

[ridwan]

Je ne connaissais pas l'existence de cette classe TCPClient à vrai dire. Notre professeur nous a parlé des sockets et puis hop faisons un chat.. Je regarderais cette classe dès ce soir si elle peut me simplifier la tâche.

[Invité]

Ah mince tu étais là... Du coup j'ai modifié mon message ci-dessus pensant que tu ne serais pas là avant...

[Invité]

Je ne connaissais pas l'existence de cette classe TCPClient à vrai dire. Notre professeur nous a parlé des sockets et puis hop faisons un chat.. Je regarderais cette classe dès ce soir si elle peut me simplifier la tâche.

N'hésites pas à consulter la doc MSDN là-dessus :
TcpClient : http://msdn.microsoft.com/fr-fr/libr...v=vs.110).aspx
TcpListener : http://msdn.microsoft.com/fr-fr/libr...v=vs.110).aspx

[ridwan]

Merci, je regarde ça réellement ce soir du coup.

Bonne journée à vous

[ridwan]

Bon j'ai trouvé d'où venait mon problème.
Au niveau du serveur, je n'effectuais l'écoute (Receive sur socket) seulement sur le dernier client connecté, d'où le fait que seul le dernier pouvait communique alors que tous pouvait recevoir les messages.

Encore merci, je regarderais tout de même les deux classes dont vous m'avez parlé ainsi que les Task.

Juste une dernière question: Vous m'avez dit que le code n'était pas très bien écrit, ni organisé. Comment devrais-je modifier les choses? A quoi ressemblerait un code mieux organisé? Mieux écrit? Je ne demande qu'à progresser.

Merci d'avance

[Invité]

Bon j'ai trouvé d'où venait mon problème.
Au niveau du serveur, je n'effectuais l'écoute (Receive sur socket) seulement sur le dernier client connecté, d'où le fait que seul le dernier pouvait communique alors que tous pouvait recevoir les messages.

Oui, c'est bien ce que je pensais. Mais comme je disais plus haut, au début tu m'avais montré la méthode "ThreadProcess" de la partie client au lieu du "ThreadProcess" de la partie serveur.

Juste une dernière question: Vous m'avez dit que le code n'était pas très bien écrit, ni organisé. Comment devrais-je modifier les choses? A quoi ressemblerait un code mieux organisé? Mieux écrit? Je ne demande qu'à progresser.

Merci d'avance

C'est un bon état d'esprit que tu as, c'est bien.

En fait, au niveau du code il y a plusieurs choses qui feront qu'un code soit plus lisible :
- Des nomenclatures pour voir d'un seul coup d'œil certaines informations comme par exemple : Est-ce que telle variable est une variable de classe ou une variable de méthode? Est-ce que telle variable est une propriété ou une variable membre?
En C#, la convention habituelle c'est : de mettre les noms de variables membres avec un underscore au début puis première lettre en minuscule et les autres lettres comme tu veux; Exemple : "_maVariable"; Pour les propriétés, première lettre en majuscule (ex: "MaPropriete"); pour les méthodes, idem que pour les propriétés; variables de méthode : comme les variables membres mais sans underscore (ex : "maVariableLocale"). Après rien ne t'empêche d'avoir une autre nomenclature perso mais l'intérêt de la nomenclature comme je disais est que quelqu'un d'autre puisse facilement relire le code.
- Avec Visual Studio 2013, tu peux mettre plusieurs projets dans une même solution. Cela te facilitera la vie de mettre le projet "Client" et le projet "Serveur" dans la même solution.
- Bien dissocier la partie "interface utilisateur" et la partie "logique métier". Avec la méthodologie orientée objet c'est assez facile à mettre en place. Cela consiste à dire que telle classe est associée à tel bouton que va faire comme action appel à une méthode de la partie de la logique métier.
Exemple de partie "logique métier" :

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
 
//Exemple d'une classe de "logique métier"
class MaGestionServeur
{
    //Mettres les variables privées...
 
    //Constructeur
    public MaGestionServeur()
    {
         //Initialisation de variables etc...
    }
 
    //Un exemple de méthode qui peut être appelée à partir d'un IHM...
    public Initialisation()
    {
        //D'autres initialisations par exemple...
    }
}

Exemple d'un IHM qui l'appelle (exemple de Windows forms)

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
 
sealed class MainForm : Form
{
    MaGestionServeur _maGestionServeur;
    public MainForm()
    {
        _maGestionServeur = new MaGestionServeur();
    }
 
    protected override void OnLoad(EventArgs e)
    {
        _maGestionServeur.Initialisation();
    }
 
}

Ainsi cela permettra aussi de bien compartimenter les choses : la cuisine interne de "MaGestionServeur" ne regarde pas la classe "MainForm".

Cela dit, après comme il s'agit d'une application qui doit être vite faite dans le cadre d'un TP (j'ai connu ça quand j'étais étudiant), je comprend qu'il faut faire au plus vite et tout. Mais ce sont de bons conseils et de bonnes bases quand tu auras à faire du développement plus tard.

Maintenant, tu as un projet qui fonctionne comme tu veux et en plus il est "éphémère" (car seulement pour le TP concerné) donc pour ton TP ne le réécris pas s'il fonctionne. Ces conseils c'est juste pour des projets qui peuvent "durer dans le temps"....

Ou alors si tu le réécris quand même malgré tout, conserves bien ton ancienne version.

[ridwan]

Merci beaucoup pour ces réponses. J'en prend note et je tâcherais de les appliquer pour me prochains projets.

Encore merci à vous et bonne continuation