C＃でストリームをファイルに保存するにはどうすればよいですか？

StreamReaderストリームで初期化したオブジェクトがありますが、このストリームをディスクに保存したいと思います（ストリームは.gifまたは.jpgまたはの場合があります.pdf）。

既存のコード：

StreamReader sr = new StreamReader(myOtherObject.InputStream);

1. これをディスクに保存する必要があります（ファイル名があります）。
2. 将来的には、これをSQL Serverに保存する必要があるかもしれません。

SQL Serverに保存する場合に必要となるエンコードタイプもありますが、正しいですか？

Jon Skeetの回答で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);
}

あなたはしてはならない使用StreamReader（GIFやJPGのみのような）バイナリ・ファイルのために。テキストデータ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で導入された、基本的に同じ目的を果たします。

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

CopyToアプリを使用するシステムが.NET 4.0以降にアップグレードされていない可能性があるため、を使用してすべての回答を得ることができません。人々に強制的にアップグレードさせたいと思う人もいますが、互換性も素晴らしいです。

もう1つ、ストリームを使用して最初から別のストリームからコピーすることはありません。なぜそうしないのですか？

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 MB未満）でのみ使用したことは認めています。1つのストリーム、ストリーム間でのコピー、エンコーディングの必要なし、バイトの書き込みのみ！StreamReader既にbytes直接ストリームに変換できるストリームがある場合、で複雑化する必要はありません.ToArray()。

この方法で私が見ることができる潜在的な欠点は、大きなファイルがあり、それをストリームとして持ち、バイト配列を使用して1つずつバイトを読み取る代わりに、.CopyTo()それと同等またはFileStreamそれを使用してストリーミングできることです。結果として、この方法で実行するのが遅くなる可能性があります。しかし.Write()、FileStreamハンドルのメソッドがバイトを書き込むので、チョークするべきではなく、一度に1バイトしか実行しないため、ストリームをaとして保持するのに十分なメモリが必要でbyte[]あることを除いて、メモリを詰まらせませんオブジェクト。これを使用した私の状況では、を取得しOracleBlob、に移動する必要がありましたbyte[]。それは十分に小さかっただけでなく、いずれにせよ、ストリーミングを利用できなかったため、上記の関数にバイトを送信しました。

ストリームを使用する別のオプションCopyStreamは、別の投稿にあるJon Skeetの関数と一緒に使用することです。これは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();
}

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

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

別のオプションは、ストリームをaに取得して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.
}

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

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

重要なのは、適切な使用法（上記のように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);
        }
    }
}

説明はかなり単純です。書き込みたいデータのセット全体を覚えておく必要があること、および特定の量だけを書き込みたいことを知っているので、最後のパラメーターを空にして最初のループを行います（これまでと同じです）。 ）。次に、渡されたサイズに設定されたバイト配列バッファーを初期化し、2番目のループでjをバッファーのサイズおよび元のサイズと比較し、それが元のサイズより大きいかどうかを調べます。バイト配列、実行を終了します。