Jak zapisać strumień do pliku w C #?

Mam StreamReaderobiekt, który zainicjowałem ze strumieniem, teraz chcę zapisać ten strumień na dysku (strumień może być .giflub .jpglub .pdf).

Istniejący kod:

StreamReader sr = new StreamReader(myOtherObject.InputStream);

1. Muszę zapisać to na dysku (mam nazwę pliku).
2. W przyszłości mogę chcieć zapisać to na SQL Server.

Mam również typ kodowania, który będzie potrzebny, jeśli będę go przechowywać na serwerze SQL, prawda?

Jak podkreśla Tilendor w odpowiedzi Jona Skeeta, strumienie mają CopyTometodę od .NET 4.

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

Lub ze usingskładnią:

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

ty wolno używać StreamReaderdo plików binarnych (takich jak gif lub jpg). StreamReaderdotyczy danych tekstowych . Prawie na pewno stracisz dane, jeśli użyjesz ich do dowolnych danych binarnych. (Jeśli użyjesz Encoding.GetEncoding (28591) prawdopodobnie będziesz w porządku, ale o co chodzi?)

Dlaczego w ogóle potrzebujesz StreamReader? Dlaczego nie po prostu zachować dane binarne jako dane binarne i zapisać je z powrotem na dysk (lub SQL) jako dane binarne?

EDIT: Jak to wydaje się być coś ludzie chcą zobaczyć ... jeśli nie po prostu chcesz skopiować jednego strumienia do drugiego (np do pliku) używać coś takiego:

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

Aby użyć go do zrzucenia strumienia do pliku, na przykład:

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

Zauważ, że Stream.CopyTozostał wprowadzony w .NET 4, służąc w zasadzie do tego samego celu.

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

Nie otrzymuję wszystkich odpowiedzi CopyTo , a być może systemy korzystające z aplikacji mogły nie zostać zaktualizowane do wersji .NET 4.0+. Wiem, że niektórzy chcieliby zmusić ludzi do aktualizacji, ale kompatybilność też jest dobra.

Inna sprawa, że ​​nie używam strumienia do kopiowania z innego strumienia. Dlaczego nie tylko:

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

Gdy masz bajty, możesz łatwo zapisać je w pliku:

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

Ten kod działa tak, jak przetestowałem go z .jpgplikiem, choć przyznaję, że użyłem go tylko z małymi plikami (mniej niż 1 MB). Jeden strumień, bez kopiowania między strumieniami, niepotrzebne kodowanie, wystarczy napisać bajty! Nie musisz nadmiernie komplikować rzeczy, StreamReaderjeśli masz już strumień, na który można bytesbezpośrednio przekonwertować.ToArray() !

Jedyne potencjalne wady, które widzę podczas robienia tego w ten sposób, to to, że masz duży plik, mając go jako strumień, a użycie .CopyTo()lub odpowiednik pozwala FileStreamna przesyłanie strumieniowe zamiast korzystania z tablicy bajtów i odczytywania bajtów jeden po drugim. W rezultacie może być wolniej. Ale nie powinien się dusić, ponieważ .Write()metoda FileStreamuchwytów zapisujących bajty, i robi to tylko jeden bajt na raz, więc nie zapycha pamięci, z wyjątkiem tego, że będziesz musiał mieć wystarczającą ilość pamięci, aby utrzymać strumień jako byte[]przedmiot . W mojej sytuacji, w której korzystałem z tego, OracleBlobmusiałem iść do byte[], był wystarczająco mały, a poza tym i tak nie było dla mnie żadnego streamingu, więc po prostu wysłałem moje bajty do mojej funkcji powyżej.

Inną opcją, wykorzystującą strumień, byłoby użycie go z CopyStreamfunkcją Jona Skeeta, która była w innym poście - służy to tylko FileStreamdo pobrania strumienia wejściowego i utworzenia z niego bezpośrednio pliku. Nie działa File.Create, tak jak on (co początkowo wydawało mi się problematyczne, ale później stwierdził, że to prawdopodobnie tylko błąd 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.
*/

Dlaczego nie użyć obiektu 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);
     }
}

Inną opcją jest doprowadzenie strumienia do byte[]i użycie File.WriteAllBytes. To powinno zrobić:

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

Zawijanie go w metodzie rozszerzenia daje lepszą nazwę:

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

Oto przykład, który wykorzystuje odpowiednie zastosowania i implementację 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());
            }
        }
    }
}

... i jest też to

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

Kluczem jest zrozumienie prawidłowego użycia use (które powinno zostać zaimplementowane przy tworzeniu instancji obiektu, który implementuje idisposable, jak pokazano powyżej) oraz dobre wyobrażenie o tym, jak właściwości działają dla strumieni. Pozycja jest dosłownie indeksem w strumieniu (który zaczyna się od 0), po którym następuje odczyt każdego bajtu przy użyciu metody readbyte. W tym przypadku zasadniczo używam go zamiast zmiennej pętli for i po prostu pozwalam mu przejść przez całą długość aż do długości, która jest LITERALNIE końcem całego strumienia (w bajtach). Ignoruj ​​w bajtach, ponieważ jest praktycznie taki sam, a będziesz mieć coś prostego i eleganckiego, takiego jak ten, który wszystko rozwiąże.

Należy również pamiętać, że metoda ReadByte po prostu rzutuje bajt na liczbę całkowitą w procesie i można go po prostu przekonwertować.

Dodam kolejną implementację, którą niedawno napisałem, aby utworzyć rodzaj dynamicznego bufora, aby zapewnić sekwencyjne zapisywanie danych, aby zapobiec ogromnemu przeciążeniu

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

Wyjaśnienie jest dość proste: wiemy, że musimy pamiętać o całym zestawie danych, które chcemy zapisać, a także, że chcemy zapisywać tylko określone ilości, więc chcemy, aby pierwsza pętla z ostatnim parametrem była pusta (tak jak podczas gdy ). Następnie inicjalizujemy bufor tablicy bajtów, który jest ustawiony na rozmiar tego, co zostało przekazane, a za pomocą drugiej pętli porównujemy j z rozmiarem bufora i rozmiarem oryginalnego, a jeśli jest większy niż rozmiar oryginału tablica bajtów, zakończ bieg.