首页 / NETCORE / .NetCore 图片压缩

.NetCore 图片压缩

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了.NetCore 图片压缩，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10188字，纯文字阅读大概需要15分钟。

内容图文

using System;
using System.Drawing;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace 图片压缩
{
    public class Program
    {
        static void Main(string[] args)
        {
            DirectoryInfo root = new DirectoryInfo(@"D:\桌面\测试");

            foreach (FileInfo f in root.GetFiles())
            {
                GetImage(f.FullName,f.Name);
                Console.WriteLine(f.Name);
            }
            Console.WriteLine("Hello World!");
        }

        public static void GetImage(string path,string name)
        {

            var imageStr = ImageToBase64(path);

            var newImageStr = GetImg(imageStr, 1);
            using (var stream = new FileStream($@"D:\桌面\测试新\tu{name}", FileMode.Create))
            {
                var match = Regex.Match(newImageStr, "data:image/png;base64,([\\w\\W]*)$");
                if (match.Success)
                {
                    newImageStr = match.Groups[1].Value;
                }
                var imgByte = Convert.FromBase64String(newImageStr);
                stream.Write(imgByte, 0, imgByte.Length);
                stream.Flush();
            }
        }

        /// <summary>
        /// Image 转成 base64
        /// </summary>
        /// <param name="filePath"></param>
        public static string ImageToBase64(string filePath)
        {
            Bitmap bmp = new Bitmap(filePath);
            MemoryStream ms = new MemoryStream();
            bmp.Save(ms, bmp.RawFormat);
            byte[] arr = new byte[ms.Length];
            ms.Position = 0;
            ms.Read(arr, 0, (int)ms.Length);
            ms.Close();
            return Convert.ToBase64String(arr);
        }

        /// <summary>
        /// 图片压缩
        /// </summary>
        /// <param name="imgstr">图片base64</param>
        /// <param name="type">图片类型，默认宽高</param>
        /// <param name="length">图片最大限制</param>
        /// <returns></returns>
        public static string GetImg(string imgstr,int type, int length = 1024 * 1536)
        {
            //1.5MB以内的图片，不做压缩处理
            if (imgstr.Length < length)
                return imgstr;
            int width = 800, height = 560;
            if (type == 1)
            {
                width = 1230;
                height = 870;
            }
            byte[] imgBytes = Convert.FromBase64String(imgstr);
            var stream = new MemoryStream(imgBytes);

            var image = Image.FromStream(stream);
            double newWidth, newHeight;
            if (image.Width > image.Height)
            {
                newWidth = width;
                newHeight = image.Height * (newWidth / image.Width);
            }
            else
            {
                newHeight = height;
                newWidth = (newHeight / image.Height) * image.Width;
            }
            if (newWidth > width)
            {
                newWidth = width;
            }
            if (newHeight > height)
            {
                newHeight = height;
                newWidth = image.Width * (newHeight / image.Height);
            }
            var outStream = new MemoryStream();
            ImgThumbnail.Thumbnail(stream, outStream,Convert.ToInt32(newWidth),Convert.ToInt32(newHeight), 100, ImgThumbnail.ImgThumbnailType.WH);
            var newImageStr = Convert.ToBase64String(outStream.ToArray());
            while (newImageStr.Length>= length)
            {
                newImageStr= GetImg(newImageStr, type,length);
            }
            return newImageStr;
        }
    }
}

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Net.Mime;
using System.Text;

namespace 图片压缩
{
    public class ImgThumbnail
    {
        #region 枚举
        /// <summary>
        /// 指定缩放类型
        /// </summary>
        public enum ImgThumbnailType
        {
            /// <summary>
            /// 无
            /// </summary>
            Nothing = 0,


            /// <summary>
            /// 指定高宽缩放（可能变形）
            /// </summary>
            WH = 1,


            /// <summary>
            /// 指定宽，高按比例
            /// </summary>
            W = 2,


            /// <summary>
            /// 指定高，宽按比例
            /// </summary>
            H = 3,


            /// <summary>
            /// 指定高宽裁减（不变形）
            /// </summary>
            Cut = 4,


            /// <summary>
            /// 按照宽度成比例缩放后，按照指定的高度进行裁剪
            /// </summary>
            W_HCut = 5,

            /// <summary>
            /// 长边优先
            /// </summary>
            W_L = 5,

            /// <summary>
            /// 短边优先
            /// </summary>
            W_S = 5,
        }

        public enum ImgResize
        {
            /// <summary>
            /// 无
            /// </summary>
            Nothing = 0,

            /// <summary>
            /// 按长边优先
            /// </summary>
            M_lfit = 1,

            /// <summary>
            /// 按短边优先
            /// </summary>
            M_mfit = 2,
        }
        #endregion


        #region 图片压缩
        /// <summary>
        /// 无损压缩图片
        /// </summary>
        /// <param name="sourceFile">原图片</param>
        /// <param name="height">高度</param>
        /// <param name="width"></param>
        /// <param name="quality">压缩质量 1-100</param>
        /// <param name="type">压缩缩放类型</param>
        /// <param name="tFormat"></param>
        /// <returns></returns>
        private static Bitmap Thumbnail(Stream sourceStream, int width, int height, int quality
          , ImgThumbnailType type, out ImageFormat tFormat)
        {
            using (Image iSource = Image.FromStream(sourceStream))
            {
                tFormat = iSource.RawFormat;
                //缩放后的宽度和高度
                int toWidth = width;
                int toHeight = height;
                //
                int x = 0;
                int y = 0;
                int oWidth = iSource.Width;
                int oHeight = iSource.Height;

                if (type == ImgThumbnailType.W_L) type = oWidth > oHeight ? ImgThumbnailType.W : ImgThumbnailType.H;
                if (type == ImgThumbnailType.W_S) type = oWidth > oHeight ? ImgThumbnailType.H : ImgThumbnailType.W;


                switch (type)
                {
                    case ImgThumbnailType.WH://指定高宽缩放（可能变形）           
                        {
                            break;
                        }
                    case ImgThumbnailType.W://指定宽，高按比例     
                        {
                            toHeight = iSource.Height * width / iSource.Width;
                            break;
                        }
                    case ImgThumbnailType.H://指定高，宽按比例
                        {
                            toWidth = iSource.Width * height / iSource.Height;
                            break;
                        }
                    case ImgThumbnailType.Cut://指定高宽裁减（不变形）     
                        {
                            if (iSource.Width / (double)iSource.Height > toWidth / (double)toHeight)
                            {
                                oHeight = iSource.Height;
                                oWidth = iSource.Height * toWidth / toHeight;
                                y = 0;
                                x = (iSource.Width - oWidth) / 2;
                            }
                            else
                            {
                                oWidth = iSource.Width;
                                oHeight = iSource.Width * height / toWidth;
                                x = 0;
                                y = (iSource.Height - oHeight) / 2;
                            }
                            break;
                        }
                    case ImgThumbnailType.W_HCut://按照宽度成比例缩放后，按照指定的高度进行裁剪
                        {
                            toHeight = iSource.Height * width / iSource.Width;
                            if (height < toHeight)
                            {
                                oHeight = oHeight * height / toHeight;
                                toHeight = toHeight * height / toHeight;
                            }
                            break;
                        }
                    default:
                        break;
                }

                Bitmap ob = new Bitmap(toWidth, toHeight);
                //ImgWaterMark iwm = new ImgWaterMark();
                //iwm.AddWaterMark(ob, towidth, toheight, "www.***.com");
                Graphics g = Graphics.FromImage(ob);
                g.Clear(Color.WhiteSmoke);
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                g.DrawImage(iSource
                  , new Rectangle(x, y, toWidth, toHeight)
                  , new Rectangle(0, 0, oWidth, oHeight)
                  , GraphicsUnit.Pixel);
                g.Dispose();

                return ob;

            }
        }


        /// <summary>
        /// 无损压缩图片
        /// </summary>
        /// <param name="sourceStream">原图片文件流</param>
        /// <param name="outStream">压缩后保存到流中</param>
        /// <param name="height">高度</param>
        /// <param name="width"></param>
        /// <param name="quality">压缩质量 1-100</param>
        /// <param name="type">压缩缩放类型</param>
        /// <returns></returns>
        public static bool Thumbnail(Stream sourceStream, Stream outStream, int width, int height, int quality, ImgThumbnailType type)
        {
            ImageFormat tFormat;
            Bitmap ob = Thumbnail(sourceStream, width, height, quality, type, out tFormat);
            //水印
            //ImgWaterMark.AddWaterMark(ob, "www.***.com");
            //以下代码为保存图片时，设置压缩质量
            EncoderParameters ep = new EncoderParameters();
            long[] qy = new long[1] { quality };//设置压缩的比例1-100
            EncoderParameter eParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, qy);
            ep.Param[0] = eParam;
            try
            {
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICIinfo = null;
                for (int i = 0; i < arrayICI.Length; i++)
                {
                    if (arrayICI[i].FormatDescription.Equals("JPEG"))
                    {
                        jpegICIinfo = arrayICI[i];
                        break;
                    }
                }
                if (jpegICIinfo != null)
                {
                    ob.Save(outStream, jpegICIinfo, ep);//jpegICIinfo是压缩后的新路径
                }
                else
                {
                    ob.Save(outStream, tFormat);
                }
                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                //iSource.Dispose();

                ob.Dispose();

            }
        }

        /// <summary>
        /// 无损压缩图片
        /// </summary>
        /// <param name="sourceFile">原图片</param>
        /// <param name="targetFile">压缩后保存位置</param>
        /// <param name="height">高度</param>
        /// <param name="width"></param>
        /// <param name="quality">压缩质量 1-100</param>
        /// <param name="type">压缩缩放类型</param>
        /// <returns></returns>
        public static bool Thumbnail(string sourceFile, string targetFile, int width, int height, int quality, ImgThumbnailType type)
        {
            ImageFormat tFormat = null;
            var fileBytes = File.ReadAllBytes(sourceFile);
            var sourceStream = new MemoryStream(fileBytes);
            Bitmap ob = Thumbnail(sourceStream, width, height, quality, type, out tFormat);
            //以下代码为保存图片时，设置压缩质量
            EncoderParameters ep = new EncoderParameters();
            long[] qy = new long[1] { quality };//设置压缩的比例1-100
            EncoderParameter eParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, qy);
            ep.Param[0] = eParam;
            try
            {
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICIinfo = null;
                for (int i = 0; i < arrayICI.Length; i++)
                {
                    if (arrayICI[i].FormatDescription.Equals("JPEG"))
                    {
                        jpegICIinfo = arrayICI[i];
                        break;
                    }
                }
                if (jpegICIinfo != null)
                {
                    ob.Save(targetFile, jpegICIinfo, ep);//jpegICIinfo是压缩后的新路径
                }
                else
                {
                    ob.Save(targetFile, tFormat);
                }
                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                //iSource.Dispose();

                ob.Dispose();

            }
        }
        #endregion


        #region 生成缩略图

        /// <summary>
        /// 生成缩略图
        /// </summary>
        /// <param name="sourceFile">原始图片文件</param>
        /// <param name="quality">质量压缩比</param>
        /// <param name="w"></param>
        /// <param name="h"></param>
        /// <param name="outputFile">输出文件名</param>
        /// <returns>成功返回true,失败则返回false</returns>
        public static bool GetThumImage(string sourceFile, long quality, int w, int h, string outputFile)
        {
            try
            {
                long imageQuality = quality;
                Bitmap sourceImage = new Bitmap(sourceFile);
                ImageCodecInfo myImageCodecInfo = GetEncoder(ImageFormat.Jpeg);
                System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, imageQuality);
                myEncoderParameters.Param[0] = myEncoderParameter;
                sourceImage.Save(outputFile, myImageCodecInfo, myEncoderParameters);


                float xWidth = sourceImage.Width;
                float yWidth = sourceImage.Height;
                Bitmap newImage = new Bitmap(w, h);
                Graphics g = Graphics.FromImage(newImage);

                g.DrawImage(sourceImage, 0, 0, w, h);
                g.Dispose();
                newImage.Save(outputFile, myImageCodecInfo, myEncoderParameters);
                return true;
            }
            catch
            {
                return false;
            }
        }

        private static ImageCodecInfo GetEncoder(ImageFormat format)
        {

            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();

            foreach (ImageCodecInfo codec in codecs)
            {
                if (codec.FormatID == format.Guid)
                {
                    return codec;
                }
            }
            return null;
        }
        #endregion


        public static ImgThumbnailType GetThumbnailType(string w, string h, string t, string sourceFile)
        {
            //参数只有一个
            if (w == "0" || h == "0")
            {
                return w == "0" ? ImgThumbnailType.H : ImgThumbnailType.W;
            }
            else
            {
                return t == "0" ? ImgThumbnailType.W_L : ImgThumbnailType.W_S;
            }
        }

        /// <summary>
        /// 比较原图的高宽大小
        /// </summary>
        /// <param name="w">宽度</param>
        /// <param name="h">高度</param>
        /// <param name="t"></param>
        /// <returns></returns>
        public static int GetImgResize(int w, int h, int t)
        {
            if (w > h) return t == 0 ? w : h;
            return t == 0 ? h : w;
        }
    }
}

内容总结

以上是互联网集市为您收集整理的.NetCore 图片压缩全部内容，希望文章能够帮你解决.NetCore 图片压缩所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1004459.html

来源：【匿名】

【上一篇】.net 工具集，支持.net fx和.net core 【下一篇】.NET Core 中的并发编程

更多 ►

【.NetCore 图片压缩】教程文章相关的互联网学习教程文章

ASP.NET Core MVC压缩样式、脚本及总是复制文件到输出目录【代码】【图】

前言在.NET Core之前对于压缩样式文件和脚本我们可能需要借助第三方工具来进行压缩，但在ASP.NET MVC Core中则无需借助第三方工具来完成，本节我们来看看ASP.NET Core MVC为我们提供了哪些方便。自动压缩样式和脚本当我们在测试环境中肯定不需要压缩脚本的，如果一旦压缩脚本的话，若在控制台出现错误不利于我们调试，但是在生产环境中我们通过压缩脚本或者样式一来可以减少传输流量，二来可以加速页面加载时间，换句话说，此时我们...

详解ASP.NET Core 中间件之压缩、缓存【图】

前言今天给大家介绍一下在 ASP.NET Core 日常开发中用的比较多的两个中间件，它们都是出自于微软的 ASP.NET 团队，他们分别是Microsoft.AspNetCore.ResponseCompression 和 Microsoft.AspNetCore.ResponseCaching ，下面让我们一起看看的功能以及如何去使用吧。 Getting Started Microsoft.AspNetCore.ResponseCompression Microsoft.AspNetCore.ResponseCompression 这个中间件是 .NET Core 1.1 版本中新增加的，看名字应该知道...

ASP.NET Core中预压缩静态文件的方法步骤

前言 Web应用程序的优化是非常重要，因为使用更少的CPU,占用更少的带宽可以减少项目的费用。在ASP.NET Core中我们可以很容易的启用响应压缩，但是针对预压缩文件，就需要做一些额外的功能了。这篇博客文章展示了如何在ASP.NET Core中预压缩静态文件。下面话不多说了，来一起看看详细的介绍吧为什么需要预压缩文件？虽然在从服务器请求文件时，我们可以动态压缩文件，但这意味这Web服务器需要做更多的额外工作。其实只有在新的...

ASP.NET Core MVC压缩样式、脚本详解【图】

asp.net core合并压缩资源文件引发的学习之旅【图】

原文:asp.net core合并压缩资源文件引发的学习之旅 0. 在asp.net core中使用BuildBundlerMinifier合并压缩资源文件在asp.net mvc中可以使用Bundle来压缩合并css,js 不知道的见：http://www.cnblogs.com/morang/p/7207176.html 在asp.net core中则可以使用BuildBundlerMinifier来进行css，js的压缩合并新建一个core项目可以看到一个根目录下面有一个bundleconfig.json配置文件，看名字大概也猜到了几分，点开json文件中的链接，果然...

ASP.NET Core 资源打包与压缩

原文:ASP.NET Core 资源打包与压缩 ASP.NET Core 资源打包与压缩在ASP.NET 中可以使用打包与压缩来提高Web应用程序页面加载的性能。打包是将多个文件（CSS，JS等资源文件)合并或打包到单个文件。文件合并可减少Web资源文件从服务器的所需请求数，这样可提高页面载入的性能。压缩是将各种不同的代码进行优化，以减少请求资源文件的体积。压缩的常见方法删除不必要的空格和注释，并将变量名缩减为一个字符。 bundleconfig.json文件[...

asp.net core2.1 bundleconfig.json合并压缩资源文件【代码】

原文:asp.net core2.1 bundleconfig.json合并压缩资源文件在asp.net core中则可以使用BuildBundlerMinifier来进行css，js的压缩合并 1、使用NuGet安装 BuildBundlerMinifier（也可以在vs中下载安装扩展Bundler & Minifier，手动压缩文件） 2、新建：bundleconfig.json 绑定和缩减[{// 要输出的捆绑文件名称。可以包含中的相对路径bundleconfig.json文件。必填"outputFileName": "wwwroot/css/site.min.css",// 要将捆绑在一起的...

[小技巧]ASP.NET Core中如何预压缩静态文件

原文:[小技巧]ASP.NET Core中如何预压缩静态文件原文地址：Pre-compressed static files with ASP.NET Core 作者：Gunnar Peipman 译者：Lamond Lu 译文：https://www.cnblogs.com/lwqlun/p/10552131.html 示例代码：https://github.com/lamondlu/CompressedStaticFileSampleWeb应用程序的优化是非常重要，因为使用更少的CPU,占用更少的带宽可以减少项目的费用。在ASP.NET Core中我们可以很容易的启用响应压缩，但是针对预压缩文件...

asp.net core2.1 bundleconfig.json合并压缩资源文件【代码】

在asp.net core中则可以使用BuildBundlerMinifier来进行css，js的压缩合并 1、使用NuGet安装 BuildBundlerMinifier（也可以在vs中下载安装扩展Bundler & Minifier，手动压缩文件） 2、新建：bundleconfig.json 绑定和缩减[{// 要输出的捆绑文件名称。可以包含中的相对路径bundleconfig.json文件。必填"outputFileName": "wwwroot/css/site.min.css",// 要将捆绑在一起的文件的数组。这些是配置文件的相对路径。可选，* 空值会在...