Bagaimana cara saya menyimpan aliran ke file di C #?

Saya memiliki StreamReaderobjek yang saya inisialisasi dengan aliran, sekarang saya ingin menyimpan aliran ini ke disk (aliran mungkin a .gifatau .jpgatau .pdf).

Kode yang ada:

StreamReader sr = new StreamReader(myOtherObject.InputStream);

1. Saya perlu menyimpan ini ke disk (saya memiliki nama file).
2. Di masa depan saya mungkin ingin menyimpan ini ke SQL Server.

Saya memiliki tipe penyandian juga, yang akan saya perlukan jika saya menyimpannya ke SQL Server, benar?

Seperti yang disorot oleh Tilendor dalam jawaban Jon Skeet, stream memiliki CopyTometode sejak .NET 4.

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

Atau dengan usingsintaks:

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

Anda tidak boleh menggunakan StreamReaderfile biner (seperti gifs atau jpgs). StreamReaderadalah untuk data teks . Anda hampir pasti akan kehilangan data jika Anda menggunakannya untuk data biner sewenang-wenang. (Jika Anda menggunakan Encoding.GetEncoding (28591) Anda mungkin akan baik-baik saja, tapi apa gunanya?)

Mengapa Anda perlu menggunakan StreamReadersama sekali? Mengapa tidak hanya menyimpan data biner sebagai data biner dan menulisnya kembali ke disk (atau SQL) sebagai data biner?

EDIT: Karena ini tampaknya menjadi sesuatu yang orang ingin melihat ... jika Anda tidak hanya ingin menyalin satu aliran yang lain (misalnya untuk file) menggunakan sesuatu seperti ini:

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

Untuk menggunakannya untuk membuang aliran ke file, misalnya:

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

Catatan yang Stream.CopyTodiperkenalkan di .NET 4, pada dasarnya melayani tujuan yang sama.

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

Saya tidak mendapatkan semua jawaban menggunakan CopyTo, di mana mungkin sistem yang menggunakan aplikasi mungkin belum ditingkatkan ke .NET 4.0+. Saya tahu beberapa orang ingin memaksa orang untuk melakukan upgrade, tetapi kompatibilitasnya juga bagus.

Hal lain, saya tidak bisa menggunakan aliran untuk menyalin dari aliran lain di tempat pertama. Mengapa tidak lakukan saja:

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

Setelah Anda memiliki byte, Anda dapat dengan mudah menuliskannya ke 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();
    }
}

Kode ini berfungsi saat saya mengujinya dengan a .jpg file, meskipun saya akui saya hanya menggunakannya dengan file kecil (kurang dari 1 MB). Satu aliran, tidak ada penyalinan antar aliran, tidak perlu penyandian, cukup tulis byte! Tidak perlu terlalu rumit hal-hal dengan StreamReaderjika Anda sudah memiliki aliran Anda dapat mengonversi bytessecara langsung dengan .ToArray()!

Hanya kerugian potensial yang dapat saya lihat dengan melakukannya dengan cara ini adalah jika ada file besar yang Anda miliki, menjadikannya sebagai stream dan menggunakan .CopyTo()atau setara memungkinkan FileStreamuntuk streaming itu daripada menggunakan array byte dan membaca byte satu per satu. Mungkin lebih lambat melakukannya dengan cara ini, sebagai hasilnya. Tetapi seharusnya tidak tersedak karena .Write()metode FileStreampegangan menulis byte, dan itu hanya melakukannya satu byte pada satu waktu, sehingga tidak akan menyumbat memori, kecuali bahwa Anda harus memiliki cukup memori untuk menahan aliran sebagai byte[]objek . Dalam situasi saya di mana saya menggunakan ini, mendapatkan OracleBlob, saya harus pergi ke byte[], itu cukup kecil, dan lagi pula, tidak ada streaming yang tersedia untuk saya, jadi saya hanya mengirim byte saya ke fungsi saya, di atas.

Pilihan lain, menggunakan aliran, akan menggunakannya dengan CopyStreamfungsi Jon Skeet yang ada di pos lain - ini hanya menggunakan FileStreamuntuk mengambil aliran input dan membuat file dari itu secara langsung. Itu tidak digunakan File.Create, seperti yang dia lakukan (yang awalnya tampak bermasalah bagi saya, tetapi kemudian menemukan itu kemungkinan hanya 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.
*/

Mengapa tidak menggunakan objek 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);
     }
}

Pilihan lain adalah untuk mendapatkan aliran ke byte[]dan gunakan File.WriteAllBytes. Ini harus dilakukan:

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

Membungkusnya dengan metode ekstensi memberikan penamaan yang lebih baik:

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

Berikut adalah contoh yang menggunakan penggunaan yang tepat dan implementasi 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());
            }
        }
    }
}

... dan ada juga ini

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

Kuncinya adalah memahami penggunaan yang tepat dari penggunaan (yang harus diimplementasikan pada instantiasi objek yang mengimplementasikan idisposable seperti yang ditunjukkan di atas), dan memiliki ide yang bagus tentang bagaimana properti bekerja untuk stream. Posisi secara harfiah adalah indeks dalam aliran (yang dimulai dari 0) yang diikuti setiap byte dibaca menggunakan metode readbyte. Dalam hal ini saya pada dasarnya menggunakannya sebagai pengganti variabel loop dan hanya membiarkannya mengikuti sampai ke panjang yang pada akhirnya adalah akhir dari seluruh aliran (dalam byte). Abaikan dalam byte karena praktis sama dan Anda akan memiliki sesuatu yang sederhana dan elegan seperti ini yang menyelesaikan semuanya dengan bersih.

Perlu diingat juga, bahwa metode ReadByte hanya membuang byte ke int dalam proses dan hanya dapat dikonversi kembali.

Saya akan menambahkan implementasi lain yang baru-baru ini saya tulis untuk membuat semacam buffer dinamis untuk memastikan data berurutan menulis untuk mencegah kelebihan besar

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

Penjelasannya cukup sederhana: kita tahu bahwa kita perlu mengingat seluruh rangkaian data yang ingin kita tulis dan juga kita hanya ingin menulis jumlah tertentu, jadi kita ingin loop pertama dengan parameter terakhir kosong (sama seperti saat ). Selanjutnya, kita menginisialisasi buffer array byte yang diatur ke ukuran yang dilewati, dan dengan loop kedua kita membandingkan j dengan ukuran buffer dan ukuran yang asli, dan jika itu lebih besar dari ukuran aslinya array byte, akhiri prosesnya.