[socket] Transfert de fichier, Bug d'envoi des BYTE

salut,
Je poste pour un problème de transfert des blocs de Byte. Par exemple quand j'envoie une image de 5 mo, décomposée en Byte où le buffer size=4000, arrivé à l'envoie du 10ème, ça bloque!

voici un extrait de code d'envoie de l'image :

Code:

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
 
 const int BUFFER_SIZE = 4000;
//récuperation fichier image
    FileStream fichier = new FileStream(fileName, FileMode.Open, FileAccess.Read);
 
 
 
                        //header sert d'identifiant (  peut être une image,un fichier ...)
                        string header = "IMG_"+openFileDialog1.SafeFileName+"?";
 
                        // fin d'envoie d'un fichier (symbole :)
                        string end = "IMG_" + openFileDialog1.SafeFileName + ":";
 
                        byte[] headerb = Encoding.Unicode.GetBytes(header);
                        byte[] endb = Encoding.Unicode.GetBytes(end);
 
                        //construction buffer vers le réseau 
                        byte[] contenu = new byte[BUFFER_SIZE];
                        byte[] morceau = new byte[headerb.Length+BUFFER_SIZE];
                        byte[]morceauFin=new byte[endb.Length+BUFFER_SIZE];
                        int tailleBit=0;
                        int totalLu=0;
 
                        NetworkStream nfs=new NetworkStream(socket);
                        int i = 0;
                        //boucle d'envoie des groupes de BYTE
                        while (totalLu < fichier.Length && nfs.CanWrite)
                        {   
                           //recuperation BYTE
                           tailleBit = fichier.Read(contenu, 0, contenu.Length);
 
                               // Copie du header
                               for (i = 0; i < headerb.Length; i++)
                                   morceau[i] = headerb[i];
 
                               //copie header + fichier 
                               for (int j = 0; i < contenu.Length; j++, i++)
                                   morceau[i] = contenu[j];
 
                               //ecriture sur socket
                               nfs.Write(morceau, 0, tailleBit + headerb.Length);
                               totalLu = totalLu + tailleBit;
                           }

En gros voilà comment , j'envoie l'image
Tant Que la taille de fichier n'est pas atteinte par totalLu, je continue à envoyer les groupe de BYTE, sachant que chaque groupe est composé d'un header (identifiant) avec son type (IMG) et son nom!

et là c'est le code de récupération

Code:

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
 
//fichier ou image à reconstruire
FileStream fs = new FileStream("image", FileMode.Create, FileAccess.Write, FileShare.None);
while (true)
            {
                boolFin = false;
                p = 0;
                result = null;
                chaineBit = null;
                try
                {
                    if (sock != null)
                    {
                        byte[] b = new byte[BUFFER_SIZE];
 
                        int k = ((Socket)sock).Receive(b);
 
                        chaineBit = Encoding.UTF8.GetString(b);
                        //on regarde si chaine commence par IMG
                        if (chaineBit.StartsWith("I"))
                        {
                            while (boolFin != true)
                            {
                                char c = Convert.ToChar(b[p]);
 
                                result += Convert.ToChar(b[p]);
                                if (c.ToString().Equals("?"))
                                {
                                    //suppression du header du BYTE
                                    string chaineCoupe = chaineBit.Remove(0, result.Length);
                                    byte[] blocImgBit = Encoding.Unicode.GetBytes(chaineCoupe);
                                    // Ecriture du bloc dans le fichier
                                    fs.Write(blocImgBit, 0, blocImgBit.Length);
                                    boolFin = true;
                                }
 
                                p++;
                            }

En gros là , je récupère un bloc, je retire le header, et j'écris dans FS!!

Donc mon soucis est que dans l'itération d'envoie des BYTE, ça se bloque vers l'envoie du 10 ème paquet!!
Je sais pas pourquoi, peut-être que la socket est saturée???
Quelqun a une idée?