认为我有内存泄漏

Question

遇到这个错误：

“System.OutOfMemoryException”类型的异常发生在 System.Drawing.dll 但未在用户代码中处理

附加信息：内存不足。

它发生在DrawImage调用的以下方法中

/// <summary>
        /// Resize the image to the specified width and height.
        /// </summary>
        /// <param name="image">The image to resize.</param>
        /// <returns>The resized image.</returns>
        public Bitmap ResizeImage(Image image, System.Drawing.Size newSize)
        {
            var destRect = new Rectangle(0, 0, newSize.Width, newSize.Height);
            var destImage = new Bitmap(newSize.Width, newSize.Height);

            destImage.SetResolution(image.HorizontalResolution, image.VerticalResolution);

            using (var graphics = Graphics.FromImage(destImage))
            {
                graphics.CompositingMode = CompositingMode.SourceCopy;
                graphics.CompositingQuality = CompositingQuality.HighQuality;
                graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
                graphics.SmoothingMode = SmoothingMode.HighQuality;
                graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;

                using (var wrapMode = new ImageAttributes())
                {
                    wrapMode.SetWrapMode(WrapMode.TileFlipXY);
                    graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, wrapMode);
                }
            }

            return destImage;
        }

我不知道为什么会这样，我多次调用这个方法，结果被转换成 Base64 字符串并存储在 ObservableCollection 中。

/// <summary>
        /// Convert Image and Resize
        /// </summary>
        /// <param name="loc"></param>
        /// <returns></returns>
        public async Task<string> GenerateThumbnailBinary(string loc)
        {
            return await Task<string>.Factory.StartNew(() =>
            {
                Image image = Image.FromFile(loc, true);

                // Figure out the ratio
                double ratioX = (double)Properties.Settings.Default.ThumbnailWidth.Width / (double)image.Width;
                double ratioY = (double)Properties.Settings.Default.ThumbnailWidth.Height / (double)image.Height;
                // use whichever multiplier is smaller
                double ratio = ratioX < ratioY ? ratioX : ratioY;

                System.Drawing.Size newSize = 
                new System.Drawing.Size(
                    (int)(image.Width * ratio), 
                    (int)(image.Height * ratio));

                Image resized = ResizeImage(image, newSize);

                return ImageToBase64(resized, ImageFormat.Jpeg);
            });
        }

我还通过绑定到集合并使用转换器将 Base64 字符串转换回位图，将每个字符串显示为图像，这只是为了让 UI 显示已转换的内容。

我的问题从哪里开始？当我在 UI 上显示图像并使用转换器将字符串转换为图像时，我是否会尝试在内存中存储太多图像？

下图中的高点在运行方法循环时很明显，但它似乎仍然比方法运行结束前高，这有帮助吗？

编辑： 这是启动任务并运行方法的循环。

// Generate List of images to upload
                var files = Directory.EnumerateFiles(sel.Name, "*.*", SearchOption.AllDirectories)
                        .Where(s => s.EndsWith(".jpeg") ||
                        s.EndsWith(".jpg") ||
                        s.EndsWith(".png") ||
                        s.EndsWith(".JPG"));
                int b = 1;

                if (files.Count() > 0)
                {
                    /// <summary>
                    /// Resize Images
                    /// </summary>
                    /// Set current Task first
                    UploadTask = Steps[0].Message;
                    try
                    {
                        foreach (string item in files)
                        {
                            // Generate new name
                            string oldname = Path.GetFileNameWithoutExtension(item);
                            string newName = Common.Security.KeyGenerator.GetUniqueKey(32);
                            string t = await GenerateThumbnailBinary(item);

                            ImageUploadObjects.Add(
                                new ImageUploadObject { OldName = oldname,
                                    NewName = newName,
                                    ByteImage = t });

                            UploadProgress = (int)Math.Round((double)(100 * b / files.Count()));
                            b++;
                        }
                        // Complete
                        Steps[0].Complete = true;
                    }
                    catch(Exception e)
                    {
                        Steps[0].Error = e.InnerException.ToString();
                    }


                    /// <summary>
                    /// Move full resoluation images
                    /// </summary>
                    /// Set current Task first
                    UploadTask = Steps[1].Message;
                    try
                    {
                        foreach (string item in files)
                        {

                        }
                        // Complete
                        Steps[1].Complete = true;
                    }
                    catch (Exception e)
                    {
                        Steps[1].Error = e.InnerException.ToString();
                    }
                }
            }

编辑：

如何判断内存是否仍在使用？我在下面添加了另一张图片，第一个快照是在我执行该方法之前，最后一个是它完成时，2 - 4 是它正在运行的时候

Answer 1

我认为解决您的问题的最简单方法是分块/分批进行。例如，如果您有 100 个文件，那么您正在创建 100 个任务，这些任务将文件内容加载到内存中的图像中。也许做 10（或其他数字），一旦完成，再做下一个 10（或其他数字）。我相信这将解决您的问题。

还要确保在任何实现 Disposable 的类（即 Image 和 Bitmap 等）上调用 Dispose。

除上述内容外，以下是您要尝试执行的简要操作： 1.读取一个目录并取出所有文件。 2. 为每个文件创建缩略图。 3. 将缩略图添加到内存中的集合中。 4. 将图像转移到另一个位置。

对于上面的第 2 项，我不会将所有缩略图都保存在内存中。即使我需要在 UI 中显示这一点，我也会根据需要合并分页并拉取它们。

Answer 2

Image resized = ResizeImage(image, newSize) 未被处理。因为在运行终结器线程之前不会释放分配的内存，因此您可能会到处泄漏内存。

Image image = Image.FromFile(loc, true);
...

Image resized = ResizeImage(image, newSize);
image.Dispose();
string base64Image = ImageToBase64(resized, ImageFormat.Jpeg);
resized.Dispose();
return base64Image;