System.OutOfMemoryException .NET 4.8 WPF应用程序

zwghvu4y  于 2023-11-20  发布在  .NET
关注(0)|答案(1)|浏览(189)

我正在开发一个WPF（WCF架构）应用程序。这个应用程序有2个主要的解决方案，客户端（前端）和控制器（后端），客户端与后端通信的方式是通过反射调用，本质上它建立了一个XML文档，包含要执行的方法，方法所在的命名空间和方法参数等信息。
所以这个具体的方法是上传文档。它可以完美地工作，直到文件大小> 1GB。当客户端为反射调用构建XML文档时，就会发生错误。
我们像这样添加到XML文档中：

  1. result.Add(new XElement(itemProperty.Name, new XCData(data)));

字符串
在这种情况下，itemProperty.Name是方法名称，XCData是方法args。所以要上传的文档显然是参数，我们在byte[]中接收它。我们需要将它作为字符串传递给XCData构造函数，因此使用以下内容：

  1. string data= Convert.ToBase64String((byte[])value)

型
请注意，这适用于较小的文件，但对于1GB的文件，当试图将byte[]转换为base64 String时，会抛出“System.OutOfMemoryException”异常。
我尝试过分块阅读数组，但是当调用stringBuilder.ToString（）时，同样的异常被抛出.

  1. public static string HandleBigByteArray(byte[] arr)
  2.         {
  3.             try
  4.             {
  5.                 
  6.                 #region approach 2
  7.                 int chunkSize = 104857600;//100MB
  8.                 StringBuilder b64StringBuilder = new StringBuilder();
  9.                 int offset = 0;
  11.                 while (offset < arr.Length)
  12.                 {
  13.                     int remainingBytes = arr.Length - offset;
  14.                     int bytesToEncode = Math.Min(chunkSize, remainingBytes);
  15.                     string base64Chunk = Convert.ToBase64String(arr, offset, bytesToEncode);
  16.                     b64StringBuilder.Append(base64Chunk);
  17.                     offset += bytesToEncode;
  18.                 }
  20.                 return b64StringBuilder.ToString();
  21.                 #endregion
  22.             }
  23.             catch (Exception)
  24.             {
  25.                 throw;
  26.             }
  27.         }

型
我不知道该怎么做，也不知道如何进一步调试/处理这个问题。

.net

1条答案

按热度按时间
vnzz0bqm

vnzz0bqm1#

这里的基本问题是，在构造Base64字符串时，当您执行b64StringBuilder.ToString()时，您试图超过系统上最大可能的.NET字符串长度，正如HitScan在this answer to * What is the maximum possible length of a .NET string? * 中所解释的那样，在64位系统上，最多只能有int.MaxValue / 2个字符。
为了进一步细分，您可以在.NET Framework上分配的最大连续内存块是int.MaxValue字节，即2GB。char占用2个字节，而Base64编码将字符数增加了33%，因此您可以编码的最大字节数组大小约为3/4GB--这正是您所看到的。
(Note如果您设置gcAllowVeryLargeObjects，您将能够在内存中分配最多4GB的数组，因此，如果您这样做，请将上述计算结果乘以系数2。）

若要解决此特定问题，您可以建立一个XText序列，其中包含有限大小的部分区块，并将它们全部新增至itemProperty.Name元素，而不是建立一个包含byte []数组之整个Base64内容的单一XCData。写入XML时，它们会格式化为单一连续文字值。

为此，首先介绍以下扩展方法：

  1. public static partial class XmlExtensions
  2. {
  3.     const int DefaultChunkLength = 8000;
  4.     const int Base64BytesPerChunk = 3; // Base64 encodes 3 bytes to 4 characters.
  5.     
  6.     public static IEnumerable<XText> ToBase64XTextChunks(this Stream stream, int chunkLength = DefaultChunkLength)
  7.     {
  8.         return stream.ToBase64StringChunks(chunkLength).Select(s => new XText(s));
  9.     }
  11.     public static IEnumerable<XText> ToBase64XTextChunks(this IEnumerable<byte []> chunks, int chunkLength = DefaultChunkLength)
  12.     {
  13.         return chunks.Select(b => new ArraySegment<byte>(b)).ToBase64XTextChunks(chunkLength);
  14.     }
  16.     // In .NET Core I would use Memory<T> and/or ReadOnlyMemory<T> instead of ArraySegment<T>.
  18.     public static IEnumerable<XText> ToBase64XTextChunks(this IEnumerable<ArraySegment<byte>> chunks, int chunkLength = DefaultChunkLength)
  19.     {
  20.         return chunks.ToBase64StringChunks(chunkLength).Select(s => new XText(s));
  21.     }
  23.     internal static IEnumerable<string> ToBase64StringChunks(this Stream stream, int chunkLength = DefaultChunkLength)
  24.     {
  25.         if (stream == null)
  26.             throw new ArgumentNullException("stream");
  27.         if (chunkLength < 1 || chunkLength > int.MaxValue / Base64BytesPerChunk)
  28.             throw new ArgumentOutOfRangeException("chunkLength < 1 || chunkLength > int.MaxValue / Base64BytesPerChunk");
  29.         var buffer = new byte[Math.Max(300, Base64BytesPerChunk * DefaultChunkLength)];
  30.         return ToBase64StringChunksEnumerator(stream.ReadAllByteChunks(buffer), chunkLength);
  31.     }
  32.     
  33.     internal static IEnumerable<string> ToBase64StringChunks(this IEnumerable<ArraySegment<byte>> chunks, int chunkLength = DefaultChunkLength)
  34.     {
  35.         if (chunks == null)
  36.             throw new ArgumentNullException("chunks");
  37.         if (chunkLength < 1 || chunkLength > int.MaxValue / 3)
  38.             throw new ArgumentOutOfRangeException("chunkLength < 1 || chunkLength > int.MaxValue / 3");
  39.         return ToBase64StringChunksEnumerator(chunks, chunkLength);
  40.     }
  41.     
  42.     static IEnumerable<string> ToBase64StringChunksEnumerator(this IEnumerable<ArraySegment<byte>> chunks, int chunkLength)
  43.     {
  44.         var buffer = new byte[Base64BytesPerChunk*chunkLength];
  45.         foreach (var chunk in chunks.ToFixedSizedChunks(buffer))
  46.         {
  47.             yield return Convert.ToBase64String(chunk.Array, chunk.Offset, chunk.Count);
  48.         }
  49.     }
  50.     
  51.     internal static IEnumerable<ArraySegment<byte>> ReadAllByteChunks(this Stream stream, byte [] buffer)
  52.     {
  53.         if (stream == null)
  54.             throw new ArgumentNullException("stream");
  55.         if (buffer == null)
  56.             throw new ArgumentNullException("buffer");
  57.         if (buffer.Length < 1)
  58.             throw new ArgumentException("buffer.Length < 1");
  59.         return ReadAllByteChunksEnumerator(stream, buffer);
  60.     }
  62.     static IEnumerable<ArraySegment<byte>> ReadAllByteChunksEnumerator(Stream stream, byte [] buffer)
  63.     {
  64.         int nRead;
  65.         while ((nRead = stream.Read(buffer, 0, buffer.Length)) > 0)
  66.             yield return new ArraySegment<byte>(buffer, 0, nRead);
  67.     }
  68. }
  70. public static partial class EnumerableExtensions
  71. {
  72.     public static IEnumerable<ArraySegment<T>> ToFixedSizedChunks<T>(this IEnumerable<ArraySegment<T>> chunks, T [] buffer)
  73.     {
  74.         if (chunks == null)
  75.             throw new ArgumentNullException("chunks");
  76.         if (buffer.Length == 0)
  77.             throw new ArgumentException("buffer.Length == 0");
  78.         return ToFixedSizedChunksEnumerator(chunks, buffer);
  79.     }
  80.     
  81.     static IEnumerable<ArraySegment<T>> ToFixedSizedChunksEnumerator<T>(IEnumerable<ArraySegment<T>> chunks, T [] buffer) 
  82.     {
  83.         int bufferIndex = 0;
  84.         bool anyRead = false, anyReturned = false;
  85.         foreach (var chunk in chunks)
  86.         {
  87.             anyRead = true;
  88.             int chunkIndex = 0;
  89.             while (chunkIndex < chunk.Count)
  90.             {
  91.                 int toCopy = Math.Min(buffer.Length - bufferIndex, chunk.Count - chunkIndex);
  92.                 if (toCopy > 0)
  93.                 {
  94.                     chunk.CopyTo(chunkIndex, buffer, bufferIndex, toCopy);
  95.                     bufferIndex += toCopy;
  96.                     if (bufferIndex == buffer.Length)
  97.                     {
  98.                         yield return new ArraySegment<T>(buffer, 0, bufferIndex);
  99.                         bufferIndex = 0;
  100.                         anyReturned = true;
  101.                     }
  102.                 }
  103.                 chunkIndex += toCopy;
  104.             }
  105.         }
  106.         // If passed an enumerable of empty chunks we should still return one empty chunk.  But if there were no chunks at all, return nothing.
  107.         if (bufferIndex > 0 || (anyRead && !anyReturned))
  108.             yield return new ArraySegment<T>(buffer, 0, bufferIndex);
  109.     }
  110.     
  111.     public static void CopyTo<T>(this ArraySegment<T> from, int fromIndex, T [] destination, int destinationIndex, int count)
  112.     {
  113.         Buffer.BlockCopy(from.Array, checked(from.Offset + fromIndex), destination, destinationIndex, count);
  114.     }
  115. }

字符串
现在，假设您的byte[] arr值实际上是从fileName文件中读取的，您可以执行以下操作：

  1. var result = new XElement("root");
  3. var e = new XElement(itemProperty.Name);
  4. using (var stream = File.OpenRead(fileName))
  5. {
  6.     foreach (var text in stream.ToBase64XTextChunks())
  7.         e.Add(text);
  8. }
  9. result.Add(e);

型
扩展方法stream.ToBase64XTextChunks()以块为单位读取流，并以块为单位进行编码，这样就不会达到最大数组大小或最大字符串长度。
但如果内存中已经有了巨大的byte [] arr数组，则可以执行以下操作：

  1. foreach (var text in new [] { arr }.ToBase64XTextChunks())
  2.         e.Add(text);

型
注意到

  • 出于性能方面的考虑，我建议将缓冲区和字符串分配保持在80，000字节以下，这样它们就不会在large object heap上运行。
  • 在.NET Core中，我将使用Memory<T>和ReadOnlyMemory<T>，而不是旧的ArraySegment<T>。

演示小提琴here。
话虽如此，您也非常接近达到其他内存限制，包括：

  • 最大byte []阵列大小，即int.MaxValue，即2 GB。

设置gcAllowVeryLargeObjects不会增加此限制。gcAllowVeryLargeObjects只会增加数组可以容纳的内存量。长度仍限制为int.MaxValue。
此限制在客户端和服务器端都将是一个问题。

  • StringBuilder可容纳的最大字符数，从引用源可以看出，它是int.MaxValue。
  • 您的服务器的可用虚拟内存总量。您当前的设计似乎根本没有限制上载大小 *。这可能会使您的服务器容易受到拒绝服务攻击，攻击者会继续上载数据，直到您的服务器内存不足。

如果您有大量的客户端同时上传大量数据，即使没有客户端尝试DOS攻击，您的服务器也会再次耗尽内存。

  • 客户端的可用虚拟内存。如果客户端在资源受限的环境（如智能手机）中运行，则可能无法分配大量内存。

我建议您重新考虑允许任意大的文件上传并将其缓冲在客户端和服务器端的内存中的设计。即使您决定出于业务原因需要支持大于1或2GB的文件上传，我建议你采用一个一种解决方案，其中使用XmlWriter和XmlReader写入和读取内容，而无需将整个内容加载到内存中。要开始，请参阅

展开查看全部
赞(0）分享  回复(0）举报  2023-11-20
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com