Come faccio a salvare uno stream in un file in C #?

Ho un StreamReaderoggetto che ho inizializzato con un flusso, ora voglio salvare questo flusso su disco (il flusso può essere un .gifo .jpgo .pdf).

Codice esistente:

StreamReader sr = new StreamReader(myOtherObject.InputStream);

1. Devo salvarlo su disco (ho il nome file).
2. In futuro potrei voler archiviare questo su SQL Server.

Ho anche il tipo di codifica, che sarà necessario se lo memorizzo su SQL Server, corretto?

Come sottolineato da Tilendor nella risposta di Jon Skeet, i flussi hanno un CopyTometodo da .NET 4.

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

O con la usingsintassi:

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

Non è necessario utilizzare StreamReaderper file binari (come gif o jpg). StreamReaderè per i dati di testo . Quasi sicuramente perderete i dati se li utilizzate per dati binari arbitrari. (Se usi Encoding.GetEncoding (28591) probabilmente starai bene, ma qual è il punto?)

Perché devi usare StreamReadera? Perché non conservare semplicemente i dati binari come dati binari e riscriverli su disco (o SQL) come dati binari?

EDIT: Come questo sembra essere qualcosa che la gente vuole vedere ... se non volete semplicemente copiare un flusso a un altro (ad esempio, per un file) qualcosa di utilizzo simile a questo:

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

Per usarlo per scaricare un flusso in un file, ad esempio:

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

Si noti che è Stream.CopyTostato introdotto in .NET 4 e ha sostanzialmente lo stesso scopo.

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

Non ottengo tutte le risposte usando CopyTo, dove forse i sistemi che utilizzano l'app potrebbero non essere stati aggiornati a .NET 4.0+. So che alcuni vorrebbero costringere le persone ad aggiornare, ma anche la compatibilità è buona.

Un'altra cosa, in primo luogo non riesco a utilizzare uno stream per copiare da un altro stream. Perché non fare solo:

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

Una volta che hai i byte, puoi facilmente scriverli in un file:

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

Questo codice funziona come l'ho testato con un .jpgfile, anche se ammetto di averlo usato solo con file piccoli (meno di 1 MB). Un flusso, nessuna copia tra i flussi, nessuna codifica necessaria, basta scrivere i byte! Non c'è bisogno di complicare eccessivamente le cose StreamReaderse hai già un flusso con cui puoi convertirlo bytesdirettamente .ToArray()!

Solo i potenziali svantaggi che posso vedere nel farlo in questo modo è se c'è un file di grandi dimensioni che hai, averlo come flusso e l'utilizzo .CopyTo()o equivalente consente FileStreamdi eseguire lo streaming invece di utilizzare un array di byte e leggere i byte uno per uno. Di conseguenza, potrebbe essere più lento farlo in questo modo. Ma non dovrebbe soffocare dal momento che il .Write()metodo degli FileStreamhandle scrive i byte e lo sta facendo solo un byte alla volta, quindi non ostruirà la memoria, tranne per il fatto che dovrai avere memoria sufficiente per contenere lo stream come byte[]oggetto . Nella mia situazione in cui l'ho usato, ottenendo un OracleBlob, dovevo andare a un byte[], era abbastanza piccolo e, inoltre, non c'era streaming disponibile per me, quindi ho appena inviato i miei byte alla mia funzione, sopra.

Un'altra opzione, usando un flusso, sarebbe quella di usarlo con la CopyStreamfunzione di Jon Skeet che era in un altro post - questo usa solo FileStreamper prendere il flusso di input e creare il file direttamente da esso. Non usa File.Create, come ha fatto lui (che inizialmente mi è sembrato problematico, ma in seguito ha scoperto che probabilmente era solo 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.
*/

Perché non usare un oggetto 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);
     }
}

Un'altra opzione è quella di ottenere lo stream byte[]e utilizzare File.WriteAllBytes. Questo dovrebbe fare:

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

Avvolgendolo in un metodo di estensione si ottiene una migliore denominazione:

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

Ecco un esempio che utilizza usi corretti e implementazione di 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());
            }
        }
    }
}

... e c'è anche questo

    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 chiave è comprendere l'uso corretto dell'uso (che dovrebbe essere implementato sull'istanza dell'oggetto che implementa idisposable come mostrato sopra) e avere una buona idea di come funzionano le proprietà per i flussi. La posizione è letteralmente l'indice all'interno del flusso (che inizia da 0) che viene seguito quando ogni byte viene letto usando il metodo readbyte. In questo caso lo sto essenzialmente usando al posto di una variabile for loop e sto semplicemente lasciando che segua tutto il percorso fino alla lunghezza che è LETTERAMENTE la fine dell'intero flusso (in byte). Ignora in byte perché è praticamente lo stesso e avrai qualcosa di semplice ed elegante come questo che risolve tutto in modo pulito.

Tieni presente, inoltre, che il metodo ReadByte semplicemente lancia il byte in un int nel processo e può essere semplicemente riconvertito.

Aggiungerò un'altra implementazione che ho scritto di recente per creare una sorta di buffer dinamico per garantire scritture sequenziali di dati per prevenire un sovraccarico massiccio

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

La spiegazione è abbastanza semplice: sappiamo che dobbiamo tenere a mente l'intero insieme di dati che desideriamo scrivere e anche che vogliamo solo scrivere determinate quantità, quindi vogliamo che il primo ciclo con l'ultimo parametro vuoto (lo stesso mentre ). Successivamente, inizializziamo un buffer di array di byte che è impostato sulla dimensione di ciò che è passato e con il secondo loop confrontiamo j con la dimensione del buffer e la dimensione di quello originale, e se è maggiore della dimensione dell'originale array di byte, termina l'esecuzione.