压缩base64格式图片（前端jq、后端.net）的两种方法

前端方法

参考来源：https://blog.csdn.net/WANG_CODER/article/details/78214409

base64版本

 function dealImage(base64Str, obj, callback) {
            var img = new Image();
            img.src = "data:image/jpeg;base64," + base64Str;
            img.onload = function () {
                var that = this;
                // 默认按比例压缩
                var w = that.width,
                    h = that.height,
                    scale = w / h;
                w = obj.width || w;
                h = obj.height || (w / scale);
                var quality = 0.7;  // 默认图片质量为0.7
                //生成canvas
                var canvas = document.createElement('canvas');
                var ctx = canvas.getContext('2d');
                // 创建属性节点
                var anw = document.createAttribute("width");
                anw.nodeValue = w;
                var anh = document.createAttribute("height");
                anh.nodeValue = h;
                canvas.setAttributeNode(anw);
                canvas.setAttributeNode(anh);
                ctx.drawImage(that, 0, 0, w, h);
                // 图像质量
                if (obj.quality && obj.quality <= 1 && obj.quality > 0) {
                    quality = obj.quality;
                }
                // quality值越小，所绘制出的图像越模糊
                var base64 = canvas.toDataURL('image/jpeg', quality);
                // 回调函数返回base64的值
                callback(base64, w, h);
            }
        }

后端方法 

来源：不明（知道的可以告诉我下..）

增加base64格式与bitmap的转换方法，将base64图片转为bitmap格式，使用Bitmap格式的压缩方法后再转回base64格式。

        
        /// <summary>
        /// Base64String转Bitmap
        /// </summary>
        /// <param name="base64Data"></param>
        /// <returns></returns>
        public static Bitmap Base64StringToBitmap(string base64String)
        {
            MemoryStream stream = new MemoryStream();
            try
            {
                byte[] arr = Convert.FromBase64String(base64String);
                stream = new MemoryStream(arr);
                return new Bitmap(stream); ;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                stream.Close();
            }
        }

        /// <summary>
        /// Bitmap转Base64String
        /// </summary>
        /// <param name="bmp"></param>
        /// <returns></returns>
        public static string BitmapToBase64String(Bitmap bmp)
        {
            MemoryStream stream = null;
            try
            {
                stream = new MemoryStream();
                bmp.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
                byte[] arr = new byte[stream.Length];
                stream.Position = 0;
                stream.Read(arr, 0, (int)stream.Length);
                return Convert.ToBase64String(arr);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                stream.Close();
            }
        }

        /// <summary>
        /// 获取图片编码信息
        /// </summary>
        private static ImageCodecInfo GetEncoderInfo(ImageFormat format)
        {
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (int j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].FormatID == format.Guid)
                {
                    return encoders[j];
                }
            }
            return null;
        }

        /// <summary>
        /// 压缩图片
        /// </summary>
        /// <param name="base64Data">原始图片</param>
        /// <param name="quality">质量压缩比</param>
        /// <param name="multiple">收缩倍数</param>
        /// <param name="outputBase64Data">输出图片</param>
        /// <returns></returns>
        public static bool CompressedImage(string base64Data, long quality, int multiple, out string outputBase64Data)
        {
            outputBase64Data = base64Data;
            try
            {
                // 获取图片信息
                using (Bitmap bitmap = Base64StringToBitmap(base64Data))
                {
                    ImageCodecInfo myImageCodecInfo = GetEncoderInfo(bitmap.RawFormat);
                    if (null == myImageCodecInfo)
                    {
                        return false;
                    }

                    // 压缩质量
                    System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                    EncoderParameters myEncoderParameters = new EncoderParameters(1);
                    EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, quality);
                    myEncoderParameters.Param[0] = myEncoderParameter;

                    // 按比例压缩
                    float _xWidth = bitmap.Width;
                    float _yWidth = bitmap.Height;
                    Bitmap newImage = new Bitmap((int)(_xWidth / multiple), (int)(_yWidth / multiple));
                    Graphics g = Graphics.FromImage(newImage);
                    /// 可按需配置属性
                    //g.CompositingQuality = CompositingQuality.HighQuality;
                    //g.CompositingMode = CompositingMode.SourceCopy;
                    //g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    g.DrawImage(bitmap, 0, 0, (_xWidth / multiple), (_yWidth / multiple));
                    g.Dispose();

                    // 保存图片
                    outputBase64Data = BitmapToBase64String(newImage);
                    return true;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

 如此可以按照需要在前后端压缩图片。