Bonjour amis Zéros !

J'aimerai obtenir une petite aide sur l'envoi d'un paquet (principe client->serveur).

J'ai tout d'abord commencé par établir une connexion sur le site sous cette forme :

TcpClient clientSocket = new TcpClient();
NetworkStream serverStream = default(NetworkStream);

try
{
     clientSocket.Connect("127.0.0.1", 15555);
     serverStream = clientSocket.GetStream();
     Console.WriteLine("Connexion établie !");
}
catch (Exception)
{
     Console.WriteLine("Problème de connexion.");
     Console.Read();
}

Jusque là pas de problèmes, la connexion est un succès. Maintenant je ne trouve pas de bonnes solutions pour envoyer un paquet en hexadécimal sur cette adresse.

Je vais expliquer très clairement mon cas :

En C++, il suffit de créer un tableau de type char sous cette forme (par exemple) char packets[16] = {0x00,0xA0,0x4F}; et de l'envoyer avec la fonction send(); en indiquant les paramètres de connexion, etc.

Mais je ne sais pas comment le faire en C#, j'ai regardé beaucoup de guide, mais je ne trouve pas pour mon cas.

Si quelqu'un peut me montrer comment le faire, ça ma'aiderai beaucoup ! Merci d'avance.

Utilise la méthode GetStream() du TcpClient pour récupérer un Stream, puis crée un StreamWriter et un StreamReader en leur donnant le Stream. Ensuite c'est juste du writer.Write().


PS : Pas besoin d'écrire default(NetworkStream), la valeur par défaut de tous les types passés par référence est toujours null.
PPS : Pas besoin d'écrire explicitement que tu veux catcher une Exception, c'est la valeur par défaut ; il suffit d'écrire catch { ... }

Merci pour ces quelques précisions, je vais essayer ça tout à l'heure.

Mais je dois stocker les valeurs hexadécimales dans un char ou dans un byte ?

As-tu un petit exemple à me faire ? Sinon je peux essayer de regarder ce que tu m'as donné et je te dit si ça fonctionne.

Dans un byte, c'est le .NET du char du C++
Un char en .NET c'est uniquement pour les caractères, en fait non mais c'est surtout utilisé pour ça.
De plus les fonctions réseau demandent des tableaux de byte donc c'est ce qu'il faut prendre

Merci pour la réponse ! C'est pour ça que je demandais, j'avais un petit doute.

Le fait est que les exemples sont un peu ambiguës.

J'ai quelques paquets à envoyer à la suite.

Par exemple les deux premiers paquets sont :

- 0x5E,0x70,0x68,0xA5,0x00,0x01,0x38,0x84,0x50,0x31
- 0xAC,0x57,0x11,0x33,0x72,0x00,0xF0,0xFF,0x4A,0x76

j'ai trouvé une méthode sur internet :

byte[] packetData = System.Text.ASCIIEncoding.ASCII.GetBytes("<Paquets>");

     string IP = "127.0.0.1";
     int port = 15555;

     IPEndPoint ep = new IPEndPoint(IPAddress.Parse(IP), port);

     Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

     client.SendTo(packetData, ep);

Je ne sais pas si c'est la bonne solution. Je ne sais pas non plus si je dois envoyer mes deux trames à la suite ou recréer un byte pour chaque trame.

Par exemple faire :

byte[] packetData = System.Text.ASCIIEncoding.ASCII.GetBytes("0x5E,0x70,0x68,0xA5,0x00,0x01,0x38,0x84,0x50,0x31, 0xAC,0x57,0x11,0x33,0x72,0x00,0xF0,0xFF,0x4A,0x76");

Ou :

byte[] packetData = System.Text.ASCIIEncoding.ASCII.GetBytes("0x5E,0x70,0x68,0xA5,0x00,0x01,0x38,0x84,0x50,0x31");

byte[] packetData2 = System.Text.ASCIIEncoding.ASCII.GetBytes("0xAC,0x57,0x11,0x33,0x72,0x00,0xF0,0xFF,0x4A,0x76");

Avez-vous une idée précise sur la question/méthode ?

Je trouve que c'est vraiment plus simple en C++, mais je souhaite le faire en C#.

Pourquoi faire compliqué quand on peut faire simple ?

byte[] packetData = new byte[] { 0x5E, 0x70, ... };

La méthode GetBytes te permet d'obtenir les bytes à partir du texte, par exemple "Toto" sera converti en un tableau de 4 bytes qui sont les caractères 'T', 'o', 't', 'o'.

Effectivement c'est plus simple comme ça !

Je débute dans les communications client->serveur, j'ai encore un peu de mal à saisir toutes les notions.

Je suis dans la bonne voie avec cette méthode donc (je vais faire des tests~) ?

Je relance un petit coup !

J'ai essayé de faire comme ça :

static void Main(string[] args)
{
            TcpClient clientSocket = new TcpClient(AddressFamily.InterNetwork);
 
            // Les paquets
            byte[] packet1 = new byte[] { 0x4D, 0x01 };
            byte[] packet2 = new byte[] { 0x4F, 0x01, 0x00, 0x00, 0x00, 0x00 };
            byte[] packet3 = new byte[] { 0x4F, 0xE1, 0x78, 0x70, 0x01, 0x00 };
 
            try
            {
                // Les connexions
                clientSocket.Connect("127.0.0.1", 3500);
                Console.WriteLine("Connexion établie !");
 
                string IP = "127.0.0.1";
                int port = 3500;
 
                IPEndPoint ep = new IPEndPoint(IPAddress.Parse(IP), port);
 
                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.IP);
 
                client.Connect("127.0.0.1", 3500);
 
                // Les paquets sont envoyés ici
                client.SendTo(packet1, 0, 2, SocketFlags.None, ep);
                Thread.Sleep(10);
                client.SendTo(packet2, 0, 6, SocketFlags.None, ep);
                Thread.Sleep(10);
                client.SendTo(packet3, 0, 6, SocketFlags.None, ep);
 
                Console.WriteLine("Paquets envoyés !");
                Console.Read();
            }
            catch
            {
                Console.WriteLine("Problème de connexion.");
                Console.Read();
            }
}

Mais ça ne fonctionne pas. Je n'ai pas d'erreurs et mes paquets sont bons, je suis sûr de ça.

Je me demande si je fais une bonne utilisation, vous voyez quelque chose qui cloche ?

Tu veux dire à part le fait que tu utilises à la fois un TcpClient et un Socket ?

Justement !

Je ne suis pas encore à l'aise avec ça, par contre en C++ ça passe tout seul. Mais je souhaite le faire en C#.

Mais si tu vois les deux méthodes, c'est simplement parce que j'ai essayé beaucoup de choses et je n'ai donc pas un code optimisé.

Petit exemple fait à l'arrache :

// Programme serveur
static void Main(string[] args)
{
    Console.WriteLine("Initializing Server...");
    var listener = new TcpListener(IPAddress.Loopback, 3500);
    listener.Start();

    Console.WriteLine("Waiting for Client...");
    var client = listener.AcceptTcpClient();
    var reader = new BinaryReader(client.GetStream());

    Console.WriteLine("Receiving packet...");
    int packetSize = reader.ReadInt32();
    byte[] bytes = reader.ReadBytes(packetSize);
    client.Close();

    Console.Write("Received : ");
    Console.WriteLine(string.Join(",", bytes));

    Console.WriteLine("Done.");
    client.Close();
    listener.Stop();

    Console.ReadLine();
}

// Programme client
static void Main(string[] args)
{
    byte[] packet = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 };

    Console.WriteLine("Connecting to Server...");
    var client = new TcpClient("localhost", 3500); // localhost à remplacer par IP du serveur si nécessaire
    var writer = new BinaryWriter(client.GetStream());

    Console.WriteLine("Sending Packet...");
    writer.Write(packet.Length);
    writer.Write(packet);

    Console.WriteLine("Done.");
    client.Close();
    Console.ReadKey();
}

Donc ce qu'il faut retenir ici, c'est que pour échanger des données via un TcpClient et/ou un TcpListener il suffit de créer un BinaryReader ou un BinaryWriter avec leur stream.

Bon... ça ne fonctionne toujours pas.

Je vais essayer de tout revoir, je vous tiens au courant demain et merci encore pour l'aide !