C# 服务器上的缩略图-GDI+；

我们已经收到这个问题很长一段时间了，并尝试了许多不同的修复从网上。到目前为止，一切都不起作用

问题：基本图像保存正常，缩略图保存失败。在下面的解决方案之前，我曾尝试为所有图像（基本图像、600x600和300x300 thumb）创建单独的流，但这也不起作用。所有流都是从相同的字节数组构造的。记住这一点：这在开发环境、测试环境和Test2环境中运行良好，但在生产环境中无法运行。我已经检查了文件夹上的所有设置/环境变量/权限，所有设置都与测试环境相同

路径如下所示：

• 基本路径：“~/images/imageUpl/”
• 缩略图添加。路径：“thumbM/”
• 缩略图添加。路径：“拇指/”
• 图像名称结构：“X_YYYYMMDD_HHMMSS_XX.png”

这些路径都是正确的，因为它在Dev/Test/Test2环境中工作

非常感谢您在这方面的任何帮助

编辑：到目前为止我们尝试的内容：

• 设置网络和IISUser的权限
• 对从原始源数据构建的每个图像使用单独的流
• 根据其他示例添加thread.sleep（30+）
• 从调整大小的位图创建新位图并保存
• 用于测试其目录是否在生产上出现问题的不同路径

编辑2：供参考，这是一个ASP.NET MVC5 Web应用程序，运行.NET Framework 4.7.2

图像处理器类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Drawing.Drawing2D;
using Newtonsoft.Json;
using System.Threading;

namespace CMS_MVC.Classes
{
    public class ImageProcessor : IDisposable
    {
        public enum PathType : int
        {
            Relative = 1,
            Static = 2
        }

        private Stream _ImageStream { get; set; }
        private HttpContext _Context { get; set; }
        public Image BaseImage { get; set; }
        private int _instanceId { get; set; }

        public ImageProcessor(int instanceId, Stream imageStream, HttpContext context)
        {
            this._ImageStream = imageStream;
            this._Context = context;
            this._instanceId = instanceId;

            this.BaseImage = Image.FromStream(this._ImageStream);
        }

        public ImageProcessor(int instanceId, byte[] imageByteArray, HttpContext context)
        {
            this._Context = context;
            this._instanceId = instanceId;

            this._ImageStream = new MemoryStream(imageByteArray);
            this.BaseImage = Image.FromStream(this._ImageStream);
        }

        public ImageProcessor(int instanceId, string imagePath, PathType pathType, HttpContext context)
        {
            this._Context = context;
            this._instanceId = instanceId;

            if (pathType == PathType.Relative)
            {
                this._ImageStream = new MemoryStream(File.ReadAllBytes(this._Context.Server.MapPath(imagePath)));
                this.BaseImage = Image.FromStream(this._ImageStream);
            }
            else
            {
                this._ImageStream = new MemoryStream(File.ReadAllBytes(imagePath));
                this.BaseImage = Image.FromStream(this._ImageStream);
            }
        }

        public Dictionary<string, bool> SaveImages(string baseImageSavePath, string imageName, Dictionary<string, Tuple<int, int>> thumbnails = null)
        {
            Dictionary<string, bool> results = new Dictionary<string, bool>();
            string lastResult = "main";
            results.Add(lastResult, true);

            try
            {
                this.BaseImage.Save(this._Context.Server.MapPath(Path.Combine(baseImageSavePath, imageName)), ImageFormat.Png);

                if (thumbnails != null)
                {
                    foreach (var thumbnail in thumbnails)
                    {
                        lastResult = thumbnail.Value.Item1.ToString() + "_" + thumbnail.Value.Item2.ToString();
                        results.Add(lastResult, true);

                        using (Bitmap thumbBitmap = this.ResizeImage(thumbnail.Value.Item1, thumbnail.Value.Item2))
                        {
                            Thread.Sleep(50);
                            thumbBitmap.Save(this._Context.Server.MapPath(Path.Combine(baseImageSavePath + thumbnail.Key, imageName)), ImageFormat.Png);
                            Thread.Sleep(50);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                results[lastResult] = false;

                // Log event
            }

            return results;
        }

        private Bitmap ResizeImage(int targetWidth, int targetHeight)
        {
            Tuple<int, int> destSize = this.CalculateThumbnailSizeAspectRatio(targetWidth, targetHeight);

            var destRect = new Rectangle(0, 0, destSize.Item1, destSize.Item2);
            var destImage = new Bitmap(destSize.Item1, destSize.Item2);

            destImage.SetResolution(this.BaseImage.HorizontalResolution, this.BaseImage.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(this.BaseImage, destRect, 0, 0, this.BaseImage.Width, this.BaseImage.Height, GraphicsUnit.Pixel, wrapMode);
                }
            }

            return destImage;
        }

        private Tuple<int, int> CalculateThumbnailSizeAspectRatio(int targetWidth, int targetHeight)
        {
            // Resize calculations
        }

        public void Dispose()
        {
            if (this._ImageStream != null) this._ImageStream.Dispose();
            if (this.BaseImage != null) this.BaseImage.Dispose();
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用System.Web；
使用系统图；
使用系统、绘图、成像；
使用System.IO；
使用System.Drawing.Drawing2D；
使用Newtonsoft.Json；
使用系统线程；
命名空间CMS_MVC.Classes
{
公共类图像处理器：IDisposable
{
公共枚举路径类型：int
{
相对=1，
静态=2
}
私有流_ImageStream{get；set；}
私有HttpContext_Context{get；set；}
公共映像BaseImage{get；set；}
私有int_instanceId{get；set；}
公共ImageProcessor（int instanceId、Stream imageStream、HttpContext上下文）
{
这是。_ImageStream=ImageStream；
这._Context=Context；
这个。_instanceId=instanceId；
this.BaseImage=Image.FromStream（this.\u ImageStream）；
}
公共图像处理器（int instanceId，字节[]imageByteArray，HttpContext上下文）
{
这._Context=Context；
这个。_instanceId=instanceId；
此._ImageStream=新内存流（imageByteArray）；
this.BaseImage=Image.FromStream（this.\u ImageStream）；
}
公共ImageProcessor（int instanceId、字符串imagePath、路径类型PathType、HttpContext上下文）
{
这._Context=Context；
这个。_instanceId=instanceId；
if（pathType==pathType.Relative）
{
this._ImageStream=newmemorystream（File.ReadAllBytes（this._Context.Server.MapPath（imagePath））；
this.BaseImage=Image.FromStream（this.\u ImageStream）；
}
其他的
{
这._ImageStream=newmemoryStream（File.ReadAllBytes（imagePath））；
this.BaseImage=Image.FromStream（this.\u ImageStream）；
}
}
公共字典SaveImages（string BaseMageSavePath、string imageName、字典缩略图=null）
{
字典结果=新字典（）；
字符串lastResult=“main”；
results.Add（lastResult，true）；
尝试
{
this.BaseImage.Save（this.u Context.Server.MapPath（Path.Combine（baseImageSavePath，imageName）），ImageFormat.Png）；
如果（缩略图！=null）
{
foreach（缩略图中的变量缩略图）
{
lastResult=thumbnail.Value.Item1.ToString（）+“"”+thumbnail.Value.Item2.ToString（）；
results.Add（lastResult，true）；
使用（位图thumbBitmap=this.ResizeImage（thumbnail.Value.Item1，thumnail.Value.Item2））
{
睡眠（50）；
thumbBitmap.Save（this._Context.Server.MapPath（Path.Combine（baseImageSavePath+thumbnail.Key，imageName）），ImageFormat.Png）；
睡眠（50）；
}
}
}
}
捕获（例外情况除外）
{
结果[最后结果]=假；
//日志事件
}
返回结果；
}
专用位图大小图像（int targetWidth、int targetHeight）
{
Tuple destSize=this.CalculateThumbnailSizeAspectRatio（targetWidth，targetSight）；
var destect=新矩形（0,0，destSize.Item1，destSize.Item2）；
var destImage=新位图（destSize.Item1、destSize.Item2）；
destImage.SetResolution（this.BaseImage.HorizontalResolution，this.BaseImage.VerticalResolution）；
使用（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；
使用（var wrapMode=newImageAttributes（））
{
wrapMode.SetWrapMode（wrapMode.TileFlipXY）；
graphics.DrawImage（this.BaseImage，desect，0,0,t