Discussion :

[Invité]

Bonjour,

Voici mon problème, je souhaite envoyer plusieurs fichiers textes via protocole TCP (TcpClient). Pas de soucis pour transmettre depuis l'émetteur, par contre je ne sais pas comment reconstituer plusieurs fichiers à l'arrivée.

Côté émetteur :

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
TcpClient client = new TcpClient();
                IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(ip), 3000);
                client.Connect(serverEndPoint);
                NetworkStream networkStream = client.GetStream();
 
                byte[] buffer = new byte[client.ReceiveBufferSize];
 
                foreach (string filePath in listFiles)
                {
                    FileInfo fileInfo = new FileInfo(filePath);
                    FileStream fileStream = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read);
                    BinaryReader binFile = new BinaryReader(fileStream);
 
                    int taille = (int)fileInfo.Length;
                    byte[] bytes = BitConverter.GetBytes(taille);
                    networkStream.Write(bytes, 0, bytes.Length);
 
                    byte[] data = new byte[1024];
                    int count = 0, total = 0;
 
                    while (total != taille)
                    {
                        count = fileStream.Read(data, 0, data.Length);
                        networkStream.Write(data, 0, count);
                        total += count;
                        Console.WriteLine(total + " bytes envoyés");
                    }
 
                    fileStream.Close();
                }
 
                networkStream.Close();
                client.Close();

Côté récepteur, qui fonctionne pour la réception d'un seul fichier :

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
TcpClient tcpClient = (TcpClient)client;
            NetworkStream networkStream = tcpClient.GetStream();
 
            byte[] data = new byte[1024];
 
            int bytesRecus = networkStream.Read(data, 0, 4);
            int taille = BitConverter.ToInt32(data, 0);
 
            FileStream fileStream = new FileStream("text.txt", FileMode.Create);
 
            int count = 0, total = 0;
            while (total != taille)
            {
                count = networkStream.Read(data, 0, data.Length);
                fileStream.Write(data, 0, count);
                total += count;
 
                Server.WriteLine(total + " bytes reçu ... (" + count + " bytes)");
            }
 
            fileStream.Close();
            networkStream.Close();
            tcpClient.Close();

Merci par avance pour toute réponse éventuelle.

Cdlt,

[Invité]

Bon et bien j'ai réussi ce que je voulais faire.

Voici le code pour la partie récepteur qui peut donc réécrire plusieurs fichiers (txt en l'occurence) à partir d'un même flux/paquet de données.

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
static private void HandleClientComm(object client)
        {
            TcpClient tcpClient = (TcpClient)client;
            NetworkStream networkStream = tcpClient.GetStream();
            Server.WriteLine("Réception des données ...");
 
            byte[] data = new byte[1024];
 
            int bytesRecus = networkStream.Read(data, 0, 4);
            int taille = BitConverter.ToInt32(data, 0);
 
            RecreateFile(tcpClient, networkStream, data, taille);
 
            networkStream.Close();
            Server.WriteLine("Fermeture du flux de données.");
 
            tcpClient.Close();
            Server.WriteLine("Client déconnecté.");
        }
 
        static private void RecreateFile(TcpClient tcpClient, NetworkStream networkStream, byte[] data, int taille)
        {
            FileStream fileStream = new FileStream(taille + ".txt", FileMode.Create); // ici le taille + ".txt" est simplement utile pour que le nom du fichier soit unique et qu'il n'écrase pas le précédent.
 
            int nbPaquets = taille / 1024 + 1;
            int taillePaquet = 0;
 
            int count = 0, total = 0;
            for(int i=0;i<nbPaquets;i++)
            {
                if (i == (nbPaquets - 1))
                    taillePaquet = taille % 1024;
                else
                    taillePaquet = 1024;
 
                count = networkStream.Read(data, 0, taillePaquet);
                fileStream.Write(data, 0, count);
                total += count;
 
                Server.WriteLine(total + " bytes reçu ... (" + count + " bytes)");
            }
 
            fileStream.Close();
 
            int bytesRecus = networkStream.Read(data, 0, 4);
            if (bytesRecus != 0)
            {
                taille = BitConverter.ToInt32(data, 0);
                RecreateFile(tcpClient, networkStream, data, taille);
            }
        }

Concrètement, j'utilise le fait que les 4 premiers bytes d'un fichier indiquent sa taille. A partir de là, j'utilise une fonction récursive (RecreateFile()) pour reconstitué un fichier en fonction de sa taille. Car il est possible de savoir combien de paquets vont être utiliser pour qu'il soit transmis en utilisant un modulo.

En espérant ne pas avoir été trop obscur.

Cdlt,