ප්‍රවාහයකින් බයිට් අරා නිර්මාණය කිරීම

ආදාන ප්‍රවාහයකින් බයිට් අරා නිර්මාණය කිරීම සඳහා වඩාත් සුදුසු ක්‍රමය කුමක්ද?

.NET 3.5 සමඟ මගේ වර්තමාන විසඳුම මෙන්න.

Stream s;
byte[] b;

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

ඇළේ කුට්ටි කියවීම හා ලිවීම තවමත් වඩා හොඳ අදහසක් ද?

එය සැබවින්ම රඳා පවතින්නේ ඔබට විශ්වාස කළ හැකිද නැද්ද යන්න මතය s.Length. බොහෝ ධාරාවන් සඳහා, කොපමණ දත්ත ප්‍රමාණයක් පවතිනු ඇත්දැයි ඔබ නොදනී. එවැනි අවස්ථාවන්හිදී - සහ .NET 4 ට පෙර - මම මේ වගේ කේත භාවිතා කරමි:

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 සහ ඊට ඉහළින්, මම භාවිතා කරමි Stream.CopyTo, එය මූලික වශයෙන් මගේ කේතයේ ඇති ලූපයට සමාන වේ - නිර්මාණය කරන්න MemoryStream, අමතන්න stream.CopyTo(ms)සහ ආපසු යන්න ms.ToArray(). වැඩේ ඉවරයි.

මගේ පිළිතුර අනෙක් අයට වඩා දිගු වන්නේ මන්දැයි මම සමහර විට පැහැදිලි කළ යුතුය. Stream.Readඑය ඉල්ලා සිටින සෑම දෙයක්ම කියවන බවට සහතික නොවේ. ඔබ ජාල ප්‍රවාහයකින් කියවන්නේ නම්, උදාහරණයක් ලෙස, එය එක් පැකට්ටුවක වටිනාකම කියවා නැවත දත්ත ලබා ගත හැකි වුවද නැවත පැමිණේ. BinaryReader.Readධාරාවේ අවසානය හෝ ඔබේ නිශ්චිත ප්‍රමාණය දක්වා දිගටම පවතිනු ඇත, නමුත් ආරම්භ කිරීමට අවශ්‍ය ප්‍රමාණය ඔබ තවමත් දැන සිටිය යුතුය.

ඉහත ක්‍රමය MemoryStreamදත්ත වලින් ඉවතට යන තෙක් කියවීම (සහ අ වෙත පිටපත් කිරීම ) දිගටම කරගෙන යනු ඇත . ඉන්පසු එය MemoryStreamදත්තවල පිටපතක් අරාවකින් ආපසු ලබා දෙන ලෙස ඉල්ලා සිටී . ආරම්භ කළ යුතු ප්‍රමාණය ඔබ දන්නේ නම් - හෝ ඔබ නොදැනුවත්වම ප්‍රමාණය දන්නවා යැයි සිතන්නේ නම් - ඔබට MemoryStreamආරම්භ කිරීමට අවශ්‍ය ප්‍රමාණය සෑදිය හැකිය. එලෙසම ඔබට අවසානයේ චෙක්පතක් තැබිය හැකි අතර, ධාරාවේ දිග බෆරයට සමාන ප්‍රමාණයක් නම් (ආපසු එවනු ලැබේ MemoryStream.GetBuffer) එවිට ඔබට බෆරය ආපසු ලබා දිය හැකිය. එබැවින් ඉහත කේතය තරමක් ප්‍රශස්ත නොවේ, නමුත් අවම වශයෙන් නිවැරදි වනු ඇත. ධාරාව වැසීම සඳහා එය කිසිදු වගකීමක් භාර නොගනී - අමතන්නා එය කළ යුතුය.

වැඩි විස්තර සඳහා මෙම ලිපිය බලන්න (සහ විකල්ප ක්‍රියාත්මක කිරීමක්).

ජෝන් ගේ පිළිතුර නිවැරදි වුවත්, ඔහු දැනටමත් පවතින කේතය නැවත ලියයි CopyTo. .Net 4 සඳහා සැන්ඩිප්ගේ විසඳුම භාවිතා කරන්න, නමුත් .Net හි පෙර අනුවාදය සඳහා ජෝන් ගේ පිළිතුර භාවිතා කරන්න. CopyToබොහෝ අවස්ථාවන්හි දී ව්‍යතිරේකයන් බොහෝ දුරට ඉඩ ඇති බැවින් "භාවිතා කිරීම" භාවිතා කිරීමෙන් සැන්ඩිප්ගේ කේතය වැඩිදියුණු වනු ඇත MemoryStream.

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

ඔබට දැනටමත් ඇති මතක ධාරාවක් තිබේ නම් පෙන්වා දීමට අවශ්‍යය memorystream.ToArray() සඳහා .

එසේම, ඔබ නොදන්නා හෝ වෙනස් උප ප්‍රභේද සමඟ ගනුදෙනු කරන්නේ නම් සහ ඔබට එය ලැබිය හැකි නම් MemoryStream, ඔබට එම අවස්ථා සඳහා එම ක්‍රමවේදය මත රිලීස් කළ හැකි අතර අනෙක් අය සඳහා පිළිගත් පිළිතුර තවමත් භාවිතා කරන්න:

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

මගේ යුවළගේ ශත ... මම බොහෝ විට භාවිතා කරන පුරුද්ද වන්නේ අභිරුචි සහායකයකු ලෙස මෙවැනි ක්‍රම සංවිධානය කිරීමයි

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

වින්‍යාස ගොනුවට නාම අවකාශයක් එක් කර ඔබට අවශ්‍ය ඕනෑම තැනක එය භාවිතා කරන්න

ඔබට හුදෙක් මතකය ප්‍රවාහ පන්තියේ ToArray () ක්‍රමය භාවිතා කළ හැකිය.

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

ඔබට එය දිගුවන් සමඟ විනෝදකාමී බවට පත් කළ හැකිය:

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

ඉන්පසු එය සාමාන්‍ය ක්‍රමයක් ලෙස අමතන්න:

byte[] arr = someStream.ToByteArray()

මට බොබ්ගේ (එනම් ප්‍රශ්න කරන්නාගේ) කේතය සමඟ සංයුක්ත කාල දෝෂයක් ලැබේ. Stream.Length යනු දිගු වන අතර BinaryReader.ReadBytes පූර්ණ සංඛ්‍යා පරාමිතියක් ගනී. මගේ නඩුවේදී, දිගු නිරවද්‍යතාවයක් අවශ්‍ය තරම් විශාල ධාරාවන් සමඟ කටයුතු කිරීමට මම අපේක්ෂා නොකරමි, එබැවින් මම පහත සඳහන් දෑ භාවිතා කරමි:

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

යමෙක් එයට කැමති නම්, මෙහි .NET 4+ එකම විසඳුමක් වන්නේ මතකය ප්‍රවාහයට අනවශ්‍ය ලෙස බැහැර කිරීමේ ඇමතුමකින් තොරව දිගු කිරීමේ ක්‍රමයක් ලෙසය. මෙය බලාපොරොත්තු රහිතව සුළු සුළු ප්‍රශස්තිකරණයකි, නමුත් මතක ප්‍රවාහයක් බැහැර කිරීමට අපොහොසත් වීම සැබෑ අසාර්ථකත්වයක් නොවන බව සඳහන් කිරීම වටී.

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

ඉහත සඳහන් දෙය හරි ... නමුත් ඔබ SMTP හරහා දේවල් යවන විට දත්ත දූෂණයට මුහුණ දෙනු ඇත (ඔබට අවශ්‍ය නම්). බයිට් සඳහා නිවැරදිව බයිට් යැවීමට උපකාරී වන වෙනත් දෙයකට මම වෙනස් කර ඇත: '

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

නාම අවකාශයේ RestSharp.Extensions කියවීමේ ක්‍රමය ReadAsBytes ඇත. මෙම ක්‍රමය ඇතුළත MemoryStream භාවිතා කරන අතර මෙම පිටුවේ සමහර උදාහරණ වල මෙන් එකම කේතයක් ඇත, නමුත් ඔබ RestSharp භාවිතා කරන විට මෙය පහසුම ක්‍රමයයි.

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

උපකාරක පන්තියක් සාදන්න සහ ඔබ එය භාවිතා කිරීමට කැමති ඕනෑම තැනක එය යොමු කරන්න.

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

මෙය මා භාවිතා කරන, පරීක්ෂා කරන ලද සහ හොඳින් වැඩ කරන ශ්‍රිතයයි. කරුණාකර මතක තබා ගන්න 'ආදානය' ශුන්‍ය නොවිය යුතු අතර කියවීමට පෙර 'input.position' '0' වෙත නැවත සැකසිය යුතුය. එසේ නොවුවහොත් එය කියවීමේ ලූපය බිඳ දමනු ඇති අතර අරාව බවට පරිවර්තනය කිරීමට කිසිවක් කියවන්නේ නැත.

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

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

එය තනි පේළියකින් ක්‍රියාත්මක කිරීමට මට හැකි විය:

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

johnnyRose විසින් පැහැදිලි කර ඇති පරිදි , ඉහත කේතය ක්‍රියාත්මක වන්නේ MemoryStream සඳහා පමණි