ASP.NET 图片上传工具类 upload image简单好用功能齐全-阿里云开发者社区

开发者社区> 杰克.陈> 正文

ASP.NET 图片上传工具类 upload image简单好用功能齐全

简介: 原文:ASP.NET 图片上传工具类 upload image简单好用功能齐全 使用方法: UploadImage ui = new UploadImage(); /***可选参数***/ ui.
+关注继续查看
原文:ASP.NET 图片上传工具类 upload image简单好用功能齐全

使用方法:

  UploadImage ui = new UploadImage();

            /***可选参数***/

            ui.SetWordWater = "哈哈";//文字水印
            // ui.SetPicWater = Server.MapPath("2.png");//图片水印(图片和文字都赋值图片有效)
            ui.SetPositionWater = 4;//水印图片的位置 0居中、1左上角、2右上角、3左下角、4右下角

            ui.SetSmallImgHeight = "110,40,20";//设置缩略图可以多个
            ui.SetSmallImgWidth = "100,40,20";

            //保存图片生成缩略图
            var reponseMessage = ui.FileSaveAs(Request.Files[0], Server.MapPath("~/file/temp"));

            //裁剪图片
            var reponseMessage2 = ui.FileCutSaveAs(Request.Files[0], Server.MapPath("~/file/temp2"), 400, 300, UploadImage.CutMode.CutNo);




            /***返回信息***/
            var isError = reponseMessage.IsError;//是否异常
            var webPath = reponseMessage.WebPath;//web路径
            var filePath = reponseMessage.filePath;//物理路径
            var message = reponseMessage.Message;//错误信息
            var directory = reponseMessage.Directory;//目录
            var smallPath1 = reponseMessage.SmallPath(0);//缩略图路径1
            var smallPath2 = reponseMessage.SmallPath(1);//缩略图路径2
            var smallPath3 = reponseMessage.SmallPath(2);//缩略图路径3

  

 

 效果:

 

源码:

 

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Web;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.Collections;
using System.Net;
using System.Text.RegularExpressions;
using System.Configuration;

namespace SyntacticSugar
{
    /// <summary>
    /// ** 描述:图片上传类、支持水印、缩略图
    /// ** 创始时间:2015-5-28
    /// ** 修改时间:-
    /// ** 修改人:sunkaixuan
    /// ** 使用说明:http://www.cnblogs.com/sunkaixuan/p/4536626.html
    /// </summary>
    public class UploadImage
    {

        #region 属性
        /// <summary>
        /// 允许图片格式
        /// </summary>
        public string SetAllowFormat { get; set; }
        /// <summary>
        /// 允许上传图片大小
        /// </summary>
        public double SetAllowSize { get; set; }
        /// <summary>
        /// 文字水印字符
        /// </summary>
        public string SetWordWater { get; set; }
        /// <summary>
        /// 图片水印
        /// </summary>
        public string SetPicWater { get; set; }
        /// <summary>
        /// 水印图片的位置 0居中、1左上角、2右上角、3左下角、4右下角
        /// </summary>
        public int SetPositionWater { get; set; }
        /// <summary>
        /// 缩略图宽度多个逗号格开(例如:200,100)
        /// </summary>
        public string SetSmallImgWidth { get; set; }
        /// <summary>
        /// 缩略图高度多个逗号格开(例如:200,100)
        /// </summary>
        public string SetSmallImgHeight { get; set; }
        /// <summary>
        /// 是否限制最大宽度,默认为true
        /// </summary>
        public bool SetLimitWidth { get; set; }
        /// <summary>
        /// 最大宽度尺寸,默认为600
        /// </summary>
        public int SetMaxWidth { get; set; }
        /// <summary>
        /// 是否剪裁图片,默认true
        /// </summary>
        public bool SetCutImage { get; set; }
        /// <summary>
        /// 限制图片最小宽度,0表示不限制
        /// </summary>
        public int SetMinWidth { get; set; }

        #endregion

        public UploadImage()
        {
            SetAllowFormat = ".jpeg|.jpg|.bmp|.gif|.png";   //允许图片格式
            SetAllowSize = 1;       //允许上传图片大小,默认为1MB
            SetPositionWater = 4;
            SetCutImage = true;
        }



        #region main method


        /// <summary>
        /// 裁剪图片
        /// </summary>
        /// <param name="PostedFile">HttpPostedFile控件</param>
        /// <param name="SavePath">保存路径【sys.config配置路径】</param>
        /// <param name="oImgWidth">图片宽度</param>
        /// <param name="oImgHeight">图片高度</param>
        /// <param name="cMode">剪切类型</param>
        /// <param name="ext">返回格式</param>
        /// <returns>返回上传信息</returns>
        public ResponseMessage FileCutSaveAs(System.Web.HttpPostedFile PostedFile, string SavePath, int oImgWidth, int oImgHeight, CutMode cMode)
        {
            ResponseMessage rm = new ResponseMessage();
            try
            {
                //获取上传文件的扩展名
                string sEx = System.IO.Path.GetExtension(PostedFile.FileName);
                if (!CheckValidExt(SetAllowFormat, sEx))
                {
                    TryError(rm, 2);
                    return rm;
                }

                //获取上传文件的大小
                double PostFileSize = PostedFile.ContentLength / 1024.0 / 1024.0;

                if (PostFileSize > SetAllowSize)
                {
                    TryError(rm, 3);
                    return rm;  //超过文件上传大小
                }
                if (!System.IO.Directory.Exists(SavePath))
                {
                    System.IO.Directory.CreateDirectory(SavePath);
                }
                //重命名名称
                string NewfileName = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString("000");
                string fName = "s" + NewfileName + sEx;
                string fullPath = Path.Combine(SavePath, fName);
                PostedFile.SaveAs(fullPath);

                //重命名名称
                string sNewfileName = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString("000");
                string sFName = sNewfileName + sEx;
                rm.IsError = false;
                rm.FileName = sFName;
                string sFullPath = Path.Combine(SavePath, sFName);
                rm.filePath = sFullPath;
                rm.WebPath = "/"+sFullPath.Replace(HttpContext.Current.Server.MapPath("~/"), "").Replace("\\", "/");
                CreateSmallPhoto(fullPath, oImgWidth, oImgHeight, sFullPath, SetPicWater, SetWordWater, cMode);
                if (File.Exists(fullPath))
                {
                    File.Delete(fullPath);
                }
                //压缩
                if (PostFileSize > 100)
                {
                    CompressPhoto(sFullPath, 100);
                }
            }
            catch (Exception ex)
            {
                TryError(rm, ex.Message);
            }
            return rm;
        }



        /// <summary>
        /// 通用图片上传类
        /// </summary>
        /// <param name="PostedFile">HttpPostedFile控件</param>
        /// <param name="SavePath">保存路径【sys.config配置路径】</param>
        /// <param name="finame">返回文件名</param>
        /// <param name="fisize">返回文件大小</param>
        /// <returns>返回上传信息</returns>
        public ResponseMessage FileSaveAs(System.Web.HttpPostedFile PostedFile, string SavePath)
        {
            ResponseMessage rm = new ResponseMessage();
            try
            {
                if (string.IsNullOrEmpty(PostedFile.FileName))
                {
                    TryError(rm, 4);
                    return rm;
                }

                Random rd = new Random();
                int rdInt = rd.Next(1000, 9999);
                //重命名名称
                string NewfileName = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString() + rdInt;

                //获取上传文件的扩展名
                string sEx = System.IO.Path.GetExtension(PostedFile.FileName);
                if (!CheckValidExt(SetAllowFormat, sEx))
                {
                    TryError(rm, 2);
                    return rm;
                }

                //获取上传文件的大小
                double PostFileSize = PostedFile.ContentLength / 1024.0 / 1024.0;

                if (PostFileSize > SetAllowSize)
                {
                    TryError(rm, 3);
                    return rm;
                }


                if (!System.IO.Directory.Exists(SavePath))
                {
                    System.IO.Directory.CreateDirectory(SavePath);
                }

                rm.FileName = NewfileName + sEx;
                string fullPath = SavePath.Trim('\\') + "\\" + rm.FileName;
                rm.WebPath = "/"+fullPath.Replace(HttpContext.Current.Server.MapPath("~/"), "").Replace("\\", "/");
                rm.filePath = fullPath;
                rm.Size = PostFileSize;
                PostedFile.SaveAs(fullPath);


                System.Drawing.Bitmap bmp = new Bitmap(fullPath);
                int realWidth = bmp.Width;
                int realHeight = bmp.Height;
                bmp.Dispose();

                #region 检测图片宽度限制
                if (SetMinWidth > 0)
                {
                    if (realWidth < SetMinWidth)
                    {
                        TryError(rm, 7);
                        return rm;
                    }
                }
                #endregion

                #region 监测图片宽度是否超过600,超过的话,自动压缩到600
                if (SetLimitWidth && realWidth > SetMaxWidth)
                {
                    int mWidth = SetMaxWidth;
                    int mHeight = mWidth * realHeight / realWidth;

                    string tempFile = SavePath + Guid.NewGuid().ToString() + sEx;
                    File.Move(fullPath, tempFile);
                    CreateSmallPhoto(tempFile, mWidth, mHeight, fullPath, "", "");
                    File.Delete(tempFile);
                }
                #endregion

                #region 压缩图片存储尺寸
                if (sEx.ToLower() != ".gif")
                {
                    CompressPhoto(fullPath, 100);
                }
                #endregion



                //生成缩略图片高宽
                if (string.IsNullOrEmpty(SetSmallImgWidth))
                {
                    rm.Message = "上传成功,无缩略图";
                    return rm;
                }


                string[] oWidthArray = SetSmallImgWidth.Split(',');
                string[] oHeightArray = SetSmallImgHeight.Split(',');
                if (oWidthArray.Length != oHeightArray.Length)
                {
                    TryError(rm, 6);
                    return rm;
                }


                for (int i = 0; i < oWidthArray.Length; i++)
                {
                    if (Convert.ToInt32(oWidthArray[i]) <= 0 || Convert.ToInt32(oHeightArray[i]) <= 0)
                        continue;

                    string sImg = SavePath.TrimEnd('\\') + '\\' + NewfileName + "_" + i.ToString() + sEx;

                    //判断图片高宽是否大于生成高宽。否则用原图
                    if (realWidth > Convert.ToInt32(oWidthArray[i]))
                    {
                        if (SetCutImage)
                            CreateSmallPhoto(fullPath, Convert.ToInt32(oWidthArray[i]), Convert.ToInt32(oHeightArray[i]), sImg, "", "");
                        else
                            CreateSmallPhoto(fullPath, Convert.ToInt32(oWidthArray[i]), Convert.ToInt32(oHeightArray[i]), sImg, "", "", CutMode.CutNo);
                    }
                    else
                    {
                        if (SetCutImage)
                            CreateSmallPhoto(fullPath, realWidth, realHeight, sImg, "", "");
                        else
                            CreateSmallPhoto(fullPath, realWidth, realHeight, sImg, "", "", CutMode.CutNo);
                    }
                }

                #region 给大图添加水印
                if (!string.IsNullOrEmpty(SetPicWater))
                    AttachPng(SetPicWater, fullPath);
                else if (!string.IsNullOrEmpty(SetWordWater))
                    AttachText(SetWordWater, fullPath);
                #endregion


            }
            catch (Exception ex)
            {
                TryError(rm, ex.Message);
            }
            return rm;
        }

        #region 验证格式
        /// <summary>
        /// 验证格式
        /// </summary>
        /// <param name="allType">所有格式</param>
        /// <param name="chkType">被检查的格式</param>
        /// <returns>bool</returns>
        public bool CheckValidExt(string allType, string chkType)
        {
            bool flag = false;
            string[] sArray = allType.Split('|');
            foreach (string temp in sArray)
            {
                if (temp.ToLower() == chkType.ToLower())
                {
                    flag = true;
                    break;
                }
            }

            return flag;
        }
        #endregion

        #region 根据需要的图片尺寸,按比例剪裁原始图片
        /// <summary>
        /// 根据需要的图片尺寸,按比例剪裁原始图片
        /// </summary>
        /// <param name="nWidth">缩略图宽度</param>
        /// <param name="nHeight">缩略图高度</param>
        /// <param name="img">原始图片</param>
        /// <returns>剪裁区域尺寸</returns>
        public Size CutRegion(int nWidth, int nHeight, Image img)
        {
            double width = 0.0;
            double height = 0.0;

            double nw = (double)nWidth;
            double nh = (double)nHeight;

            double pw = (double)img.Width;
            double ph = (double)img.Height;

            if (nw / nh > pw / ph)
            {
                width = pw;
                height = pw * nh / nw;
            }
            else if (nw / nh < pw / ph)
            {
                width = ph * nw / nh;
                height = ph;
            }
            else
            {
                width = pw;
                height = ph;
            }

            return new Size(Convert.ToInt32(width), Convert.ToInt32(height));
        }
        #endregion

        #region 等比例缩小图片
        public Size NewSize(int nWidth, int nHeight, Image img)
        {
            double w = 0.0;
            double h = 0.0;
            double sw = Convert.ToDouble(img.Width);
            double sh = Convert.ToDouble(img.Height);
            double mw = Convert.ToDouble(nWidth);
            double mh = Convert.ToDouble(nHeight);

            if (sw < mw && sh < mh)
            {
                w = sw;
                h = sh;
            }
            else if ((sw / sh) > (mw / mh))
            {
                w = nWidth;
                h = (w * sh) / sw;
            }
            else
            {
                h = nHeight;
                w = (h * sw) / sh;
            }

            return new Size(Convert.ToInt32(w), Convert.ToInt32(h));
        }
        #endregion

        #region 生成缩略图

        #region 生成缩略图,不加水印
        /// <summary>
        /// 生成缩略图,不加水印
        /// </summary>
        /// <param name="filename">源文件</param>
        /// <param name="nWidth">缩略图宽度</param>
        /// <param name="nHeight">缩略图高度</param>
        /// <param name="destfile">缩略图保存位置</param>
        public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile)
        {
            Image img = Image.FromFile(filename);
            ImageFormat thisFormat = img.RawFormat;

            Size CutSize = CutRegion(nWidth, nHeight, img);
            Bitmap outBmp = new Bitmap(nWidth, nHeight);
            Graphics g = Graphics.FromImage(outBmp);

            // 设置画布的描绘质量
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;

            int nStartX = (img.Width - CutSize.Width) / 2;
            int nStartY = (img.Height - CutSize.Height) / 2;

            g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                nStartX, nStartY, CutSize.Width, CutSize.Height, GraphicsUnit.Pixel);
            g.Dispose();

            //if (thisFormat.Equals(ImageFormat.Gif))
            //{
            //    Response.ContentType = "image/gif";
            //}
            //else
            //{
            //    Response.ContentType = "image/jpeg";
            //}

            // 以下代码为保存图片时,设置压缩质量
            EncoderParameters encoderParams = new EncoderParameters();
            long[] quality = new long[1];
            quality[0] = 100;

            EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
            encoderParams.Param[0] = encoderParam;

            //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
            ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo jpegICI = null;
            for (int x = 0; x < arrayICI.Length; x++)
            {
                if (arrayICI[x].FormatDescription.Equals("JPEG"))
                {
                    jpegICI = arrayICI[x];//设置JPEG编码
                    break;
                }
            }

            if (jpegICI != null)
            {
                //outBmp.Save(Response.OutputStream, jpegICI, encoderParams);
                outBmp.Save(destfile, jpegICI, encoderParams);
            }
            else
            {
                //outBmp.Save(Response.OutputStream, thisFormat);
                outBmp.Save(destfile, thisFormat);
            }

            img.Dispose();
            outBmp.Dispose();
        }
        #endregion

        #region 生成缩略图,加水印
        public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile, string sy, int nType)
        {
            if (nType == 0)
                CreateSmallPhoto(filename, nWidth, nHeight, destfile, sy, "");
            else
                CreateSmallPhoto(filename, nWidth, nHeight, destfile, "", sy);
        }
        #endregion

        #region 生成缩略图
        /// <summary>
        /// 生成缩略图
        /// </summary>
        /// <param name="filename">源文件</param>
        /// <param name="nWidth">缩略图宽度</param>
        /// <param name="nHeight">缩略图高度</param>
        /// <param name="destfile">缩略图保存位置</param>
        /// <param name="png">图片水印</param>
        /// <param name="text">文本水印</param>
        public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile, string png, string text)
        {
            Image img = Image.FromFile(filename);
            ImageFormat thisFormat = img.RawFormat;

            Size CutSize = CutRegion(nWidth, nHeight, img);
            Bitmap outBmp = new Bitmap(nWidth, nHeight);
            Graphics g = Graphics.FromImage(outBmp);
            g.Clear(Color.White);

            // 设置画布的描绘质量
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;

            int nStartX = (img.Width - CutSize.Width) / 2;
            int nStartY = (img.Height - CutSize.Height) / 2;

            g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                nStartX, nStartY, CutSize.Width, CutSize.Height, GraphicsUnit.Pixel);
            g.Dispose();

            // 以下代码为保存图片时,设置压缩质量
            EncoderParameters encoderParams = new EncoderParameters();
            long[] quality = new long[1];
            quality[0] = 100;

            EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
            encoderParams.Param[0] = encoderParam;

            //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
            ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo jpegICI = null;
            for (int x = 0; x < arrayICI.Length; x++)
            {
                if (arrayICI[x].FormatDescription.Equals("JPEG"))
                {
                    jpegICI = arrayICI[x];//设置JPEG编码
                    break;
                }
            }

            if (jpegICI != null)
            {
                outBmp.Save(destfile, jpegICI, encoderParams);
            }
            else
            {
                outBmp.Save(destfile, thisFormat);
            }

            img.Dispose();
            outBmp.Dispose();

            if (!string.IsNullOrEmpty(png))
                AttachPng(png, destfile);

            if (!string.IsNullOrEmpty(text))
                AttachText(text, destfile);
        }


        public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile, string png, string text, CutMode cMode)
        {
            Image img = Image.FromFile(filename);

            if (nWidth <= 0)
                nWidth = img.Width;
            if (nHeight <= 0)
                nHeight = img.Height;

            int towidth = nWidth;
            int toheight = nHeight;

            switch (cMode)
            {
                case CutMode.CutWH://指定高宽缩放(可能变形)               
                    break;
                case CutMode.CutW://指定宽,高按比例                   
                    toheight = img.Height * nWidth / img.Width;
                    break;
                case CutMode.CutH://指定高,宽按比例
                    towidth = img.Width * nHeight / img.Height;
                    break;
                case CutMode.CutNo: //缩放不剪裁
                    int maxSize = (nWidth >= nHeight ? nWidth : nHeight);
                    if (img.Width >= img.Height)
                    {
                        towidth = maxSize;
                        toheight = img.Height * maxSize / img.Width;
                    }
                    else
                    {
                        toheight = maxSize;
                        towidth = img.Width * maxSize / img.Height;
                    }
                    break;
                default:
                    break;
            }
            nWidth = towidth;
            nHeight = toheight;

            ImageFormat thisFormat = img.RawFormat;

            Size CutSize = new Size(nWidth, nHeight);
            if (cMode != CutMode.CutNo)
                CutSize = CutRegion(nWidth, nHeight, img);

            Bitmap outBmp = new Bitmap(CutSize.Width, CutSize.Height);

            Graphics g = Graphics.FromImage(outBmp);
            g.Clear(Color.White);

            // 设置画布的描绘质量
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;

            int nStartX = (img.Width - CutSize.Width) / 2;
            int nStartY = (img.Height - CutSize.Height) / 2;

            //int x1 = (outBmp.Width - nWidth) / 2;
            //int y1 = (outBmp.Height - nHeight) / 2;

            if (cMode != CutMode.CutNo)
                g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                    nStartX, nStartY, CutSize.Width, CutSize.Height, GraphicsUnit.Pixel);
            else
                g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                0, 0, img.Width, img.Height, GraphicsUnit.Pixel);
            g.Dispose();

            // 以下代码为保存图片时,设置压缩质量
            EncoderParameters encoderParams = new EncoderParameters();
            long[] quality = new long[1];
            quality[0] = 100;

            EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
            encoderParams.Param[0] = encoderParam;

            //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
            ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo jpegICI = null;
            for (int x = 0; x < arrayICI.Length; x++)
            {
                if (arrayICI[x].FormatDescription.Equals("JPEG"))
                {
                    jpegICI = arrayICI[x];//设置JPEG编码
                    break;
                }
            }

            if (jpegICI != null)
            {
                outBmp.Save(destfile, jpegICI, encoderParams);
            }
            else
            {
                outBmp.Save(destfile, thisFormat);
            }

            img.Dispose();
            outBmp.Dispose();

            if (!string.IsNullOrEmpty(png))
                AttachPng(png, destfile);

            if (!string.IsNullOrEmpty(text))
                AttachText(text, destfile);
        }
        #endregion

        #endregion

        #region 添加文字水印
        public void AttachText(string text, string file)
        {
            if (string.IsNullOrEmpty(text))
                return;

            if (!System.IO.File.Exists(file))
                return;

            System.IO.FileInfo oFile = new System.IO.FileInfo(file);
            string strTempFile = System.IO.Path.Combine(oFile.DirectoryName, Guid.NewGuid().ToString() + oFile.Extension);
            oFile.CopyTo(strTempFile);

            Image img = Image.FromFile(strTempFile);
            ImageFormat thisFormat = img.RawFormat;

            int nHeight = img.Height;
            int nWidth = img.Width;

            Bitmap outBmp = new Bitmap(nWidth, nHeight);
            Graphics g = Graphics.FromImage(outBmp);
            g.Clear(Color.White);

            // 设置画布的描绘质量
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;

            g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                0, 0, nWidth, nHeight, GraphicsUnit.Pixel);

            int[] sizes = new int[] { 16, 14, 12, 10, 8, 6, 4 };

            Font crFont = null;
            SizeF crSize = new SizeF();

            //通过循环这个数组,来选用不同的字体大小
            //如果它的大小小于图像的宽度,就选用这个大小的字体
            for (int i = 0; i < 7; i++)
            {
                //设置字体,这里是用arial,黑体
                crFont = new Font("arial", sizes[i], FontStyle.Bold);
                //Measure the Copyright string in this Font
                crSize = g.MeasureString(text, crFont);

                if ((ushort)crSize.Width < (ushort)nWidth)
                    break;
            }

            //因为图片的高度可能不尽相同, 所以定义了
            //从图片底部算起预留了5%的空间
            int yPixlesFromBottom = (int)(nHeight * .08);

            //现在使用版权信息字符串的高度来确定要绘制的图像的字符串的y坐标

            float yPosFromBottom = ((nHeight - yPixlesFromBottom) - (crSize.Height / 2));

            //计算x坐标
            float xCenterOfImg = (nWidth / 2);

            //把文本布局设置为居中
            StringFormat StrFormat = new StringFormat();
            StrFormat.Alignment = StringAlignment.Center;

            //通过Brush来设置黑色半透明
            SolidBrush semiTransBrush2 = new SolidBrush(Color.FromArgb(153, 0, 0, 0));

            //绘制版权字符串
            g.DrawString(text,                 //版权字符串文本
                crFont,                                   //字体
                semiTransBrush2,                           //Brush
                new PointF(xCenterOfImg + 1, yPosFromBottom + 1),  //位置
                StrFormat);

            //设置成白色半透明
            SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(153, 255, 255, 255));

            //第二次绘制版权字符串来创建阴影效果
            //记住移动文本的位置1像素
            g.DrawString(text,                 //版权文本
                crFont,                                   //字体
                semiTransBrush,                           //Brush
                new PointF(xCenterOfImg, yPosFromBottom),  //位置
                StrFormat);

            g.Dispose();

            // 以下代码为保存图片时,设置压缩质量
            EncoderParameters encoderParams = new EncoderParameters();
            long[] quality = new long[1];
            quality[0] = 100;

            EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
            encoderParams.Param[0] = encoderParam;

            //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
            ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo jpegICI = null;
            for (int x = 0; x < arrayICI.Length; x++)
            {
                if (arrayICI[x].FormatDescription.Equals("JPEG"))
                {
                    jpegICI = arrayICI[x];//设置JPEG编码
                    break;
                }
            }

            if (jpegICI != null)
            {
                outBmp.Save(file, jpegICI, encoderParams);
            }
            else
            {
                outBmp.Save(file, thisFormat);
            }

            img.Dispose();
            outBmp.Dispose();

            System.IO.File.Delete(strTempFile);
        }
        #endregion

        #region 添加图片水印
        ///<summary>
        /// 添加图片水印
        /// </summary>
        /// <param name="png">水印图片</param>
        /// <param name="file">原文件</param>
        /// <param name="position">水印图片的位置 0居中、1左上角、2右上角、3左下角、4右下角</param>
        public void AttachPng(string png, string file)
        {
            if (string.IsNullOrEmpty(png))
                return;

            if (!System.IO.File.Exists(png))
                return;

            if (!System.IO.File.Exists(file))
                return;

            System.IO.FileInfo oFile = new System.IO.FileInfo(file);
            string strTempFile = System.IO.Path.Combine(oFile.DirectoryName, Guid.NewGuid().ToString() + oFile.Extension);
            oFile.CopyTo(strTempFile);

            Image img = Image.FromFile(strTempFile);
            ImageFormat thisFormat = img.RawFormat;
            int nHeight = img.Height;
            int nWidth = img.Width;

            Bitmap outBmp = new Bitmap(nWidth, nHeight);
            Graphics g = Graphics.FromImage(outBmp);

            // 设置画布的描绘质量
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;

            g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                0, 0, nWidth, nHeight, GraphicsUnit.Pixel);

            img.Dispose();

            img = Image.FromFile(png);

            //Bitmap bmpPng = new Bitmap(img);

            //ImageAttributes imageAttr = new ImageAttributes();
            //Color bg = Color.Green;
            //imageAttr.SetColorKey(bg, bg);

            Size pngSize = NewSize(nWidth, nHeight, img);
            int nx = 0;
            int ny = 0;
            int padding = 10;
            if (SetPositionWater == 0)
            {
                nx = (nWidth - pngSize.Width) / 2;
                ny = (nHeight - pngSize.Height) / 2;
            }
            else if (SetPositionWater == 1)
            {
                nx = padding;
                ny = padding;
            }
            else if (SetPositionWater == 2)
            {
                nx = (nWidth - pngSize.Width) - padding;
                ny = padding;
            }
            else if (SetPositionWater == 3)
            {
                nx = padding;
                ny = (nHeight - pngSize.Height) - padding;
            }
            else
            {
                nx = (nWidth - pngSize.Width) - padding;
                ny = (nHeight - pngSize.Height) - padding;
            }
            g.DrawImage(img, new Rectangle(nx, ny, pngSize.Width, pngSize.Height),
                0, 0, img.Width, img.Height, GraphicsUnit.Pixel);

            g.Dispose();

            // 以下代码为保存图片时,设置压缩质量
            EncoderParameters encoderParams = new EncoderParameters();
            long[] quality = new long[1];
            quality[0] = 100;

            EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
            encoderParams.Param[0] = encoderParam;

            //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
            ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo jpegICI = null;
            for (int x = 0; x < arrayICI.Length; x++)
            {
                if (arrayICI[x].FormatDescription.Equals("JPEG"))
                {
                    jpegICI = arrayICI[x];//设置JPEG编码
                    break;
                }
            }

            if (jpegICI != null)
            {
                outBmp.Save(file, jpegICI, encoderParams);
            }
            else
            {
                outBmp.Save(file, thisFormat);
            }

            img.Dispose();
            outBmp.Dispose();

            System.IO.File.Delete(strTempFile);
        }
        #endregion

        #region 得到指定mimeType的ImageCodecInfo
        /// <summary>
        /// 保存JPG时用
        /// </summary>
        /// <param name="mimeType"> </param>
        /// <returns>得到指定mimeType的ImageCodecInfo </returns>
        private ImageCodecInfo GetCodecInfo(string mimeType)
        {
            ImageCodecInfo[] CodecInfo = ImageCodecInfo.GetImageEncoders();
            foreach (ImageCodecInfo ici in CodecInfo)
            {
                if (ici.MimeType == mimeType) return ici;
            }
            return null;
        }
        #endregion

        #region 保存为JPEG格式,支持压缩质量选项
        /// <summary>
        /// 保存为JPEG格式,支持压缩质量选项
        /// </summary>
        /// <param name="SourceFile"></param>
        /// <param name="FileName"></param>
        /// <param name="Qty"></param>
        /// <returns></returns>
        public bool KiSaveAsJPEG(string SourceFile, string FileName, int Qty)
        {
            Bitmap bmp = new Bitmap(SourceFile);

            try
            {
                EncoderParameter p;
                EncoderParameters ps;

                ps = new EncoderParameters(1);

                p = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, Qty);
                ps.Param[0] = p;

                bmp.Save(FileName, GetCodecInfo("image/jpeg"), ps);

                bmp.Dispose();

                return true;
            }
            catch
            {
                bmp.Dispose();
                return false;
            }

        }
        #endregion

        #region 将图片压缩到指定大小
        /// <summary>
        /// 将图片压缩到指定大小
        /// </summary>
        /// <param name="FileName">待压缩图片</param>
        /// <param name="size">期望压缩后的尺寸</param>
        public void CompressPhoto(string FileName, int size)
        {
            if (!System.IO.File.Exists(FileName))
                return;

            int nCount = 0;
            System.IO.FileInfo oFile = new System.IO.FileInfo(FileName);
            long nLen = oFile.Length;
            while (nLen > size * 1024 && nCount < 10)
            {
                string dir = oFile.Directory.FullName;
                string TempFile = System.IO.Path.Combine(dir, Guid.NewGuid().ToString() + "." + oFile.Extension);
                oFile.CopyTo(TempFile, true);

                KiSaveAsJPEG(TempFile, FileName, 70);

                try
                {
                    System.IO.File.Delete(TempFile);
                }
                catch { }

                nCount++;

                oFile = new System.IO.FileInfo(FileName);
                nLen = oFile.Length;
            }
        }
        #endregion

        #endregion


        #region common method

        /// <summary>
        /// 图片上传错误编码
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        private string GetCodeMessage(int code)
        {
            var dic = new Dictionary<int, string>(){
        {0,"系统配置错误"},
        {1,"上传图片成功"},
        {2,string.Format( "对不起,上传格式错误!请上传{0}格式图片",SetAllowFormat)},
        {3,string.Format("超过文件上传大小,不得超过{0}M",SetAllowSize)},
        {4,"未上传文件"},
        {5,""},
        {6,"缩略图长度和宽度配置错误"},
        {7,"检测图片宽度限制"}
         };
            return dic[code];
        }
        private void TryError(ResponseMessage rm, int code)
        {
            rm.IsError = true;
            rm.Message = GetCodeMessage(code);
        }
        private void TryError(ResponseMessage rm, string message)
        {
            rm.IsError = true;
            rm.Message = message;
        }
        #endregion

        #region models
        public enum CutMode
        {
            /// <summary>
            /// 根据高宽剪切
            /// </summary>
            CutWH = 1,
            /// <summary>
            /// 根据宽剪切
            /// </summary>
            CutW = 2,
            /// <summary>
            /// 根据高剪切
            /// </summary>
            CutH = 3,
            /// <summary>
            /// 缩放不剪裁
            /// </summary>
            CutNo = 4
        }
        public class ResponseMessage
        {
            /// <summary>
            /// 是否遇到错误
            /// </summary>
            public bool IsError { get; set; }
            /// <summary>
            /// web路径
            /// </summary>
            public string WebPath { get; set; }
            /// <summary>
            /// 文件物理路径
            /// </summary>
            public string filePath { get; set; }
            /// <summary>
            /// 反回消息
            /// </summary>
            public string Message { get; set; }
            /// <summary>
            /// 文件大小
            /// </summary>
            public double Size { get; set; }
            /// <summary>
            /// 图片名
            /// </summary>
            public string FileName { get; set; }
            /// <summary>
            /// 图片目录
            /// </summary>
            public string Directory
            {
                get
                {
                    if (WebPath == null) return null;
                    return WebPath.Replace(FileName, "");
                }
            }
            /// <summary>
            /// 缩略图路径
            /// </summary>
            public string SmallPath(int index)
            {
                return string.Format("{0}{1}_{2}{3}", Directory, Path.GetFileNameWithoutExtension(FileName), index, Path.GetExtension(FileName));
            }
        }
        #endregion
    }

}

  

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Chrome 图片解码与 Image Decoding Hint
我在之前的一篇文章[Chrome 图片解码与 Image.decode API][1],说明了为什么图片解码可能会导致非合成器动画的阻塞和如何使用 Image.decode API 来避免动画的阻塞。不过虽然 Image.decode API 给页端提供了更灵活的控制图片解码时机的能力,但是使用起来较为复杂,也容易误用,而 Image Decoding Hint 属性则更简单,容易使用,同时也满足
2821 0
Kubernetes 1.4:一个DevOps工具管理所有的容器
本文讲的是Kubernetes 1.4:一个DevOps工具管理所有的容器【编者的话】有很多的DevOps工具管理容器,但Kubernetes迅速成为其中的佼佼者。
1583 0
你以为的ASP.NET文件上传大小限制是你以为的吗
原文:你以为的ASP.NET文件上传大小限制是你以为的吗 我们以为的文件大小限制 我们大家都知道ASP.NET为我们提供了文件上传服务器控件FileUpload,默认情况下可上传的最大文件为4M,如果要改变可上传文件大小限制,那么我们可以在web.config中的httpRuntime元素中添加maxRequestLength属性设置大小,同时为了支持大文件上传超时可以添加executionTimeout属性设置超时时间。
1045 0
DOS批处理命令递归删除给定的文件(夹),兼VC工程清理小工具
<p><span style="font-size:18px;">使用dos批处理命令递归删除指定的文件(夹):</span></p> <p><span style="font-size:18px;">(下面内容针对清理VC工程!自己按说明任意修改)</span></p> <p><span style="font-size:18px;">2014-06-10修改:删除前增加了[y,n]询问;<
1519 0
C# 使用FileUpload控件上传图片,将文件转换成二进制进行存储与读取
状况描述:   需要上传文件,但是不想要保存到实体路径下,便可以用该功能来实现。   效果图:      点击【Upload】按钮,上传文件到数据库;   点击【Preview】,预览文件;   具体实现:   前台: 1 2 3 4 : 5 ...
1663 0
SQLite数据库常用语句及MAC上的SQLite可视化工具MeasSQLlite使用(二)
SQLite数据库常用语句及MAC上的SQLite可视化工具MeasSQLlite使用
16 0
UIImage 图片处理:截图,缩放,设定大小,存储
<p style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> <span style="font-family:mceinline"><span style="font-size:18px">1.等比率缩放</span><br> - (UIImage *)scaleImage:(
1547 0
TensorFlow新功能:TensorFlow Probability概率编程工具箱介绍
2018年,tensorflow开发者峰会上,tensorflow管理人员发布了:TensorFlow Probability——一种概率编程工具箱,用于机器学习研究人员和从业人员快速可靠地构建利用最先进硬件的复杂模型。快来学习一下吧~
3292 0
推荐25款很棒的 HTML5 开发框架和开发工具【上篇】
  HTML5 在不同的领域让网页设计更强大的。快速,安全,响应式,互动和美丽,这些优点吸引更多的 Web 开发人员使用 HTML5。HTML5 有许多新的特性功能,允许开发人员和设计师创建应用程序和网站,带给用户桌面应用程序的速度,性能和体验。
1008 0
+关注
杰克.陈
一个安静的程序猿~
9798
文章
2
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载