ASP.NET简单好用功能齐全图片上传工具类（水印、缩略图、裁剪等）

使用方法：

									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

									  /// </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

									  }

									}