【问题标题】:Creating a byte array from a stream从流中创建字节数组
【发布时间】:2021-02-28 21:03:11
【问题描述】:

从输入流创建字节数组的首选方法是什么?

这是我目前使用 .NET 3.5 的解决方案。

Stream s;
byte[] b;

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

读取和写入流的块仍然是一个更好的主意吗?

【问题讨论】:

  • 当然,另一个问题是应该从流中创建一个字节[]...对于大数据,最好将流视为一个流!
  • 确实你应该使用流而不是字节[]。但是有些系统 API 不支持流。例如,您不能从流中创建X509Certificate2,您必须给它一个字节[](或字符串)。在这种情况下,这很好,因为 x509 证书可能不是大数据。
  • 二进制阅读器是否没有将 UTF-8 编码附加到流中?如果您不阅读文本(例如,如果您正在阅读图像等),那不是问题吗? docs.microsoft.com/en-us/dotnet/api/…

标签: c# .net-3.5 inputstream


【解决方案1】:

这真的取决于你是否可以信任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 返回),那么您可以只返回缓冲区。所以上面的代码不是很优化,但至少是正确的。它不承担关闭流的任何责任——调用者应该这样做。

请参阅this article 了解更多信息(以及替代实现)。

【讨论】:

  • @Jon,值得一提的是yoda.arachsys.com/csharp/readbinary.html
  • @Jeff:我们这里没有真正的上下文,但是如果您一直在写入流,那么是的,您需要在阅读之前“倒带”它。只有一个“光标”表示您在流中的位置 - 不是一个用于阅读,一个用于书写。
  • @Jeff:这是调用者的责任。毕竟,流可能无法搜索(例如网络流),或者根本不需要倒带。
  • 我能问一下为什么是16*1024吗?
  • @just_name:我不知道这是否有任何意义,但 (16*1024) 恰好是 Int16.MaxValue 的一半 :)
【解决方案2】:

只是想指出,如果你有一个 MemoryStream,你已经有 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);
    }
}

【讨论】:

  • 嗯,所有的赞成票是为了什么?即使有最慷慨的假设,这只适用于已经是MemoryStreams 的流。当然,这个例子显然也是不完整的,它是如何使用一个未初始化的变量的。
  • 没错,感谢您指出这一点。不过,这一点仍然代表 MemoryStream,因此我对其进行了修复以反映这一点。
  • 只需提到 MemoryStream 的另一种可能性是 MemoryStream.GetBuffer(),尽管其中涉及一些问题。见stackoverflow.com/questions/1646193/… 和krishnabhargav.blogspot.dk/2009/06/…
  • 这实际上在 Skeet 的代码中引入了一个错误;如果您调用stream.Seek(1L, SeekOrigin.Begin),在您充分调用之前,如果流是内存流,您将获得比任何其他流多1 个字节。如果调用者希望从当前位置读取到流的末尾,那么您不能使用CopyTo 或ToArray();在大多数情况下,这不是问题,但如果调用者不知道这种古怪的行为,他们会感到困惑。
【解决方案3】:
MemoryStream ms = new MemoryStream();
file.PostedFile.InputStream.CopyTo(ms);
var byts = ms.ToArray();
ms.Dispose();

【讨论】:

  • MemoryStream 应使用“new MemoryStream(file.PostedFile.ContentLength)”创建以避免内存碎片。
【解决方案4】:

我收到 Bob(即提问者)代码的编译时错误。 Stream.Length 是 long 而 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);
}

【讨论】:

    【解决方案5】:

    虽然 Jon 的回答是正确的,但他正在重写 CopyTo 中已经存在的代码。因此,对于 .Net 4 使用 Sandip 的解决方案,但对于以前版本的 .Net 使用 Jon 的答案。 Sandip 的代码可以通过使用“使用”来改进,因为在许多情况下,CopyTo 中的异常很可能会导致 MemoryStream 未处理。

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

    【讨论】:

    • 你的答案和乔恩的有什么不同?我也必须这样做 input.Position=0 才能让 CopyTo 工作。
    • @nathan ,从 Web 客户端读取文件 (filizesize=1mb) - iis 必须将整个 1mb 加载到其内存中对吗?
    • @Jeff,我的回答仅适用于 .Net 4 或更高版本,Jons 将通过重写更高版本中提供给我们的功能来处理较低版本。你是正确的,CopyTo 只会从当前位置复制,如果你有一个 Seekable 流并且你想从头开始复制,那么你可以使用你的代码或 input.Seek(0, SeekOrigin.Begin) 移动到开头,尽管在许多情况下,您的流可能无法搜索。
    • 检查input 是否已经是MemorySteam 并且短路可能是值得的。我知道调用者传递MemoryStream 会很愚蠢,但是...
    • @Jodrell,确实如此。如果您将数百万个小流复制到内存中,其中一个是MemoryStream,那么优化在您的上下文中是否有意义是进行数百万次类型转换所花费的时间与复制一个所花费的时间的比较这是一个 MemoryStream 到另一个 MemoryStream。
    【解决方案6】:

    您甚至可以通过扩展使其更漂亮:

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

    【讨论】:

    • 我认为将输入流放在 using 块中是个坏主意。该责任应由调用程序承担。
    【解决方案7】:

    上面的没问题...但是当您通过 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;
            }'
    

    【讨论】:

    • 我看不出这段代码在哪里可以避免数据损坏。你能解释一下吗?
    • 假设你有一张图片,你想通过 SMTP 发送它。您可能会使用 base64 编码。出于某种原因,如果将文件分解为字节,文件就会损坏。但是,使用二进制阅读器将允许文件成功发送。
    • 有些旧,但我觉得值得一提 - @NothinRandom 提供的实现适用于字符串,而不是流。不过,在这种情况下使用 File.ReadAllBytes 可能是最简单的。
    • 因为危险的代码风格而投反对票(没有自动处置/使用)。
    • 遗憾的是只允许-1,与问题无关,文件名参数命名为输入,不处理,没有读取缓冲区,没有文件模式,以及二进制读取器逐字节读取为什么?
    【解决方案8】:

    只是我的几分钱......我经常使用的做法是将这样的方法组织为自定义助手

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

    将命名空间添加到配置文件并在您希望的任何地方使用它

    【讨论】:

    • 请注意,这在 .NET 3.5 及更低版本中不起作用,因为 CopyTo 在 4.0 之前在 Stream 上不可用。
    【解决方案9】:

    我能够让它在一行上工作:

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

    johnnyRose 已澄清,以上代码仅适用于 MemoryStream

    【讨论】:

    • 如果localStream 不是MemoryStream 怎么办?此代码将失败。
    • localStream 必须是基于流的对象。更多关于基于流的对象在这里stackoverflow.com/questions/8156896/…
    • 我想建议的是,如果您尝试将localStream 转换为MemoryStream,但localStream 不是 MemoryStream,它将失败。这段代码可以正常编译,但在运行时可能会失败,具体取决于localStream 的实际类型。您不能总是随意地将基类型转换为子类型; read more here。 This is another good example 解释了为什么你不能总是这样做。
    • 详细说明我上面的评论:所有的MemoryStreams都是Streams,但不是所有的Streams都是MemoryStreams。
    • 那是错误的。简单示例:无法将FileStream 转换为MemoryStream,并且将失败并出现以下错误:“无法将'System.IO.FileStream' 类型的对象转换为'System.IO.MemoryStream' 类型。”示例:using (Stream fs = new FileStream(@"C:\pathtofile.txt", FileMode.Open)) { var memoryStream = (MemoryStream)fs; } 如果您只使用var,这将不会编译,因为它会隐式键入MemoryStream。如上所述使用Stream 键入它会创建一个运行时异常,正如我之前解释的那样。试试看,自己看看。
    【解决方案10】:

    将投票率最高的两个答案组合成一个扩展方法:

    public static byte[] ToByteArray(this Stream stream)
    {
        if (stream is MemoryStream)
            return ((MemoryStream)stream).ToArray();
        else
        {
            using MemoryStream ms = new();
            stream.CopyTo(ms);
            return ms.ToArray();
        }            
    }
    

    【讨论】:

    • 当您添加代码时,还要简要描述您提出的解决方案。
    【解决方案11】:

    您可以使用此扩展方法。

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

    【讨论】:

      【解决方案12】:

      您可以简单地使用 MemoryStream 类的 ToArray() 方法,例如-

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

      【讨论】:

      • 这只有在dataInStream 已经是MemoryStream 时才有效
      【解决方案13】:

      创建一个辅助类并在您希望使用它的任何地方引用它。

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

      【讨论】:

        【解决方案14】:

        如果有人喜欢,这里有一个仅 .NET 4+ 的解决方案,它作为扩展方法形成,无需对 MemoryStream 进行不必要的 Dispose 调用。这是一个无可救药的微不足道的优化,但值得注意的是,未能 Dispose 内存流并不是真正的失败。

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

        【讨论】:

          【解决方案15】:

          这是我正在使用、测试并运行良好的功能。 请记住,'input' 不应为 null,并且在读取之前,'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;
                  }
              }
          

          【讨论】:

            【解决方案16】:

            在命名空间 RestSharp.Extensions 中有方法 ReadAsBytes。此方法内部使用了 MemoryStream,并且与此页面上的某些示例中的代码相同,但是当您使用 RestSharp 时,这是最简单的方法。

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

            【讨论】:

              【解决方案17】:

              如果流支持 Length 属性,则可以直接创建字节数组。优点是MemoryStream.ToArray 创建了两次数组。另外,缓冲区中可能有一些未使用的额外字节。此解决方案分配所需的确切数组。如果流不支持Length属性,则会抛出NotSupportedException异常。

              另外值得注意的是,数组不能大于 int.MaxValue。

              public static async Task<byte[]> ToArrayAsync(this Stream stream)
              {
                  var array = new byte[stream.Length];
                  await stream.ReadAsync(array, 0, (int)stream.Length);
                  return array;
              }
              

              根据流是否支持搜索在两个版本之间切换的完整代码。

              /// <summary>
              /// Converts stream to byte array.
              /// </summary>
              /// <param name="stream">Stream</param>
              /// <returns>Binary data from stream in an array</returns>
              public static async Task<byte[]> ToArrayAsync(this Stream stream)
              {
                  if (!stream.CanRead)
                  {
                      throw new AccessViolationException("Stream cannot be read");
                  }
              
                  if (stream.CanSeek)
                  {
                      return await ToArrayAsyncDirect(stream);
                  }
                  else
                  {
                      return await ToArrayAsyncGeneral(stream);
                  }
              }
              
              private static async Task<byte[]> ToArrayAsyncGeneral(Stream stream)
              {
                  using (var memoryStream = new MemoryStream())
                  {
                      await stream.CopyToAsync(memoryStream);
                      return memoryStream.ToArray();
                  }
              }
              
              private static async Task<byte[]> ToArrayAsyncDirect(Stream stream)
              {
                  var array = new byte[stream.Length];
                  await stream.ReadAsync(array, 0, (int)stream.Length);
                  return array;
              }
              

              【讨论】:

                猜你喜欢
                • 2017-06-17
                • 1970-01-01
                • 2011-10-05
                • 2015-11-19
                • 2013-09-23
                • 2012-04-05
                • 1970-01-01
                • 1970-01-01
                相关资源
                最近更新 更多