Wie speichere ich einen Stream in einer Datei in C #?

Ich habe ein StreamReaderObjekt, das ich mit einem Stream initialisiert habe. Jetzt möchte ich diesen Stream auf der Festplatte speichern (der Stream kann ein .gifoder .jpgoder sein .pdf).

Bestehender Code:

StreamReader sr = new StreamReader(myOtherObject.InputStream);

1. Ich muss dies auf der Festplatte speichern (ich habe den Dateinamen).
2. In Zukunft möchte ich dies möglicherweise in SQL Server speichern.

Ich habe auch den Codierungstyp, den ich benötige, wenn ich ihn auf SQL Server speichere, richtig?

Wie Tilendor in Jon Skeets Antwort hervorgehoben hat, haben Streams CopyToseit .NET 4 eine Methode.

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

Oder mit der usingSyntax:

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

Sie müssen nicht verwenden StreamReaderfür binäre Dateien (wie GIF oder JPG - Dateien). StreamReaderist für Textdaten . Sie werden mit ziemlicher Sicherheit Daten verlieren, wenn Sie sie für beliebige Binärdaten verwenden. (Wenn Sie Encoding.GetEncoding (28591) verwenden, sind Sie wahrscheinlich in Ordnung, aber worum geht es?)

Warum brauchen Sie StreamReaderüberhaupt eine? Warum nicht einfach die Binärdaten als Binärdaten behalten und als Binärdaten auf die Festplatte (oder SQL) zurückschreiben?

EDIT: Da dies scheint etwas die Leute sehen wollen sein ... , wenn Sie es nur einen Stream in einen anderen kopieren möchten (zB in einer Datei) Verwendung etwas wie folgt aus :

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

So verwenden Sie es zum Speichern eines Streams in eine Datei, zum Beispiel:

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

Beachten Sie, dass dies Stream.CopyToin .NET 4 eingeführt wurde und im Wesentlichen demselben Zweck dient.

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

Ich erhalte nicht alle Antworten mit CopyTo, wobei die Systeme, die die App verwenden, möglicherweise nicht auf .NET 4.0+ aktualisiert wurden. Ich weiß, einige möchten die Leute zum Upgrade zwingen, aber die Kompatibilität ist auch gut.

Eine andere Sache ist, dass ich überhaupt keinen Stream verwende, um von einem anderen Stream zu kopieren. Warum nicht einfach machen:

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

Sobald Sie die Bytes haben, können Sie sie einfach in eine Datei schreiben:

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

Dieser Code funktioniert so, wie ich ihn mit einer .jpgDatei getestet habe , obwohl ich zugeben muss, dass ich ihn nur mit kleinen Dateien (weniger als 1 MB) verwendet habe. Ein Stream, kein Kopieren zwischen Streams, keine Codierung erforderlich, schreiben Sie einfach die Bytes! Sie müssen die Dinge nicht zu kompliziert machen, StreamReaderwenn Sie bereits einen Stream haben, in den Sie bytesdirekt konvertieren können .ToArray()!

Die einzigen möglichen Nachteile, die ich auf diese Weise erkennen kann, sind, wenn Sie eine große Datei haben. Wenn Sie sie als Stream haben und sie verwenden .CopyTo()oder gleichwertig verwenden, können Sie FileStreamsie streamen, anstatt ein Byte-Array zu verwenden und die Bytes einzeln zu lesen. Infolgedessen könnte es auf diese Weise langsamer sein. Es sollte jedoch nicht ersticken, da die .Write()Methode der FileStreamHandles die Bytes schreibt, und es wird jeweils nur ein Byte ausgeführt, sodass der Speicher nicht verstopft wird, außer dass Sie über genügend Speicher verfügen müssen, um den Stream als zu speichern byte[]Objekt . In meiner Situation, in der ich dies verwendet habe, OracleBlobmusste ich zu einem gehen byte[], es war klein genug, und außerdem stand mir sowieso kein Streaming zur Verfügung, also habe ich meine Bytes einfach an meine Funktion oben gesendet.

Eine andere Möglichkeit, einen Stream zu verwenden, besteht darin, ihn mit Jon Skeets CopyStreamFunktion zu verwenden, die sich in einem anderen Beitrag befand. Hiermit wird lediglich FileStreamder Eingabestream verwendet und die Datei direkt daraus erstellt. Es wird nicht verwendet File.Create, wie er es tat (was anfangs für mich problematisch schien, aber später feststellte, dass es wahrscheinlich nur ein VS-Fehler war ...).

/// <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.
*/

Warum nicht ein FileStream-Objekt verwenden?

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

Eine andere Möglichkeit ist, den Stream zu einem zu bringen byte[]und zu verwenden File.WriteAllBytes. Dies sollte tun:

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

Wenn Sie es in eine Erweiterungsmethode einschließen, erhalten Sie eine bessere Benennung:

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

Hier ist ein Beispiel, das die ordnungsgemäße Verwendung und Implementierung von idisposable verwendet:

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

... und da ist auch das

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

Der Schlüssel besteht darin, die ordnungsgemäße Verwendung von using zu verstehen (die bei der Instanziierung des Objekts implementiert werden sollte, das wie oben gezeigt idisposable implementiert), und eine gute Vorstellung davon zu haben, wie die Eigenschaften für Streams funktionieren. Die Position ist buchstäblich der Index innerhalb des Streams (der bei 0 beginnt), dem gefolgt wird, wenn jedes Byte mit der Readbyte-Methode gelesen wird. In diesem Fall verwende ich es im Wesentlichen anstelle einer for-Schleifenvariablen und lasse es einfach bis zu der Länge durchlaufen, die buchstäblich das Ende des gesamten Streams ist (in Bytes). Ignorieren Sie in Bytes, da es praktisch dasselbe ist und Sie etwas Einfaches und Elegantes wie dieses haben, das alles sauber auflöst.

Beachten Sie auch, dass die ReadByte-Methode das Byte dabei einfach in ein int umwandelt und einfach zurückkonvertiert werden kann.

Ich werde eine weitere Implementierung hinzufügen, die ich kürzlich geschrieben habe, um eine Art dynamischen Puffer zu erstellen, um sequentielle Datenschreibvorgänge sicherzustellen und eine massive Überlastung zu verhindern

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

Die Erklärung ist ziemlich einfach: Wir wissen, dass wir den gesamten Datensatz berücksichtigen müssen, den wir schreiben möchten, und dass wir nur bestimmte Mengen schreiben möchten. Daher möchten wir, dass die erste Schleife mit dem letzten Parameter leer ist (wie während) ). Als nächstes initialisieren wir einen Byte-Array-Puffer, der auf die Größe des übergebenen Objekts eingestellt ist, und vergleichen mit der zweiten Schleife j mit der Größe des Puffers und der Größe des Originals, und wenn er größer als die Größe des Originals ist Byte-Array, beenden Sie den Lauf.