Как сохранить поток в файл на C#?

Вы не должен используете StreamReader для двоичных файлов (например, gif или jpgs). StreamReader предназначен для данных текст. Вы почти потеряете безусловно, если будете использовать его для произвольных двоичных данных. (Если вы используете Encoding.GetEncoding (28591), вероятно, все будет в порядке, но какой в ​​этом смысл?)

Зачем вообще нужно использовать StreamReader? Почему бы просто не сохранить двоичные данные в виде и записать их обратно на диск (или в SQL) как двоичные данные?

Обновлено: Поскольку это похоже на то, что люди хотят видеть ... если вы делать просто хотите скопировать один поток в другой (например, в файл), используйте что-то вроде этого:

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

Чтобы использовать его для сброса потока в файл, например:

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

Обратите внимание, что Stream.CopyTo был введен в .NET 4 и служит в основном той же цели.

Почему бы не использовать объект 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);
     }
}

Как подчеркнул Tilendor в ответе Джона Скита, потоки имеют метод CopyTo, начиная с .NET 4.

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

Или с синтаксисом using:

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

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

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

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

Другой вариант - передать поток на byte[] и использовать File.WriteAllBytes. Это должно делать:

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

Оборачивание его в метод расширения дает ему лучшее именование:

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

Я не получаю все ответы, используя CopyTo, где, возможно, системы, использующие приложение, могли не быть обновлены до .NET 4.0+. Я знаю, что некоторые хотели бы заставить людей обновиться, но совместимость тоже хороша.

Другое дело, я вообще не использую поток для копирования из другого потока. Почему бы просто не сделать:

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

Получив байты, вы можете легко записать их в файл:

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

Этот код работает так же, как я тестировал его с файлом .jpg, хотя я признаю, что использовал его только с небольшими файлами (менее 1 МБ). Один поток, без копирования между потоками, без кодирования, просто напишите байты! Нет необходимости усложнять вещи с StreamReader, если у вас уже есть поток, который вы можете преобразовать в bytes напрямую с .ToArray()!

Единственные потенциальные недостатки, которые я вижу в этом способе, - это наличие у вас большого файла, использование его в виде потока и использование .CopyTo() или его эквивалента позволяет FileStream передавать его в потоковом режиме вместо использования массива байтов и чтения байтов один за другим. В результате это может быть медленнее. Но он не должен задыхаться, поскольку метод .Write() в FileStream обрабатывает запись байтов и делает это только по одному байту за раз, поэтому он не забивает память, за исключением у вас должно быть достаточно памяти для хранения потока как объекта byte[]. В моей ситуации, когда я использовал это, получая OracleBlob, мне пришлось перейти к byte[], он был достаточно маленьким, и, кроме того, мне все равно не было потоковой передачи, поэтому я просто отправил свои байты в свою функцию, описанную выше.

Другой вариант, используя поток, - это использовать его с функцией CopyStream Джона Скита, которая была в другом сообщении - здесь просто используется FileStream для получения входного потока и создания файла напрямую из него. Он не использует File.Create, как он (что сначала показалось мне проблематичным, но позже выяснилось, что это, скорее всего, просто ошибка 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();
}

Вот пример правильного использования и реализации 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());
            }
        }
    }
}

... и еще это

    public static void WriteToFile(Stream 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());
            }
        }
    }

Ключевым моментом является понимание правильного использования using (которое должно быть реализовано при создании экземпляра объекта, реализующего idisposable, как показано выше), и хорошее представление о том, как свойства работают для потоков. Позиция - это буквально индекс в потоке (который начинается с 0), за которым следует каждый байт, считанный с использованием метода readbyte. В этом случае я, по сути, использую его вместо переменной цикла for и просто позволяю ему пройти весь путь до длины, которая БУКВАЛЬНО является концом всего потока (в байтах). Игнорируйте в байтах, потому что это практически то же самое, и у вас будет что-то простое и элегантное, подобное этому, которое решает все чисто.

Также имейте в виду, что метод ReadByte просто преобразует байт в int в процессе и может быть просто преобразован обратно.

Я собираюсь добавить еще одну реализацию, которую я недавно написал, чтобы создать своего рода динамический буфер, чтобы обеспечить последовательную запись данных, чтобы предотвратить массовую перегрузку.

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

Объяснение довольно простое: мы знаем, что нам нужно иметь в виду весь набор данных, которые мы хотим записать, а также то, что мы хотим записать только определенные суммы, поэтому нам нужен первый цикл с последним параметром пустым (так же, как и while ). Затем мы инициализируем буфер массива байтов, для которого установлен размер переданного, и во втором цикле мы сравниваем j с размером буфера и размером исходного, и если он больше размера оригинала байтовый массив, завершите запуск.