Comment enregistrer un flux dans un fichier en C #?

J'ai un StreamReaderobjet que j'ai initialisé avec un flux, maintenant je veux enregistrer ce flux sur le disque (le flux peut être un .gifou .jpgou .pdf).

Code existant:

StreamReader sr = new StreamReader(myOtherObject.InputStream);

1. J'ai besoin de l'enregistrer sur le disque (j'ai le nom du fichier).
2. À l'avenir, je voudrai peut-être stocker cela sur SQL Server.

J'ai également le type d'encodage, dont j'aurai besoin si je le stocke sur SQL Server, correct?

Comme l'a souligné Tilendor dans la réponse de Jon Skeet, les flux ont une CopyTomé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 usingsyntaxe:

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

Vous ne devez pas utiliser StreamReaderpour les fichiers binaires (comme les gifs ou jpgs). StreamReaderest pour les données texte . Vous perdrez presque certainement des données si vous les utilisez pour des données binaires arbitraires. (Si vous utilisez Encoding.GetEncoding (28591), vous serez probablement d'accord, mais à quoi ça sert?)

Pourquoi avez-vous besoin d'utiliser un StreamReader? Pourquoi ne pas simplement conserver les données binaires comme binaires et les réécrire sur le disque (ou SQL) en tant que données binaires?

EDIT: Comme cela semble être quelque chose les gens veulent voir ... si vous ne voulez juste copier un flux à un autre (par exemple dans un fichier) utiliser quelque chose comme ceci:

/// <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);
    }    
}

Pour l'utiliser pour vider un flux dans un fichier, par exemple:

using (Stream file = File.Create(filename))
{
    CopyStream(input, file);
}

Notez que cela a Stream.CopyToété introduit dans .NET 4, servant essentiellement le même objectif.

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

private void SaveFileStream(String path, Stream stream)
{
    var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write);
    stream.CopyTo(fileStream);
    fileStream.Dispose();
}

Je n'obtiens pas toutes les réponses en utilisant CopyTo, où peut-être que les systèmes utilisant l'application n'ont peut-être pas été mis à niveau vers .NET 4.0+. Je sais que certains voudraient forcer les gens à mettre à niveau, mais la compatibilité est également très bien aussi.

Une autre chose, je n'utilise pas un flux pour 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 les é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 comme je l'ai testé avec un .jpgfichier, mais j'avoue ne l'avoir utilisé qu'avec de petits fichiers (moins de 1 Mo). Un flux, pas de copie entre les flux, aucun encodage nécessaire, il suffit d'écrire les octets! Pas besoin de trop compliquer les choses StreamReadersi vous avez déjà un flux avec lequel vous pouvez convertir bytesdirectement .ToArray()!

Seuls les inconvénients potentiels que je peux voir en procédant de cette façon sont s'il y a un gros fichier que vous possédez, l'avoir comme flux et utiliser .CopyTo()ou équivalent permet FileStreamde le diffuser au lieu d'utiliser un tableau d'octets et de lire les octets un par un. En conséquence, cela pourrait être plus lent à faire de cette façon. Mais il ne devrait pas s'étouffer puisque la .Write()méthode des FileStreampoignées écrivant les octets, et il ne le fait qu'un octet à la fois, donc il n'encombrera pas la mémoire, sauf que vous devrez avoir suffisamment de mémoire pour contenir le flux en tant que byte[]objet . Dans ma situation où j'utilisais cela, obtenir un OracleBlob, je devais aller à un byte[], c'était assez petit, et en plus, il n'y avait pas de streaming disponible pour moi, de toute façon, alors j'ai juste envoyé mes octets à ma fonction, ci-dessus.

Une autre option, en utilisant un flux, serait de l'utiliser avec la CopyStreamfonction de Jon Skeet qui était dans un autre post - cela permet simplement FileStreamde prendre le flux d'entrée et de créer le fichier directement à partir de celui-ci. Il n'utilise pas File.Create, comme il l'a fait (ce qui au départ semblait être problématique pour moi, mais a trouvé plus tard que c'était probablement juste un bug VS ...).

/// <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();
}

//If you don't have .Net 4.0  :)

public void SaveStreamToFile(Stream stream, string filename)
{  
   using(Stream destination = File.Create(filename))
      Write(stream, destination);
}

//Typically I implement this Write method as a Stream extension method. 
//The framework handles buffering.

public void Write(Stream from, Stream to)
{
   for(int a = from.ReadByte(); a != -1; a = from.ReadByte())
      to.WriteByte( (byte) a );
}

/*
Note, StreamReader is an IEnumerable<Char> while Stream is an IEnumbable<byte>.
The distinction is significant such as in multiple byte character encodings 
like Unicode used in .Net where Char is one or more bytes (byte[n]). Also, the
resulting translation from IEnumerable<byte> to IEnumerable<Char> can loose bytes
or insert them (for example, "\n" vs. "\r\n") depending on the StreamReader instance
CurrentEncoding.
*/

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 consiste à obtenir le flux byte[]et à l'utiliser File.WriteAllBytes. Cela devrait faire:

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

L'encapsuler dans une méthode d'extension lui donne un meilleur nom:

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.
}

public void testdownload(stream input)
{
    byte[] buffer = new byte[16345];
    using (FileStream fs = new FileStream(this.FullLocalFilePath,
                        FileMode.Create, FileAccess.Write, FileShare.None))
    {
        int read;
        while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
        {
             fs.Write(buffer, 0, read);
        }
    }
}

Voici un exemple qui utilise les utilisations appropriées et l'implémentation de idisposable:

static void WriteToFile(string sourceFile, string destinationfile, bool append = true, int bufferSize = 4096)
{
    using (var sourceFileStream = new FileStream(sourceFile, FileMode.OpenOrCreate))
    {
        using (var destinationFileStream = new FileStream(destinationfile, FileMode.OpenOrCreate))
        {
            while (sourceFileStream.Position < sourceFileStream.Length)
            {
                destinationFileStream.WriteByte((byte)sourceFileStream.ReadByte());
            }
        }
    }
}

... et il y a aussi ça

    public static void WriteToFile(FileStream stream, string destinationFile, int bufferSize = 4096, FileMode mode = FileMode.OpenOrCreate, FileAccess access = FileAccess.ReadWrite, FileShare share = FileShare.ReadWrite)
    {
        using (var destinationFileStream = new FileStream(destinationFile, mode, access, share))
        {
            while (stream.Position < stream.Length) 
            {
                destinationFileStream.WriteByte((byte)stream.ReadByte());
            }
        }
    }

La clé est de comprendre la bonne utilisation de l'utilisation (qui doit être implémentée lors de l'instanciation de l'objet qui implémente idisposable comme indiqué ci-dessus), et d'avoir une bonne idée de la façon dont les propriétés fonctionnent pour les flux. La position est littéralement l'index dans le flux (qui commence à 0) qui est suivi lorsque chaque octet est lu à l'aide de la méthode readbyte. Dans ce cas, je l'utilise essentiellement à la place d'une variable de boucle for et je la laisse simplement suivre jusqu'à la longueur qui est LITTÉRALEMENT la fin de l'ensemble du flux (en octets). Ignorez-le en octets car il est pratiquement le même et vous aurez quelque chose de simple et d'élégant comme celui-ci qui résout tout proprement.

Gardez également à l'esprit que la méthode ReadByte convertit simplement l'octet en entier dans le processus et peut simplement être reconvertie.

Je vais ajouter une autre implémentation que j'ai récemment écrite pour créer une sorte de tampon dynamique pour garantir l'écriture séquentielle des données afin d'éviter une surcharge massive

private void StreamBuffer(Stream stream, int buffer)
{
    using (var memoryStream = new MemoryStream())
    {
        stream.CopyTo(memoryStream);
        var memoryBuffer = memoryStream.GetBuffer();

        for (int i = 0; i < memoryBuffer.Length;)
        {
            var networkBuffer = new byte[buffer];
            for (int j = 0; j < networkBuffer.Length && i < memoryBuffer.Length; j++)
            {
                networkBuffer[j] = memoryBuffer[i];
                i++;
            }
            //Assuming destination file
            destinationFileStream.Write(networkBuffer, 0, networkBuffer.Length);
        }
    }
}

L'explication est assez simple: nous savons que nous devons garder à l'esprit l'ensemble des données que nous souhaitons écrire et aussi que nous ne voulons écrire que certains montants, nous voulons donc que la première boucle avec le dernier paramètre vide (identique à while ). Ensuite, nous initialisons un tampon de tableau d'octets qui est défini à la taille de ce qui est passé, et avec la deuxième boucle, nous comparons j à la taille du tampon et à la taille de l'original, et s'il est supérieur à la taille de l'original tableau d'octets, terminer l'analyse.