Discussion :

[Ywnith]

Bonjour,

Je développe une petite dll qui me permet de gérer la com' TCP, et cherche a y implémenter une fonction d'envoi de fichiers.

Je cherche à éviter le File.ReadAllBytes() qui fait automatiquement grimper mon application à 500 Mo d'utilisation de mémoire vive dès que je veux envoyer un fichier de 100 Mo.

J'ai donc réfléchis et cherche à envoyer un fichier par chunk de 1024 bytes, voici le code d'envoi :

Code :

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

1
2
3
4
5
6
byte[] bufferFichier = new byte[1024];
FileStream fs = File.OpenRead(ofd.FileName);
                int bytesLus;
                while ((bytesLus= fs.Read(bufferFichier, 0, bufferFichier.Length)) > 0) {
                    client.BeginSend(bufferFichier, 0, bufferFichier.Length, SocketFlags.None, new AsyncCallback(SendCallback), client);
                }

De ce coté-là à priori tout marche sans problème.

En revanche je bloque du coté de la réception :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
private readonly object lockFichier = new object();
        private void ReceiveCallback(IAsyncResult ar) {
            Console.WriteLine("Réception données");
            Socket serveur = ar.AsyncState as Socket;
            int dataClient = serveur.EndReceive(ar);
            FileStream fs = new FileStream(@"salut.exe", FileMode.Append);
            lock (lockFichier) {
                fs.Write(buffer, 0, dataClient);
                fs.Close();
                serveur.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), serveur);
            }
        }

Je reçois entre 4 Mo et 12 Mo, variable, et puis bim, exception fichier en cours d'utilisation.

Du coup je cherche à comprendre comment éviter ça, j'aimerai éviter de faire un Thread.Sleep(500) par exemple dans ma boucle while de la méthode d'envoi. Voir s'il y a une autre méthode qui puisse directement être implémenté dans la méthode de réception.

Peut être que je comprends mal l'utilisation du lock ...

Merci par avance.

[tomlev]

Tu te compliques vraiment la vie en utilisant directement un Socket... utilise plutôt TcpClient, c'est beaucoup plus pratique. Avec TcpClient tu peux obtenir un Stream, qui permet de gérer facilement la copie : avec la méthode CopyTo, tu peux copier du flux fichier au flux réseau, et inversement, sans avoir à te prendre la tête.

[Ywnith]

Je voudrai bien sauf qu'une très très grosse partie de ma dll est terminée et j'utilise déjà les fonction de base à travers diverses application ... Pas très envie de repasser de partout.

Puis mon problème peut aussi arriver dans une autre utilisation que les sockets, du coup ça m'intéresserai de savoir comment pallier à ce problème d'écriture.

[tomlev]

En fait je m'aperçois que tu peux quand même utiliser un Stream avec un Socket : le constructeur de la classe NetworkStream prend le socket en paramètre.

Donc pour recevoir un fichier, il suffit de faire ça :

Code :

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

1
2
3
4
5
using (var networkStream = new NetworkStream(socket, false))
using (var fileStream = File.OpenWrite(@"C:\test.txt"))
{
    networkStream.CopyTo(fileStream);
}

et pour envoyer, c'est le contraire :

Code :

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

1
2
3
4
5
using (var networkStream = new NetworkStream(socket, false))
using (var fileStream = File.OpenRead(@"C:\test.txt"))
{
    fileStream.CopyTo(networkStream);
}

[Ywnith]

Arf FileStream.CopyTo c'est au framework 4.

J'ai essayé d'utiliser ça en passant au framework 4 mais les fichiers que je reçois ont l'air corrompu.

Je vais essayer de chercher un peu.

[tomlev]

Arf FileStream.CopyTo c'est au framework 4.

Ca pose un problème ? le framework 4 c'est 2010 quand même... 3 ans, c'est une éternité dans le domaine de l'informatique

Mais de toutes façons cette méthode est assez bidon, tu peux très bien la refaire sous forme de méthode d'extension :

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 class StreamExtensions
{
    public static void CopyTo(this Stream source, Stream destination, int bufferSize = 0x14000)
    {
        if (destination == null)
            throw new ArgumentNullException("destination");
        if (!source.CanRead && !source.CanWrite)
            throw new ObjectDisposedException("source", "The source stream is closed");
        if (!destination.CanRead && !destination.CanWrite)
            throw new ObjectDisposedException("destination", "The destination stream is closed");
        if (!source.CanRead)
            throw new NotSupportedException("The source stream cannot be read");
        if (!destination.CanWrite)
            throw new NotSupportedException("The destination stream cannot be written");
        int count;
        byte[] buffer = new byte[bufferSize];
        while ((count = source.Read(buffer, 0, buffer.Length)) != 0)
        {
            destination.Write(buffer, 0, count);
        }
    }
}