Akıştan bayt dizisi oluşturma

Bir giriş akışından bir bayt dizisi oluşturmak için tercih edilen yöntem nedir?

İşte .NET 3.5 ile şu anki çözümüm.

Stream s;
byte[] b;

using (BinaryReader br = new BinaryReader(s))
{
    b = br.ReadBytes((int)s.Length);
}

Akışın parçalarını okumak ve yazmak hala daha iyi bir fikir mi?

Gerçekten güvenip güvenemeyeceğinize bağlıdır s.Length. Birçok akış için, ne kadar veri olacağını bilmiyorsunuz. Bu gibi durumlarda - ve .NET 4'ten önce - böyle bir kod kullanırdım:

public static byte[] ReadFully(Stream input)
{
    byte[] buffer = new byte[16*1024];
    using (MemoryStream ms = new MemoryStream())
    {
        int read;
        while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
        {
            ms.Write(buffer, 0, read);
        }
        return ms.ToArray();
    }
}

.NET 4 ve üstü ile, Stream.CopyTotemelde benim kod döngü - eşdeğer kullanın, oluşturmak MemoryStream, çağrı stream.CopyTo(ms)ve sonra dön ms.ToArray(). İş bitmiş.

Belki de cevabımın neden diğerlerinden daha uzun olduğunu açıklamalıyım. Stream.Readistenen her şeyi okuyacağını garanti etmez. Örneğin, bir ağ akışından okuyorsanız, bir paketin değerini okuyabilir ve yakında daha fazla veri olsa bile geri dönebilir. BinaryReader.Readakışın sonuna veya belirttiğiniz boyuta kadar devam eder, ancak yine de başlamak için boyutu bilmeniz gerekir.

Yukarıdaki yöntem MemoryStream, veri bitene kadar okumaya devam eder (ve a'ya kopyalar ). Daha sonra MemoryStream, bir dizideki verilerin bir kopyasını döndürmesini ister . Başlamak için boyutu biliyorsanız - veya boyutu bilmediğinizi düşünüyorsanız , emin olmadan - MemoryStreamile başlamak için bu boyutta olacak şekilde yapılandırabilirsiniz . Benzer şekilde, sonunda bir kontrol koyabilirsiniz ve akışın uzunluğu arabellekle (döndürülen MemoryStream.GetBuffer) ile aynı boyuttaysa, ara belleği geri verebilirsiniz. Dolayısıyla yukarıdaki kod oldukça optimize edilmemiştir, ancak en azından doğru olacaktır. Akışı kapatmak için herhangi bir sorumluluk kabul etmez - arayan bunu yapmalıdır.

Daha fazla bilgi (ve alternatif bir uygulama) için bu makaleye bakın .

Jon'un cevabı doğru olsa da, zaten mevcut olan kodu yeniden yazıyor CopyTo. Net 4 için Sandip'in çözümünü kullanın, ancak .Net'in önceki sürümü için Jon'un yanıtını kullanın. Sandip'in kodu CopyTo, birçok durumda istisna olarak "kullanmanın" kullanılmasıyla geliştirilecektir ve çoğu durumda MemoryStreamimha edilmeyecektir.

public static byte[] ReadFully(Stream input)
{
    using (MemoryStream ms = new MemoryStream())
    {
        input.CopyTo(ms);
        return ms.ToArray();
    }
}

Sadece bunun memorystream.ToArray()için zaten bir MemoryStream'iniz varsa belirtmek istersiniz .

Ayrıca, bilinmeyen veya farklı alt türlerin akışlarıyla uğraşıyorsanız ve bir alabilirseniz MemoryStream, bu durumlar için adı geçen yöntemi aktarabilir ve yine de diğerleri için kabul edilen cevabı kullanabilirsiniz:

public static byte[] StreamToByteArray(Stream stream)
{
    if (stream is MemoryStream)
    {
        return ((MemoryStream)stream).ToArray();                
    }
    else
    {
        // Jon Skeet's accepted answer 
        return ReadFully(stream);
    }
}

MemoryStream ms = new MemoryStream();
file.PostedFile.InputStream.CopyTo(ms);
var byts = ms.ToArray();
ms.Dispose();

sadece çift sentim ... sık kullandığım uygulama, böyle bir yöntemi özel bir yardımcı olarak organize etmektir

public static class StreamHelpers
{
    public static byte[] ReadFully(this Stream input)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            input.CopyTo(ms);
            return ms.ToArray();
        }
    }
}

yapılandırma dosyasına ad alanı ekleyin ve istediğiniz yere kullanın

MemoryStream sınıfının ToArray () yöntemini ex-

MemoryStream ms = (MemoryStream)dataInStream;
byte[] imageBytes = ms.ToArray();

Hatta uzantılarla daha da meraklı olabilirsiniz:

namespace Foo
{
    public static class Extensions
    {
        public static byte[] ToByteArray(this Stream stream)
        {
            using (stream)
            {
                using (MemoryStream memStream = new MemoryStream())
                {
                     stream.CopyTo(memStream);
                     return memStream.ToArray();
                }
            }
        }
    }
}

Ve sonra düzenli bir yöntem olarak adlandırın:

byte[] arr = someStream.ToByteArray()

Bob (yani soru soran) kodu ile derleme zamanı hatası alıyorum. Stream.Length uzun, BinaryReader.ReadBytes bir tamsayı parametresi alır. Benim durumumda, uzun hassasiyet gerektirecek kadar büyük Akışlarla uğraşmayı beklemiyorum, bu yüzden aşağıdakileri kullanıyorum:

Stream s;
byte[] b;

if (s.Length > int.MaxValue) {
  throw new Exception("This stream is larger than the conversion algorithm can currently handle.");
}

using (var br = new BinaryReader(s)) {
  b = br.ReadBytes((int)s.Length);
}

Herkes beğenirse, burada MemoryStream üzerinde gereksiz Dispose çağrısı olmadan bir uzantı yöntemi olarak oluşturulan bir .NET 4+ sadece çözümü. Bu umutsuzca önemsiz bir optimizasyon, ancak bir MemoryStream öğesinin imha edilmemesinin gerçek bir hata olmadığını belirtmek gerekir.

public static class StreamHelpers
{
    public static byte[] ReadFully(this Stream input)
    {
        var ms = new MemoryStream();
        input.CopyTo(ms);
        return ms.ToArray();
    }
}

Yukarıdaki bir ok ... ama SMTP üzerinden bir şeyler gönderdiğinizde (gerekirse) veri bozulması ile karşılaşacaksınız. Baytın bayt için doğru bir şekilde gönderilmesine yardımcı olacak başka bir şeye değiştirdim: '

using System;
using System.IO;

        private static byte[] ReadFully(string input)
        {
            FileStream sourceFile = new FileStream(input, FileMode.Open); //Open streamer
            BinaryReader binReader = new BinaryReader(sourceFile);
            byte[] output = new byte[sourceFile.Length]; //create byte array of size file
            for (long i = 0; i < sourceFile.Length; i++)
                output[i] = binReader.ReadByte(); //read until done
            sourceFile.Close(); //dispose streamer
            binReader.Close(); //dispose reader
            return output;
        }'

Bir yardımcı sınıf oluşturun ve kullanmak istediğiniz yere referans verin.

public static class StreamHelpers
{
    public static byte[] ReadFully(this Stream input)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            input.CopyTo(ms);
            return ms.ToArray();
        }
    }
}

RestSharp.Extensions ad alanında ReadAsBytes yöntemi vardır. Bu yöntemin içinde MemoryStream kullanılır ve bu sayfadaki bazı örneklerde olduğu gibi aynı kod vardır, ancak RestSharp kullanırken bu en kolay yoldur.

using RestSharp.Extensions;
var byteArray = inputStream.ReadAsBytes();

Bu uzantı yöntemini kullanabilirsiniz.

public static class StreamExtensions
{
    public static byte[] ToByteArray(this Stream stream)
    {
        var bytes = new List<byte>();

        int b;
        while ((b = stream.ReadByte()) != -1)
            bytes.Add((byte)b);

        return bytes.ToArray();
    }
}

Bu, kullandığım, test ettiğim ve iyi çalıştığım işlev. lütfen 'input' değerinin boş olmaması ve 'input.position' ifadesinin okumadan önce '0' değerine ayarlanması gerektiğini unutmayın; aksi takdirde okuma döngüsünü kıracaktır ve diziye dönüştürmek için hiçbir şey okunmayacaktır.

    public static byte[] StreamToByteArray(Stream input)
    {
        if (input == null)
            return null;
        byte[] buffer = new byte[16 * 1024];
        input.Position = 0;
        using (MemoryStream ms = new MemoryStream())
        {
            int read;
            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
            {
                ms.Write(buffer, 0, read);
            }
            byte[] temp = ms.ToArray();

            return temp;
        }
    }

public static byte[] ToByteArray(Stream stream)
    {
        if (stream is MemoryStream)
        {
            return ((MemoryStream)stream).ToArray();
        }
        else
        {
            byte[] buffer = new byte[16 * 1024];
            using (MemoryStream ms = new MemoryStream())
            {
                int read;
                while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    ms.Write(buffer, 0, read);
                }
                return ms.ToArray();
            }
        }            
    }

i tek bir satır üzerinde çalışmasını başardı:

byte [] byteArr= ((MemoryStream)localStream).ToArray();

johnnyRose tarafından açıklandığı gibi , yukarıdaki kod sadece MemoryStream için çalışacaktır