Comment puis-je enregistrer un flux de données dans un fichier en C#?

Comme l'a souligné Tilendor dans Jon Skeet réponse, les ruisseaux ont un CopyTo méthode depuis .NET 4.

var fileStream = File.Create("C:\\Path\\To\\File");
myOtherObject.InputStream.Seek(0, SeekOrigin.Begin);
myOtherObject.InputStream.CopyTo(fileStream);
fileStream.Close();

Ou avec la using syntaxe:

using (var fileStream = File.Create("C:\\Path\\To\\File"))
{
    myOtherObject.InputStream.Seek(0, SeekOrigin.Begin);
    myOtherObject.InputStream.CopyTo(fileStream);
}

public void CopyStream(Stream stream, string destPath)
{
  using (var fileStream = new FileStream(destPath, FileMode.Create, FileAccess.Write))
  {
    stream.CopyTo(fileStream);
  }
}

Je n'ai pas toutes les réponses à l'aide de CopyTo, où peut-être les systèmes à l'aide de l'application pourrait ne pas avoir été mis à niveau .NET 4.0+. Je sais que certains voudraient forcer les gens à mettre à niveau, mais la compatibilité est aussi très agréable, trop.

Autre chose, je ne suis pas à l'aide d'un flux de copier à partir d'un autre flux en premier lieu. Pourquoi ne pas simplement faire:

byte[] bytes = myOtherObject.InputStream.ToArray();

Une fois que vous avez les octets, vous pouvez facilement écrire dans un fichier:

public static void WriteFile(string fileName, byte[] bytes)
{
    string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
    if (!path.EndsWith(@"\")) path += @"\";

    if (File.Exists(Path.Combine(path, fileName)))
        File.Delete(Path.Combine(path, fileName));

    using (FileStream fs = new FileStream(Path.Combine(path, fileName), FileMode.CreateNew, FileAccess.Write))
    {
        fs.Write(bytes, 0, (int)bytes.Length);
        //fs.Close();
    }
}

Ce code fonctionne car je l'ai testé avec une .jpg fichier, mais je dois admettre que j'ai utilisé uniquement avec des fichiers de petite taille (moins de 1 MO). Un cours d'eau, pas de la copie entre les flux, aucun codage nécessaire, il suffit d'écrire les octets! Pas besoin de compliquer les choses avec StreamReader si vous disposez déjà d'un ruisseau, vous pouvez convertir le bytes directement avec .ToArray()!

Seulement inconvénients potentiels que je peux voir dans cette façon de faire est si il y a un gros fichier que vous avez, de l'avoir comme un flux et à l'aide de .CopyTo() ou équivalent permet FileStream le lire au lieu d'utiliser un tableau d'octets et de la lecture les octets un par un. Il pourrait être plus lente, faisant de cette façon, comme un résultat. Mais il ne faut pas étouffer depuis le .Write() méthode de la FileStream poignées écrit les octets, et c'est seulement en faisant un octet à la fois, afin de ne pas obstruer la mémoire, sauf que vous devrez avoir assez de mémoire pour contenir le flux en tant que byte[] objet. Dans ma situation, où j'ai utilisé cette, d'obtenir une OracleBlob, j'ai dû aller à un byte[], il était assez petit, et d'ailleurs, il n'y avait pas de streaming disponible pour moi, de toute façon, je viens d'envoyer mon octets à ma fonction, ci-dessus.

Une autre option, à l'aide d'un ruisseau, serait de l'utiliser avec Jon Skeet est CopyStream fonction qui était dans un autre post, ce n'utilise FileStream de prendre le flux d'entrée et de créer le fichier directement. Il n'utilise pas File.Create, comme il l'a fait (qui au départ semblait être problématique pour moi, mais plus tard trouvé que c'était probablement juste un VS bug...).

///<summary>
///Copies the contents of input to output. Doesn't close either stream.
///</summary>
public static void CopyStream(Stream input, Stream output)
{
    byte[] buffer = new byte[8 * 1024];
    int len;
    while ( (len = input.Read(buffer, 0, buffer.Length)) > 0)
    {
        output.Write(buffer, 0, len);
    }    
}

public static void WriteFile(string fileName, Stream inputStream)
{
    string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
    if (!path.EndsWith(@"\")) path += @"\";

    if (File.Exists(Path.Combine(path, fileName)))
        File.Delete(Path.Combine(path, fileName));

    using (FileStream fs = new FileStream(Path.Combine(path, fileName), FileMode.CreateNew, FileAccess.Write)
    {
        CopyStream(inputStream, fs);
    }

    inputStream.Close();
    inputStream.Flush();
}

Pourquoi ne pas utiliser un objet FileStream?

public void SaveStreamToFile(string fileFullPath, Stream stream)
{
    if (stream.Length == 0) return;

    //Create a FileStream object to write a stream to a file
    using (FileStream fileStream = System.IO.File.Create(fileFullPath, (int)stream.Length))
    {
        //Fill the bytes[] array with the stream data
        byte[] bytesInStream = new byte[stream.Length];
        stream.Read(bytesInStream, 0, (int)bytesInStream.Length);

        //Use FileStream object to write to the specified file
        fileStream.Write(bytesInStream, 0, bytesInStream.Length);
     }
}

Une autre option est d'obtenir le flux à un byte[] et l'utilisation File.WriteAllBytes. Ceci devrait faire:

using (var stream = new MemoryStream())
{
    input.CopyTo(stream);
    File.WriteAllBytes(file, stream.ToArray());
}

En l'enveloppant dans une extension de la méthode donne de meilleurs de nommage:

public void WriteTo(this Stream input, string file)
{
    //your fav write method:

    using (var stream = File.Create(file))
    {
        input.CopyTo(stream);
    }

    //or

    using (var stream = new MemoryStream())
    {
        input.CopyTo(stream);
        File.WriteAllBytes(file, stream.ToArray());
    }

    //whatever that fits.
}