comment tamponner un flux d'entrée jusqu'à ce qu'il soit complet

Question

Je suis en train de mettre en œuvre un service wcf qui accepte les flux d'images. Cependant, je reçois actuellement une exception quand je l'exécute. comme essayer d'obtenir la longueur du flux avant que le flux est terminé. donc ce que je voudrais faire est de tamponner le flux jusqu'à son complet. cependant je ne peux pas trouver des exemples de la façon de le faire ...

Quelqu'un peut-il aider?

mon code à ce jour:

public String uploadUserImage(Stream stream) 
    { 
      Stream fs = stream; 

      BinaryReader br = new BinaryReader(fs); 

      Byte[] bytes = br.ReadBytes((Int32)fs.Length);// this causes exception 

      File.WriteAllBytes(filepath, bytes); 
    } 

Answer 1

Plutôt que d'essayer de chercher la longueur, vous devriez lire à partir du flux jusqu'à ce qu'il retourne qu'il est « fait ». Dans .NET 4, ce qui est vraiment facile:

// Assuming we *really* want to read it into memory first... 
MemoryStream memoryStream = new MemoryStream(); 
stream.CopyTo(memoryStream); 
memoryStream.Position = 0; 
File.WriteAllBytes(filepath, memoryStream); 

.NET 3.5 il n'y a pas de méthode CopyTo, mais vous pouvez écrire quelque chose vous similaire:

public static void CopyStream(Stream input, Stream output) 
{ 
    byte[] buffer = new byte[8192]; 
    int bytesRead; 
    while ((bytesRead = input.Read(buffer, 0, buffer.Length)) > 0) 
    { 
     output.Write(buffer, 0, bytesRead); 
    } 
} 

Cependant, maintenant que nous avons quelque chose à copier un flux, pourquoi s'embêter à le lire tout d'abord en mémoire? Disons simplement l'écrire directement à un fichier:

using (FileStream output = File.OpenWrite(filepath)) 
{ 
    CopyStream(stream, output); // Or stream.CopyTo(output); 
} 

Answer 2

Je ne sais pas ce que vous retournerez (ou non retour), mais quelque chose comme ça pourrait fonctionner pour vous:

public String uploadUserImage(Stream stream) { 
    const int KB = 1024; 
    Byte[] bytes = new Byte[KB]; 
    StringBuilder sb = new StringBuilder(); 
    using (BinaryReader br = new BinaryReader(stream)) { 
    int len; 
    do { 
     len = br.Read(bytes, 0, KB); 
     string readData = Encoding.UTF8.GetString(bytes); 
     sb.Append(readData); 
    } while (len == KB); 
    } 
    //File.WriteAllBytes(filepath, bytes); 
    return sb.ToString(); 
} 

Une chaîne peut peut contenir jusqu'à 2 Go, je crois.

Answer 3

Essayez ceci:

using (StreamWriter sw = File.CreateText(filepath)) 
    { 
     stream.CopyTo(sw); 
     sw.Close(); 
    }