【无私分享：从入门到精通ASP.NET MVC】从0开始，一起搭框架、做项目 （11）文件管理

索引

【无私分享：从入门到精通ASP.NET MVC】从0开始，一起搭框架、做项目 目录索引

简述

文件管理，这个比较鸡肋 但是有些方法 大家可以参考下

项目准备

我们用的工具是：VS 2013 + SqlServer 2012 + IIS7.5

希望大家对ASP.NET MVC有一个初步的理解，理论性的东西我们不做过多解释，有些地方不理解也没关系，会用就行了，用的多了，用的久了，自然就理解了。

项目开始

其实叫文件管理呢有点过，这个功能比较鸡肋，但是大家可以参考一下一些方法

一、我们在ComManage区域下面新建个控制器 UploadControllers

1、1 我们新建一个视图Home，这里接收的fileExt就是左侧用户选择的文件类型

/// <summary>
        /// 文件管理默认页面
        /// </summary>
        /// <returns></returns>
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "View")]
        public ActionResult Home()
        {
            var fileExt = Request.QueryString["fileExt"] ?? "";
            ViewData["fileExt"] = fileExt;
            return View();
        }

1、2 我们新建一个获取获取文件的方法 然后试图页通过ajax获取数据

/// <summary>
        /// 通过路径获取所有文件
        /// </summary>
        /// <returns></returns>
        public ActionResult GetAllFileData()
        {
            string fileExt = Request.Form["fileExt"];
            var jsonM = new JsonHelper() { Status = "y", Msg = "success" };
            try
            {
                var images = ConfigurationManager.AppSettings["Image"].Trim(',').Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(p => "." + p).ToList();
                var videos = ConfigurationManager.AppSettings["Video"].Trim(',').Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(p => "." + p).ToList();
                var musics = ConfigurationManager.AppSettings["Music"].Trim(',').Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(p => "." + p).ToList();
                var documents = ConfigurationManager.AppSettings["Document"].Trim(',').Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(p => "." + p).ToList();

                switch(fileExt)
                {
                    case "images":   
                    
                        jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetAllFileTable(Server.MapPath(ConfigurationManager.AppSettings["uppath"]))).OrderByDescending(p => p.name).Where(p=>images.Any(e=>e==p.ext)).ToList();
                        break;
                    case "videos":
                       
                        jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetAllFileTable(Server.MapPath(ConfigurationManager.AppSettings["uppath"]))).OrderByDescending(p => p.name).Where(p => videos.Any(e => e == p.ext)).ToList();
                        break;
                    case "musics":
                       
                        jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetAllFileTable(Server.MapPath(ConfigurationManager.AppSettings["uppath"]))).OrderByDescending(p => p.name).Where(p => musics.Any(e => e == p.ext)).ToList();
                        break;
                    case "files":
                       
                        jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetAllFileTable(Server.MapPath(ConfigurationManager.AppSettings["uppath"]))).OrderByDescending(p => p.name).Where(p => documents.Any(e => e == p.ext)).ToList();
                        break;
                    case "others":

                        jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetAllFileTable(Server.MapPath(ConfigurationManager.AppSettings["uppath"]))).OrderByDescending(p => p.name).Where(p => !images.Contains(p.ext) && !videos.Contains(p.ext) && !musics.Contains(p.ext) && !documents.Contains(p.ext)).ToList();
                        break;
                    default:
                        jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetAllFileTable(Server.MapPath(ConfigurationManager.AppSettings["uppath"]))).OrderByDescending(p => p.name).ToList();
                        break;
                }
                
            }
            catch (Exception)
            {
                jsonM.Status = "err";
                jsonM.Msg = "获取文件失败！";
            }
            return Content(JsonConverter.Serialize(jsonM, true));
        }      

1、3 FileModel模型

/// <summary>
        /// 文件名称
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// 文件全称
        /// </summary>
        public string fullname { get; set; }
        /// <summary>
        /// 文件路径
        /// </summary>
        public string path { get; set; }
        /// <summary>
        /// 文件格式
        /// </summary>
        public string ext { get; set; }
        /// <summary>
        /// 文件大小
        /// </summary>
        public string size { get; set; }
        /// <summary>
        /// 文件图标
        /// </summary>
        public string icon { get; set; }
        /// <summary>
        /// 是否为文件夹
        /// </summary>
        public bool isfolder { get; set; }
        /// <summary>
        /// 是否为图片
        /// </summary>
        public bool isImage { get; set; }
        /// <summary>
        /// 上传时间
        /// </summary>
        public DateTime time { get; set; }

1、4 FileHelper类GetAllFileTable方法 我们把获得的文件数据转换成DataTable 返回回来

/// <summary>
        /// 获取目录下所有文件（包含子目录）
        /// </summary>
        /// <param name="Path"></param>
        /// <returns></returns>

        public static DataTable GetAllFileTable(string Path)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add("name", typeof(string));
            dt.Columns.Add("ext", typeof(string));
            dt.Columns.Add("size", typeof(string));
            dt.Columns.Add("icon", typeof(string));
            dt.Columns.Add("isfolder", typeof(bool));
            dt.Columns.Add("isImage", typeof(bool));
            dt.Columns.Add("fullname", typeof(string));
            dt.Columns.Add("path", typeof(string));
            dt.Columns.Add("time", typeof(DateTime));

            string[] folders = Directory.GetDirectories(Path, "*", SearchOption.AllDirectories);

            List<string> Listfloders = new List<string>() { Path };

            if (folders != null && folders.Count() > 0)
            {
                foreach (var folder in folders)
                {
                    Listfloders.Add(folder);
                }
            }

            foreach (var f in Listfloders)
            {
                DirectoryInfo dirinfo = new DirectoryInfo(f);
                FileInfo fi;
                string FileName = string.Empty, FileExt = string.Empty, FileSize = string.Empty, FileIcon = string.Empty, FileFullName = string.Empty, FilePath = string.Empty;
                bool IsFloder = false, IsImage = false;
                DateTime FileModify;
                try
                {
                    foreach (FileSystemInfo fsi in dirinfo.GetFiles())
                    {

                        fi = (FileInfo)fsi;
                        //获取文件名称
                        FileName = fi.Name.Substring(0, fi.Name.LastIndexOf('.'));
                        FileFullName = fi.Name;
                        //获取文件扩展名
                        FileExt = fi.Extension.ToLower();
                        //获取文件大小
                        FileSize = GetDiyFileSize(fi);
                        //获取文件最后修改时间
                        FileModify = fi.LastWriteTime;
                        //文件图标
                        FileIcon = GetFileIcon(FileExt);
                        //是否为图片
                        IsImage = IsImageFile(FileExt.Substring(1, FileExt.Length - 1));
                        //文件路径
                        FilePath = urlconvertor(fi.FullName);

                        DataRow dr = dt.NewRow();
                        dr["name"] = FileName;
                        dr["fullname"] = FileFullName;
                        dr["ext"] = FileExt;
                        dr["size"] = FileSize;
                        dr["time"] = FileModify;
                        dr["icon"] = FileIcon;
                        dr["isfolder"] = IsFloder;
                        dr["isImage"] = IsImage;
                        dr["path"] = FilePath;
                        dt.Rows.Add(dr);
                    }
                }
                catch (Exception e)
                {

                    throw e;
                }
            }

            return dt;
        }

1、5 展示文件列表

我用了个jquery.tmpl.js插件 大家可以用比较流行的 angularjs

这个JS包含了 加载文件列表、删除单个文件、删除多个文件、显示文件路径、复制文件、移动文件、压缩文件、解压文件等方法 我们待会分别把方法列出来

$(function () {
    filesManage.initFiles();    
});
var filesManage = {
    initFiles: function () {
        $.post("/Com/Upload/GetAllFileData", { fileExt: $("#fileExt").val() }, function (res) {
            if (res.Status == "y") {
                if (res.Data == "" || res.Data == null) {
                    $("#filesPanel").html('<div class="alert alert-warning text-center"><span style="font-size:16px;"><i class="fa fa-warning"></i>&nbsp;没有找到任何文件</span></div>');
                } else {
                    $("#filesPanel").empty();
                    $("#tlist").tmpl(res.Data).appendTo('#filesPanel');
                    $(".file-box").each(function () { animationHover(this, "pulse") });
                    //初始化CheckBox
                    $(".icheck_box").iCheck({
                        checkboxClass: 'icheckbox_flat-red',
                        radioClass: 'iradio_flat-red',
                        increaseArea: '20%' // optional
                    });
                    //点击选中/取消
                    $(".checkselected").click(function () {
                        if ($(this).parent().next().find('input[name="check_files"]').prop("checked"))
                        {
                            $(this).parent().next().find('input[name="check_files"]').iCheck("uncheck");
                        }
                        else {
                            $(this).parent().next().find('input[name="check_files"]').iCheck("check");
                        }
                    });
                }
            } 
            else {
                dig.error(res.Msg);
            }
        }, "json");
    },
    delFiles: function (n) {
        dig.confirm("删除确认", "删除后不可恢复,确定删除吗？", function () {
            $.post("/Com/Upload/DeleteBy", { path: n }, function (res) {
                if (res.Status == "y")
                    location.reload();
                else {
                    dig.error(res.Msg);
                }
            }, "json");
        });
    },
    delMoreFiles: function () {
        var vals = '';
        $('input[name="check_files"]:checked').each(function () {
            vals += $(this).val() + ';';
        });
        if (vals == '' || vals == ';') {
            dig.error("对不起，请选中您要操作的文件！");
            return;
        }
        dig.confirm("删除确认", "删除后不可恢复,确定删除吗？", function () {
            $.post("/Com/Upload/DeleteBy", { path: vals }, function (res) {
                if (res.Status == "y")
                    location.reload();
                else {
                    dig.error(res.Msg);
                }
            }, "json");
        });
    },
    showFilePath: function (n) {
        dig.msg("","文件目录："+n);
    },
    copyFiles: function () {
        var vals = '';
        $('input[name="check_files"]:checked').each(function () {
            vals += $(this).val() + ';';
        });
        if (vals == '' || vals == ';') {
            dig.error("对不起，请选中您要操作的文件！");
            return;
        }
        dig.fileOperation('',vals,"/Com/Upload/Copy", function () {
            if (this.returnValue == 'yes') {
                location.reload();
            }
        });
    },
    moveFiles: function () {
        var vals = '';
        $('input[name="check_files"]:checked').each(function () {
            vals += $(this).val() + ';';
        });
        if (vals == '' || vals == ';') {
            dig.error("对不起，请选中您要操作的文件！");
            return;
        }
        dig.fileOperation('', vals, "/Com/Upload/Cut", function () {
            if (this.returnValue == 'yes') {
                location.reload();
            }
        });
    },
    compressFiles: function () {
        var vals = '';
        $('input[name="check_files"]:checked').each(function () {
            vals += $(this).val() + ';';
        });
        if (vals == '' || vals == ';') {
            dig.error("对不起，请选中您要操作的文件！");
            return;
        }
        dig.fileOperation('', vals, "/Com/Upload/Compress", function () {
            if (this.returnValue == 'yes') {
                location.reload();
            }
        });
    },
    expandFiles: function () {
        var vals = '';
        var num = 0;
        $('input[name="check_files"]:checked').each(function () {
            vals = $(this).val();
            num++;
        });
        if (!vals) {
            dig.error("对不起，请选中您要操作的文件！");
            return;
        }
        if (num > 1) {
            dig.error("对不起，每次只能操作一个文件！");
            return;
        }
        if(vals.substring(vals.lastIndexOf('.'), vals.length)!=".zip")
        {
            dig.error("只能解压ZIP格式文件！");
            return;
        }
        dig.fileOperation('', vals, "/Com/Upload/Expand", function () {
            if (this.returnValue == 'yes') {
                location.reload();
            }
        });
    }
};
function animationHover(o, e) {
    o = $(o), o.hover(function () {
        o.addClass("animated " + e)
    }, function () {
        window.setTimeout(function () {
            o.removeClass("animated " + e)
        }, 2e3)
    })
}

 

二、文件操作

2、1 删除文件或文件夹

/// <summary>
        /// 删除文件或文件夹
        /// </summary>
        /// <returns></returns>
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Remove")]
        public ActionResult DeleteBy()
        {
            var jsonM = new JsonHelper() { Status = "y", Msg = "success" };
            try
            {
                var path = Request.Form["path"].Trim(';').Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries).Select(p => p).ToList();

                foreach (var file in path)
                {
                    //删除文件
                    FileHelper.DeleteFile(Server.MapPath(file));
                }

                WriteLog(Common.Enums.enumOperator.Remove, "删除文件：" + path, Common.Enums.enumLog4net.WARN);
            }
            catch (Exception ex)
            {
                jsonM.Status = "err";
                jsonM.Msg = "删除过程中发生错误！";
                WriteLog(Common.Enums.enumOperator.Remove, "删除文件发生错误：", ex);
            }
            return Json(jsonM);
        }

2、2 复制文件到文件夹

/// <summary>
        /// 复制文件到文件夹
        /// </summary>
        /// <returns></returns>
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Copy")]
        public ActionResult Copy(string files)
        {
            ViewData["Files"] = files;
            ViewData["spath"] = ConfigurationManager.AppSettings["uppath"];
            return View();
        }
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Copy")]
        public ActionResult CopyFiles()
        {
            var json = new JsonHelper() { Msg = "复制文件完成", Status = "n" };

            try
            {
                var files = Request.Form["files"].Trim(';').Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries).Select(p => p).ToList();
                var path = Request.Form["path"];
                foreach (var file in files)
                {
                    FileHelper.Copy(Server.MapPath(file), Server.MapPath(path) + FileHelper.GetFileName(Server.MapPath(file)));
                }
                WriteLog(Common.Enums.enumOperator.None, "复制文件：" + Request.Form["files"].Trim(';') + "，结果：" + json.Msg, Common.Enums.enumLog4net.WARN);
                json.Status = "y";
            }
            catch(Exception e)
            {
                json.Msg = "复制文件失败！";
                WriteLog(Common.Enums.enumOperator.None, "复制文件：", e);
            }

            return Json(json);
        }

2、3 移动文件到文件夹

/// <summary>
        /// 移动文件到文件夹
        /// </summary>
        /// <returns></returns>
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Cut")]
        public ActionResult Cut(string files)
        {
            ViewData["Files"] = files;
            ViewData["spath"] = ConfigurationManager.AppSettings["uppath"];
            return View();
        }
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Cut")]
        public ActionResult CutFiles()
        {
            var json = new JsonHelper() { Msg = "移动文件完成", Status = "n" };

            try
            {
                var files = Request.Form["files"].Trim(';').Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries).Select(p => p).ToList();
                var path = Request.Form["path"];
                foreach (var file in files)
                {
                    FileHelper.Move(Server.MapPath(file), Server.MapPath(path));
                }
                WriteLog(Common.Enums.enumOperator.None, "移动文件：" + Request.Form["files"].Trim(';') + "，结果：" + json.Msg, Common.Enums.enumLog4net.WARN);
                json.Status = "y";
            }
            catch (Exception e)
            {
                json.Msg = "移动文件失败！";
                WriteLog(Common.Enums.enumOperator.None, "移动文件：", e);
            }

            return Json(json);
        }

2、4 压缩文件

/// <summary>
        /// 压缩文件
        /// </summary>
        /// <returns></returns>
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Compress")]
        public ActionResult Compress(string files)
        {
            ViewData["Files"] = files;
            ViewData["spath"] = ConfigurationManager.AppSettings["uppath"];
            return View();
        }
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Compress")]
        public ActionResult CompressFiles()
        {
            var json = new JsonHelper() { Msg = "压缩文件完成", Status = "n" };

            try
            {
                var files = Request.Form["files"].Trim(';').Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries).Select(p => p).ToList();
                var path = Request.Form["path"];
                foreach (var file in files)
                {
                    ZipHelper.ZipFile(Server.MapPath(file), Server.MapPath(path));
                }
                //ZipHelper.ZipDirectory(Server.MapPath("/upload/files/"), Server.MapPath(path));
                WriteLog(Common.Enums.enumOperator.None, "压缩文件：" + Request.Form["files"].Trim(';') + "，结果：" + json.Msg, Common.Enums.enumLog4net.WARN);
                json.Status = "y";
            }
            catch (Exception e)
            {
                json.Msg = "压缩文件失败！";
                WriteLog(Common.Enums.enumOperator.None, "压缩文件：", e);
            }

            return Json(json);
        }

2、5 解压文件

/// <summary>
        /// 解压文件
        /// </summary>
        /// <returns></returns>
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Expand")]
        public ActionResult Expand(string files)
        {
            ViewData["Files"] = files;
            ViewData["spath"] = ConfigurationManager.AppSettings["uppath"];
            return View();
        }
        [UserAuthorizeAttribute(ModuleAlias = "Files", OperaAction = "Expand")]
        public ActionResult ExpandFiles()
        {
            var json = new JsonHelper() { Msg = "解压文件完成", Status = "n" };

            try
            {
                var files = Request.Form["files"];
                var path = Request.Form["path"];
                var password = Request.Form["password"];

                if (string.IsNullOrEmpty(password))
                {
                    json.Msg = "请输入解压密码！";
                    return Json(json);
                }

                string CurrentPassword=ConfigurationManager.AppSettings["ZipPassword"] != null ? new Common.CryptHelper.AESCrypt().Decrypt(ConfigurationManager.AppSettings["ZipPassword"].ToString()) : "guodongbudingxizhilang";

                if (password != CurrentPassword)
                {
                    json.Msg = "解压密码无效！";
                    return Json(json);
                }
               
                ZipHelper.UnZip(Server.MapPath(files), Server.MapPath(path),password);
                
                WriteLog(Common.Enums.enumOperator.None, "解压文件：" + Request.Form["files"].Trim(';') + "，结果：" + json.Msg, Common.Enums.enumLog4net.WARN);
                json.Status = "y";
            }
            catch (Exception e)
            {
                json.Msg = "解压文件失败！";
                WriteLog(Common.Enums.enumOperator.None, "解压文件：", e);
            }

            return Json(json);
        }

 

关于压缩和解压文件 我用的是ICSharpCode.SharpZipLib 有不太了解的朋友可以参考一下：ICSharpCode.SharpZipLib 压缩、解压文件 附源码

 

三、单文件上传

3、1 我们建一个上传视图页

/// <summary>
        /// 单文件上传视图
        /// </summary>
        /// <returns></returns>
        public ActionResult FileMain()
        {
            ViewData["spath"] = ConfigurationManager.AppSettings["uppath"];
            return View();
        }

3、2 试图页的Js

$(function () {
    //获取IFrame传递过来的值
    var dialog = top.dialog.get(window);
    var data = dialog.data;
    $("#fileUrl").val(data);
    if (data != '' && data != undefined) {
        //文件定位
        var p = data.substring(0, data.lastIndexOf('/') + 1);
        $('#path').val(p);
        $('#jsons').val('{"path":"' + data + '"}');
    }
    signfiles.initFiles($("#path").val());
    //上传
    $(".sign-upload").click(function () {
        $("#fileUp").unbind();
        $("#fileUp").click();
    });
    //保存
    $(".btn-save").click(function () {
        dialog.close($("#jsons").val());
        dialog.remove();
    });
    //返回上级目录
    $(".btn-higher-up").click(function () {
        signfiles.OpenParentFolder();
    });
});
var signfiles = {
    signUpFile: function (upInput) {
        var subUrl = "/Com/Upload/SignUpFile?fileUp=fileUrl&isThumbnail=" + $("#isThumbnail").prop("checked") + "&isWater=" + $("#isWater").prop("checked");
        $("#forms").ajaxSubmit({
            beforeSubmit: function () {
                dig.loading("正在上传");
                $(".sign-upload").attr("disabled", "disabled");
            },
            success: function (data) {
                if (data.Status == "y") {
                    var res = eval('(' + data.Data + ')');
                    $('#fileUrl').val(res.path);
                    $('#jsons').val(data.Data);
                    //定位
                    var pa = res.path.substring(0, res.path.lastIndexOf('/') + 1);
                    $('#path').val(pa);
                    signfiles.initFiles(pa);
                    sweetAlert.close();
                } else {
                    dig.error(data.Msg);
                }
                $(".sign-upload").attr("disabled", false);

            },
            error: function (e) {
                sweetAlert.close();
                $(".sign-upload").attr("disabled", false);
                console.log(e);
            },
            url: subUrl,
            type: "post",
            dataType: "json",
            timeout: 600000
        });
    },
    initFiles: function (path) {
        if (path == $("#spath").val()) {
            $(".btn-higher-up").attr("disabled", "disabled");
        } else {
            $(".btn-higher-up").attr("disabled", false);
        }
        $.post("/Com/Upload/GetFileData", { path: path }, function (res) {
            if (res.Status == "y") {
                if (res.Data == "" || res.Data == null) {
                    dig.error("该目录下没有文件了！");
                    signfiles.OpenParentFolder();
                } else {
                    $("#filesPanel").empty();
                    $("#tlist").tmpl(res.Data).appendTo('#filesPanel');
                }
            } else if (res.Status == "empty") {
                $("#filesPanel").html('<div class="alert alert-warning text-center"><span style="font-size:16px;"><i class="fa fa-warning"></i>&nbsp;没有找到任何文件</span></div>');
            }
            else {
                dig.error(res.Msg);
            }
        }, "json");
    },
    OpenFolder: function (path) {
        var npath = $("#path").val() + path + "/";
        $("#path").val(npath);
        signfiles.initFiles(npath);
    },
    OpenParentFolder: function () {
        var p = $("#path").val();
        if (p == $("#spath").val()) return;
        p = p.substring(0, p.lastIndexOf('/'));
        p = p.substring(0, p.lastIndexOf('/')) + "/";
        $("#path").val(p);
        signfiles.initFiles(p);
    },
    SetFile: function (path, ext,size,name) {
        $("#fileUrl").val($("#path").val() + path);
        $('#jsons').val('{"path":"' + $("#path").val() + path + '","thumbpath":"' + $("#path").val() + "thumb_" + path + ' ","ext":"' + ext + '","unitsize":"' + size + '","newname":"' + name + '","oldname":"' + name + '"}');
    }
}

3、3 单文件上传方法

 /// <summary>
        /// 单个文件上传
        /// </summary>
        [HttpPost]
        public ActionResult SignUpFile()
        {
            var jsonM = new JsonHelper() { Status = "n", Msg = "success" };
            try
            {
                //取得上传文件
                HttpPostedFileBase upfile = Request.Files["fileUp"];

                //原始文件路径
                string delpath = Request.QueryString["delpath"];

                //缩略图
                bool isThumbnail = string.IsNullOrEmpty(Request.QueryString["isThumbnail"]) ? false : Request.QueryString["isThumbnail"].ToLower() == "true" ? true : false;
                //水印
                bool isWater = string.IsNullOrEmpty(Request.QueryString["isWater"]) ? false : Request.QueryString["isWater"].ToLower() == "true" ? true : false;


                if (upfile == null)
                {
                    jsonM.Msg = "请选择要上传文件！";
                    return Json(jsonM);
                }
                jsonM = FileSaveAs(upfile, isThumbnail, isWater);

                #region 移除原始文件
                if (jsonM.Status == "y" && !string.IsNullOrEmpty(delpath))
                {
                    if (System.IO.File.Exists(Utils.GetMapPath(delpath)))
                    {
                        System.IO.File.Delete(Utils.GetMapPath(delpath));
                    }
                }
                #endregion

                if (jsonM.Status == "y")
                {
                    #region 记录上传数据
                    string unit = string.Empty;
                    var jsonValue = Common.JsonConverter.ConvertJson(jsonM.Data.ToString());
                    var entity = new Domain.COM_UPLOAD()
                    {
                        ID = Guid.NewGuid().ToString(),
                        FK_USERID = this.CurrentUser.Id.ToString(),
                        UPOPEATOR = this.CurrentUser.Name,
                        UPTIME = DateTime.Now,
                        UPOLDNAME = jsonValue.oldname,
                        UPNEWNAME = jsonValue.newname,
                        UPFILESIZE = FileHelper.GetDiyFileSize(long.Parse(jsonValue.size), out unit),
                        UPFILEUNIT = unit,
                        UPFILEPATH = jsonValue.path,
                        UPFILESUFFIX = jsonValue.ext,
                        UPFILETHUMBNAIL = jsonValue.thumbpath,
                        UPFILEIP = Utils.GetIP(),
                        UPFILEURL = "http://" + Request.Url.AbsoluteUri.Replace("http://", "").Substring(0, Request.Url.AbsoluteUri.Replace("http://", "").IndexOf('/'))
                    };
                    this.UploadManage.Save(entity);
                    #endregion

                    #region 返回文件信息
                    jsonM.Data = "{\"oldname\": \"" + jsonValue.oldname + "\","; //原始名称
                    jsonM.Data += " \"newname\":\"" + jsonValue.newname + "\","; //新名称
                    jsonM.Data += " \"path\": \"" + jsonValue.path + "\", ";  //路径
                    jsonM.Data += " \"thumbpath\":\"" + jsonValue.thumbpath + "\","; //缩略图
                    jsonM.Data += " \"size\": \"" + jsonValue.size + "\",";   //大小
                    jsonM.Data += " \"id\": \"" + entity.ID + "\",";   //上传文件ID
                    jsonM.Data += " \"uptime\": \"" + entity.UPTIME + "\",";   //上传时间
                    jsonM.Data += " \"operator\": \"" + entity.UPOPEATOR + "\",";   //上传人
                    jsonM.Data += " \"unitsize\": \"" + entity.UPFILESIZE + unit + "\",";   //带单位大小
                    jsonM.Data += "\"ext\":\"" + jsonValue.ext + "\"}";//后缀名
                    #endregion
                }

            }
            catch (Exception ex)
            {
                jsonM.Msg = "上传过程中发生错误，消息：" + ex.Message;
                jsonM.Status = "n";
            }
            return Json(jsonM);
        }

3、4 文件上传方法

/// <summary>
       /// 文件上传方法
       /// </summary>
       /// <param name="postedFile">文件流</param>
       /// <param name="isThumbnail">是否生成缩略图</param>
       /// <param name="isWater">是否生成水印</param>
       /// <returns>上传后文件信息</returns>
        private JsonHelper FileSaveAs(HttpPostedFileBase postedFile, bool isThumbnail, bool isWater)
        {
            var jsons = new JsonHelper { Status = "n" };
            try
            {
                string fileExt = Utils.GetFileExt(postedFile.FileName); //文件扩展名，不含“.”
                int fileSize = postedFile.ContentLength; //获得文件大小，以字节为单位
                string fileName = postedFile.FileName.Substring(postedFile.FileName.LastIndexOf(@"\") + 1); //取得原文件名
                string newFileName = Utils.GetRamCode() + "." + fileExt; //随机生成新的文件名
                string upLoadPath = GetUpLoadPath(fileExt); //上传目录相对路径
                string fullUpLoadPath = Utils.GetMapPath(upLoadPath); //上传目录的物理路径
                string newFilePath = upLoadPath + newFileName; //上传后的路径
                string newThumbnailFileName = "thumb_" + newFileName; //随机生成缩略图文件名

                //检查文件扩展名是否合法
                if (!CheckFileExt(fileExt))
                {
                    jsons.Msg = "不允许上传" + fileExt + "类型的文件！";
                    return jsons;
                }

                //检查文件大小是否合法
                if (!CheckFileSize(fileExt, fileSize))
                {
                    jsons.Msg = "文件超过限制的大小啦！";
                    return jsons;
                }

                //检查上传的物理路径是否存在，不存在则创建
                if (!Directory.Exists(fullUpLoadPath))
                {
                    Directory.CreateDirectory(fullUpLoadPath);
                }

                //检查文件是否真实合法
                //如果文件真实合法 则 保存文件 关闭文件流
                //if (!CheckFileTrue(postedFile, fullUpLoadPath + newFileName))
                //{
                //    jsons.Msg = "不允许上传不可识别的文件!";
                //    return jsons;
                //}

                //保存文件
                postedFile.SaveAs(fullUpLoadPath + newFileName);

                string thumbnail = string.Empty;

                //如果是图片，检查是否需要生成缩略图，是则生成
                if (IsImage(fileExt) && isThumbnail && ConfigurationManager.AppSettings["ThumbnailWidth"].ToString() != "0" && ConfigurationManager.AppSettings["ThumbnailHeight"].ToString() != "0")
                {
                    Thumbnail.MakeThumbnailImage(fullUpLoadPath + newFileName, fullUpLoadPath + newThumbnailFileName,
                       int.Parse(ConfigurationManager.AppSettings["ThumbnailWidth"]), int.Parse(ConfigurationManager.AppSettings["ThumbnailHeight"]), "W");
                    thumbnail = upLoadPath + newThumbnailFileName;
                }
                //如果是图片，检查是否需要打水印
                if (IsImage(fileExt) && isWater)
                {
                    switch (ConfigurationManager.AppSettings["WatermarkType"].ToString())
                    {
                        case "1":
                            WaterMark.AddImageSignText(newFilePath, newFilePath,
                                ConfigurationManager.AppSettings["WatermarkText"], int.Parse(ConfigurationManager.AppSettings["WatermarkPosition"]),
                                int.Parse(ConfigurationManager.AppSettings["WatermarkImgQuality"]), ConfigurationManager.AppSettings["WatermarkFont"], int.Parse(ConfigurationManager.AppSettings["WatermarkFontsize"]));
                            break;
                        case "2":
                            WaterMark.AddImageSignPic(newFilePath, newFilePath,
                                ConfigurationManager.AppSettings["WatermarkPic"], int.Parse(ConfigurationManager.AppSettings["WatermarkPosition"]),
                                int.Parse(ConfigurationManager.AppSettings["WatermarkImgQuality"]), int.Parse(ConfigurationManager.AppSettings["WatermarkTransparency"]));
                            break;
                    }
                }

                string unit = string.Empty;

                //处理完毕，返回JOSN格式的文件信息
                jsons.Data = "{\"oldname\": \"" + fileName + "\",";     //原始文件名
                jsons.Data += " \"newname\":\"" + newFileName + "\",";  //文件新名称
                jsons.Data += " \"path\": \"" + newFilePath + "\", ";   //文件路径
                jsons.Data += " \"thumbpath\":\"" + thumbnail + "\",";  //缩略图路径
                jsons.Data += " \"size\": \"" + fileSize + "\",";       //文件大小
                jsons.Data += "\"ext\":\"" + fileExt + "\"}";           //文件格式
                jsons.Status = "y";
                return jsons;
            }
            catch
            {
                jsons.Msg = "上传过程中发生意外错误！";
                return jsons;
            }
        }

3、5 缩略图 水印

 /// <summary>
    /// 缩略图构造类
    /// </summary>
    public class Thumbnail
    {
        private Image srcImage;
        private string srcFileName;

        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="FileName">原始图片路径</param>
        public bool SetImage(string FileName)
        {
            srcFileName = Utils.GetMapPath(FileName);
            try
            {
                srcImage = Image.FromFile(srcFileName);
            }
            catch
            {
                return false;
            }
            return true;

        }

        /// <summary>
        /// 回调
        /// </summary>
        /// <returns></returns>
        public bool ThumbnailCallback()
        {
            return false;
        }

        /// <summary>
        /// 生成缩略图,返回缩略图的Image对象
        /// </summary>
        /// <param name="Width">缩略图宽度</param>
        /// <param name="Height">缩略图高度</param>
        /// <returns>缩略图的Image对象</returns>
        public Image GetImage(int Width, int Height)
        {
            Image img;
            Image.GetThumbnailImageAbort callb = new Image.GetThumbnailImageAbort(ThumbnailCallback);
            img = srcImage.GetThumbnailImage(Width, Height, callb, IntPtr.Zero);
            return img;
        }

        /// <summary>
        /// 保存缩略图
        /// </summary>
        /// <param name="Width"></param>
        /// <param name="Height"></param>
        public void SaveThumbnailImage(int Width, int Height)
        {
            switch (Path.GetExtension(srcFileName).ToLower())
            {
                case ".png":
                    SaveImage(Width, Height, ImageFormat.Png);
                    break;
                case ".gif":
                    SaveImage(Width, Height, ImageFormat.Gif);
                    break;
                case ".bmp":
                    SaveImage(Width, Height, ImageFormat.Bmp);
                    break;
                default:
                    SaveImage(Width, Height, ImageFormat.Jpeg);
                    break;
            }
        }

        /// <summary>
        /// 生成缩略图并保存
        /// </summary>
        /// <param name="Width">缩略图的宽度</param>
        /// <param name="Height">缩略图的高度</param>
        /// <param name="imgformat">保存的图像格式</param>
        /// <returns>缩略图的Image对象</returns>
        public void SaveImage(int Width, int Height, ImageFormat imgformat)
        {
            if (imgformat != ImageFormat.Gif && (srcImage.Width > Width) || (srcImage.Height > Height))
            {
                Image img;
                Image.GetThumbnailImageAbort callb = new Image.GetThumbnailImageAbort(ThumbnailCallback);
                img = srcImage.GetThumbnailImage(Width, Height, callb, IntPtr.Zero);
                srcImage.Dispose();
                img.Save(srcFileName, imgformat);
                img.Dispose();
            }
        }

        #region Helper

        /// <summary>
        /// 保存图片
        /// </summary>
        /// <param name="image">Image 对象</param>
        /// <param name="savePath">保存路径</param>
        /// <param name="ici">指定格式的编解码参数</param>
        private static void SaveImage(Image image, string savePath, ImageCodecInfo ici)
        {
            //设置 原图片 对象的 EncoderParameters 对象
            EncoderParameters parameters = new EncoderParameters(1);
            parameters.Param[0] = new EncoderParameter(Encoder.Quality, ((long)100));
            image.Save(savePath, ici, parameters);
            parameters.Dispose();
        }

        /// <summary>
        /// 获取图像编码解码器的所有相关信息
        /// </summary>
        /// <param name="mimeType">包含编码解码器的多用途网际邮件扩充协议 (MIME) 类型的字符串</param>
        /// <returns>返回图像编码解码器的所有相关信息</returns>
        private static ImageCodecInfo GetCodecInfo(string mimeType)
        {
            ImageCodecInfo[] CodecInfo = ImageCodecInfo.GetImageEncoders();
            foreach (ImageCodecInfo ici in CodecInfo)
            {
                if (ici.MimeType == mimeType)
                    return ici;
            }
            return null;
        }

        /// <summary>
        /// 计算新尺寸
        /// </summary>
        /// <param name="width">原始宽度</param>
        /// <param name="height">原始高度</param>
        /// <param name="maxWidth">最大新宽度</param>
        /// <param name="maxHeight">最大新高度</param>
        /// <returns></returns>
        private static Size ResizeImage(int width, int height, int maxWidth, int maxHeight)
        {
            //此次2012-02-05修改过=================
            if (maxWidth <= 0)
                maxWidth = width;
            if (maxHeight <= 0)
                maxHeight = height;
            //以上2012-02-05修改过=================
            decimal MAX_WIDTH = (decimal)maxWidth;
            decimal MAX_HEIGHT = (decimal)maxHeight;
            decimal ASPECT_RATIO = MAX_WIDTH / MAX_HEIGHT;

            int newWidth, newHeight;
            decimal originalWidth = (decimal)width;
            decimal originalHeight = (decimal)height;

            if (originalWidth > MAX_WIDTH || originalHeight > MAX_HEIGHT)
            {
                decimal factor;
                // determine the largest factor 
                if (originalWidth / originalHeight > ASPECT_RATIO)
                {
                    factor = originalWidth / MAX_WIDTH;
                    newWidth = Convert.ToInt32(originalWidth / factor);
                    newHeight = Convert.ToInt32(originalHeight / factor);
                }
                else
                {
                    factor = originalHeight / MAX_HEIGHT;
                    newWidth = Convert.ToInt32(originalWidth / factor);
                    newHeight = Convert.ToInt32(originalHeight / factor);
                }
            }
            else
            {
                newWidth = width;
                newHeight = height;
            }
            return new Size(newWidth, newHeight);
        }

        /// <summary>
        /// 得到图片格式
        /// </summary>
        /// <param name="name">文件名称</param>
        /// <returns></returns>
        public static ImageFormat GetFormat(string name)
        {
            string ext = name.Substring(name.LastIndexOf(".") + 1);
            switch (ext.ToLower())
            {
                case "jpg":
                case "jpeg":
                    return ImageFormat.Jpeg;
                case "bmp":
                    return ImageFormat.Bmp;
                case "png":
                    return ImageFormat.Png;
                case "gif":
                    return ImageFormat.Gif;
                default:
                    return ImageFormat.Jpeg;
            }
        }
        #endregion

        /// <summary>
        /// 制作小正方形
        /// </summary>
        /// <param name="image">图片对象</param>
        /// <param name="newFileName">新地址</param>
        /// <param name="newSize">长度或宽度</param>
        public static void MakeSquareImage(Image image, string newFileName, int newSize)
        {
            int i = 0;
            int width = image.Width;
            int height = image.Height;
            if (width > height)
                i = height;
            else
                i = width;

            Bitmap b = new Bitmap(newSize, newSize);

            try
            {
                Graphics g = Graphics.FromImage(b);
                //设置高质量插值法
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                //设置高质量,低速度呈现平滑程度
                g.SmoothingMode = SmoothingMode.AntiAlias;
                g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                //清除整个绘图面并以透明背景色填充
                g.Clear(Color.Transparent);
                if (width < height)
                    g.DrawImage(image, new Rectangle(0, 0, newSize, newSize), new Rectangle(0, (height - width) / 2, width, width), GraphicsUnit.Pixel);
                else
                    g.DrawImage(image, new Rectangle(0, 0, newSize, newSize), new Rectangle((width - height) / 2, 0, height, height), GraphicsUnit.Pixel);

                SaveImage(b, newFileName, GetCodecInfo("image/" + GetFormat(newFileName).ToString().ToLower()));
            }
            finally
            {
                image.Dispose();
                b.Dispose();
            }
        }

        /// <summary>
        /// 制作小正方形
        /// </summary>
        /// <param name="fileName">图片文件名</param>
        /// <param name="newFileName">新地址</param>
        /// <param name="newSize">长度或宽度</param>
        public static void MakeSquareImage(string fileName, string newFileName, int newSize)
        {
            MakeSquareImage(Image.FromFile(fileName), newFileName, newSize);
        }

        /// <summary>
        /// 制作远程小正方形
        /// </summary>
        /// <param name="url">图片url</param>
        /// <param name="newFileName">新地址</param>
        /// <param name="newSize">长度或宽度</param>
        public static void MakeRemoteSquareImage(string url, string newFileName, int newSize)
        {
            Stream stream = GetRemoteImage(url);
            if (stream == null)
                return;
            Image original = Image.FromStream(stream);
            stream.Close();
            MakeSquareImage(original, newFileName, newSize);
        }

        /// <summary>
        /// 制作缩略图
        /// </summary>
        /// <param name="original">图片对象</param>
        /// <param name="newFileName">新图路径</param>
        /// <param name="maxWidth">最大宽度</param>
        /// <param name="maxHeight">最大高度</param>
        public static void MakeThumbnailImage(Image original, string newFileName, int maxWidth, int maxHeight)
        {
            Size _newSize = ResizeImage(original.Width, original.Height, maxWidth, maxHeight);

            using (Image displayImage = new Bitmap(original, _newSize))
            {
                try
                {
                    if (original.Width > maxWidth)
                    {
                        displayImage.Save(newFileName, original.RawFormat);
                    }
                }
                finally
                {
                    original.Dispose();
                }
            }
        }

        /// <summary>
        /// 制作缩略图
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="newFileName">新图路径</param>
        /// <param name="maxWidth">最大宽度</param>
        /// <param name="maxHeight">最大高度</param>
        public static void MakeThumbnailImage(string fileName, string newFileName, int maxWidth, int maxHeight)
        {
            //2012-02-05修改过，支持替换
            byte[] imageBytes = File.ReadAllBytes(fileName);
            Image img = Image.FromStream(new System.IO.MemoryStream(imageBytes));
            if (img.Width > maxWidth)
            {
                MakeThumbnailImage(img, newFileName, maxWidth, maxHeight);
            }
            //原文
            //MakeThumbnailImage(Image.FromFile(fileName), newFileName, maxWidth, maxHeight);
        }

        #region 2012-2-19 新增生成图片缩略图方法
        /// <summary>
        /// 生成缩略图
        /// </summary>
        /// <param name="fileName">源图路径（绝对路径）</param>
        /// <param name="newFileName">缩略图路径（绝对路径）</param>
        /// <param name="width">缩略图宽度</param>
        /// <param name="height">缩略图高度</param>
        /// <param name="mode">生成缩略图的方式</param>    
        public static bool MakeThumbnailImage(string fileName, string newFileName, int width, int height, string mode)
        {
            Image originalImage = Image.FromFile(fileName);
            int towidth = width;
            int toheight = height;

            int x = 0;
            int y = 0;
            int ow = originalImage.Width;
            int oh = originalImage.Height;

            if (ow > towidth)
            {
                switch (mode)
                {
                    case "HW"://指定高宽缩放（可能变形）                
                        break;
                    case "W"://指定宽，高按比例                    
                        toheight = originalImage.Height * width / originalImage.Width;
                        break;
                    case "H"://指定高，宽按比例
                        towidth = originalImage.Width * height / originalImage.Height;
                        break;
                    case "Cut"://指定高宽裁减（不变形）                
                        if ((double)originalImage.Width / (double)originalImage.Height > (double)towidth / (double)toheight)
                        {
                            oh = originalImage.Height;
                            ow = originalImage.Height * towidth / toheight;
                            y = 0;
                            x = (originalImage.Width - ow) / 2;
                        }
                        else
                        {
                            ow = originalImage.Width;
                            oh = originalImage.Width * height / towidth;
                            x = 0;
                            y = (originalImage.Height - oh) / 2;
                        }
                        break;
                    default:
                        break;
                }

                //新建一个bmp图片
                Bitmap b = new Bitmap(towidth, toheight);
                try
                {
                    //新建一个画板
                    Graphics g = Graphics.FromImage(b);
                    //设置高质量插值法
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    //设置高质量,低速度呈现平滑程度
                    g.SmoothingMode = SmoothingMode.AntiAlias;
                    g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    //清空画布并以透明背景色填充
                    g.Clear(Color.Transparent);
                    //在指定位置并且按指定大小绘制原图片的指定部分
                    g.DrawImage(originalImage, new Rectangle(0, 0, towidth, toheight), new Rectangle(x, y, ow, oh), GraphicsUnit.Pixel);

                    SaveImage(b, newFileName, GetCodecInfo("image/" + GetFormat(newFileName).ToString().ToLower()));
                }
                catch (System.Exception e)
                {
                    throw e;
                }
                finally
                {
                    originalImage.Dispose();
                    b.Dispose();
                }
                return true;
            }
            else
            {
                originalImage.Dispose();
                return false;
            }
        }
        #endregion

        #region 2012-10-30 新增图片裁剪方法
        /// <summary>
        /// 裁剪图片并保存
        /// </summary>
        /// <param name="fileName">源图路径（绝对路径）</param>
        /// <param name="newFileName">缩略图路径（绝对路径）</param>
        /// <param name="maxWidth">缩略图宽度</param>
        /// <param name="maxHeight">缩略图高度</param>
        /// <param name="cropWidth">裁剪宽度</param>
        /// <param name="cropHeight">裁剪高度</param>
        /// <param name="X">X轴</param>
        /// <param name="Y">Y轴</param>
        public static bool MakeThumbnailImage(string fileName, string newFileName, int maxWidth, int maxHeight, int cropWidth, int cropHeight, int X, int Y)
        {
            byte[] imageBytes = File.ReadAllBytes(fileName);
            Image originalImage = Image.FromStream(new System.IO.MemoryStream(imageBytes));
            Bitmap b = new Bitmap(cropWidth, cropHeight);
            try
            {
                using (Graphics g = Graphics.FromImage(b))
                {
                    //设置高质量插值法
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    //设置高质量,低速度呈现平滑程度
                    g.SmoothingMode = SmoothingMode.AntiAlias;
                    g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    //清空画布并以透明背景色填充
                    g.Clear(Color.Transparent);
                    //在指定位置并且按指定大小绘制原图片的指定部分
                    g.DrawImage(originalImage, new Rectangle(0, 0, cropWidth, cropWidth), X, Y, cropWidth, cropHeight, GraphicsUnit.Pixel);
                    Image displayImage = new Bitmap(b, maxWidth, maxHeight);
                    SaveImage(displayImage, newFileName, GetCodecInfo("image/" + GetFormat(newFileName).ToString().ToLower()));
                    return true;
                }
            }
            catch (System.Exception e)
            {
                throw e;
            }
            finally
            {
                originalImage.Dispose();
                b.Dispose();
            }
        }
        #endregion

        /// <summary>
        /// 制作远程缩略图
        /// </summary>
        /// <param name="url">图片URL</param>
        /// <param name="newFileName">新图路径</param>
        /// <param name="maxWidth">最大宽度</param>
        /// <param name="maxHeight">最大高度</param>
        public static void MakeRemoteThumbnailImage(string url, string newFileName, int maxWidth, int maxHeight)
        {
            Stream stream = GetRemoteImage(url);
            if (stream == null)
                return;
            Image original = Image.FromStream(stream);
            stream.Close();
            MakeThumbnailImage(original, newFileName, maxWidth, maxHeight);
        }

        /// <summary>
        /// 获取图片流
        /// </summary>
        /// <param name="url">图片URL</param>
        /// <returns></returns>
        private static Stream GetRemoteImage(string url)
        {
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
            request.Method = "GET";
            request.ContentLength = 0;
            request.Timeout = 20000;
            HttpWebResponse response = null;

            try
            {
                response = (HttpWebResponse)request.GetResponse();
                return response.GetResponseStream();
            }
            catch
            {
                return null;
            }
        }
    }
    /// <summary>
    /// 水印构造类
    /// </summary>
    public class WaterMark
    {
        /// <summary>
        /// 图片水印
        /// </summary>
        /// <param name="imgPath">服务器图片相对路径</param>
        /// <param name="filename">保存文件名</param>
        /// <param name="watermarkFilename">水印文件相对路径</param>
        /// <param name="watermarkStatus">图片水印位置 0=不使用 1=左上 2=中上 3=右上 4=左中  9=右下</param>
        /// <param name="quality">附加水印图片质量,0-100</param>
        /// <param name="watermarkTransparency">水印的透明度 1--10 10为不透明</param>
        public static void AddImageSignPic(string imgPath, string filename, string watermarkFilename, int watermarkStatus, int quality, int watermarkTransparency)
        {
            if (!File.Exists(Utils.GetMapPath(imgPath)))
                return;
            byte[] _ImageBytes = File.ReadAllBytes(Utils.GetMapPath(imgPath));
            Image img = Image.FromStream(new System.IO.MemoryStream(_ImageBytes));
            filename = Utils.GetMapPath(filename);

            if (watermarkFilename.StartsWith("/") == false)
                watermarkFilename = "/" + watermarkFilename;
            watermarkFilename = Utils.GetMapPath(watermarkFilename);
            if (!File.Exists(watermarkFilename))
                return;
            Graphics g = Graphics.FromImage(img);
            //设置高质量插值法
            //g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;
            //设置高质量,低速度呈现平滑程度
            //g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            Image watermark = new Bitmap(watermarkFilename);

            if (watermark.Height >= img.Height || watermark.Width >= img.Width)
                return;

            ImageAttributes imageAttributes = new ImageAttributes();
            ColorMap colorMap = new ColorMap();

            colorMap.OldColor = Color.FromArgb(255, 0, 255, 0);
            colorMap.NewColor = Color.FromArgb(0, 0, 0, 0);
            ColorMap[] remapTable = { colorMap };

            imageAttributes.SetRemapTable(remapTable, ColorAdjustType.Bitmap);

            float transparency = 0.5F;
            if (watermarkTransparency >= 1 && watermarkTransparency <= 10)
                transparency = (watermarkTransparency / 10.0F);


            float[][] colorMatrixElements = {
                                                new float[] {1.0f,  0.0f,  0.0f,  0.0f, 0.0f},
                                                new float[] {0.0f,  1.0f,  0.0f,  0.0f, 0.0f},
                                                new float[] {0.0f,  0.0f,  1.0f,  0.0f, 0.0f},
                                                new float[] {0.0f,  0.0f,  0.0f,  transparency, 0.0f},
                                                new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}
                                            };

            ColorMatrix colorMatrix = new ColorMatrix(colorMatrixElements);

            imageAttributes.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);

            int xpos = 0;
            int ypos = 0;

            switch (watermarkStatus)
            {
                case 1:
                    xpos = (int)(img.Width * (float).01);
                    ypos = (int)(img.Height * (float).01);
                    break;
                case 2:
                    xpos = (int)((img.Width * (float).50) - (watermark.Width / 2));
                    ypos = (int)(img.Height * (float).01);
                    break;
                case 3:
                    xpos = (int)((img.Width * (float).99) - (watermark.Width));
                    ypos = (int)(img.Height * (float).01);
                    break;
                case 4:
                    xpos = (int)(img.Width * (float).01);
                    ypos = (int)((img.Height * (float).50) - (watermark.Height / 2));
                    break;
                case 5:
                    xpos = (int)((img.Width * (float).50) - (watermark.Width / 2));
                    ypos = (int)((img.Height * (float).50) - (watermark.Height / 2));
                    break;
                case 6:
                    xpos = (int)((img.Width * (float).99) - (watermark.Width));
                    ypos = (int)((img.Height * (float).50) - (watermark.Height / 2));
                    break;
                case 7:
                    xpos = (int)(img.Width * (float).01);
                    ypos = (int)((img.Height * (float).99) - watermark.Height);
                    break;
                case 8:
                    xpos = (int)((img.Width * (float).50) - (watermark.Width / 2));
                    ypos = (int)((img.Height * (float).99) - watermark.Height);
                    break;
                case 9:
                    xpos = (int)((img.Width * (float).99) - (watermark.Width));
                    ypos = (int)((img.Height * (float).99) - watermark.Height);
                    break;
            }

            g.DrawImage(watermark, new Rectangle(xpos, ypos, watermark.Width, watermark.Height), 0, 0, watermark.Width, watermark.Height, GraphicsUnit.Pixel, imageAttributes);

            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo ici = null;
            foreach (ImageCodecInfo codec in codecs)
            {
                if (codec.MimeType.IndexOf("jpeg") > -1)
                    ici = codec;
            }
            EncoderParameters encoderParams = new EncoderParameters();
            long[] qualityParam = new long[1];
            if (quality < 0 || quality > 100)
                quality = 80;

            qualityParam[0] = quality;

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

            if (ici != null)
                img.Save(filename, ici, encoderParams);
            else
                img.Save(filename);

            g.Dispose();
            img.Dispose();
            watermark.Dispose();
            imageAttributes.Dispose();
        }

        /// <summary>
        /// 文字水印
        /// </summary>
        /// <param name="imgPath">服务器图片相对路径</param>
        /// <param name="filename">保存文件名</param>
        /// <param name="watermarkText">水印文字</param>
        /// <param name="watermarkStatus">图片水印位置 0=不使用 1=左上 2=中上 3=右上 4=左中  9=右下</param>
        /// <param name="quality">附加水印图片质量,0-100</param>
        /// <param name="fontname">字体</param>
        /// <param name="fontsize">字体大小</param>
        public static void AddImageSignText(string imgPath, string filename, string watermarkText, int watermarkStatus, int quality, string fontname, int fontsize)
        {
            byte[] _ImageBytes = File.ReadAllBytes(Utils.GetMapPath(imgPath));
            Image img = Image.FromStream(new System.IO.MemoryStream(_ImageBytes));
            filename = Utils.GetMapPath(filename);

            Graphics g = Graphics.FromImage(img);
            Font drawFont = new Font(fontname, fontsize, FontStyle.Regular, GraphicsUnit.Pixel);
            SizeF crSize;
            crSize = g.MeasureString(watermarkText, drawFont);

            float xpos = 0;
            float ypos = 0;

            switch (watermarkStatus)
            {
                case 1:
                    xpos = (float)img.Width * (float).01;
                    ypos = (float)img.Height * (float).01;
                    break;
                case 2:
                    xpos = ((float)img.Width * (float).50) - (crSize.Width / 2);
                    ypos = (float)img.Height * (float).01;
                    break;
                case 3:
                    xpos = ((float)img.Width * (float).99) - crSize.Width;
                    ypos = (float)img.Height * (float).01;
                    break;
                case 4:
                    xpos = (float)img.Width * (float).01;
                    ypos = ((float)img.Height * (float).50) - (crSize.Height / 2);
                    break;
                case 5:
                    xpos = ((float)img.Width * (float).50) - (crSize.Width / 2);
                    ypos = ((float)img.Height * (float).50) - (crSize.Height / 2);
                    break;
                case 6:
                    xpos = ((float)img.Width * (float).99) - crSize.Width;
                    ypos = ((float)img.Height * (float).50) - (crSize.Height / 2);
                    break;
                case 7:
                    xpos = (float)img.Width * (float).01;
                    ypos = ((float)img.Height * (float).99) - crSize.Height;
                    break;
                case 8:
                    xpos = ((float)img.Width * (float).50) - (crSize.Width / 2);
                    ypos = ((float)img.Height * (float).99) - crSize.Height;
                    break;
                case 9:
                    xpos = ((float)img.Width * (float).99) - crSize.Width;
                    ypos = ((float)img.Height * (float).99) - crSize.Height;
                    break;
            }

            g.DrawString(watermarkText, drawFont, new SolidBrush(Color.White), xpos + 1, ypos + 1);
            g.DrawString(watermarkText, drawFont, new SolidBrush(Color.Yellow), xpos, ypos);

            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo ici = null;
            foreach (ImageCodecInfo codec in codecs)
            {
                if (codec.MimeType.IndexOf("jpeg") > -1)
                    ici = codec;
            }
            EncoderParameters encoderParams = new EncoderParameters();
            long[] qualityParam = new long[1];
            if (quality < 0 || quality > 100)
                quality = 80;

            qualityParam[0] = quality;

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

            if (ici != null)
                img.Save(filename, ici, encoderParams);
            else
                img.Save(filename);

            g.Dispose();
            img.Dispose();
        }
    }

3、6 通过路径获取文件方法

/// <summary>
        /// 通过路径获取文件
        /// </summary>
        /// <returns></returns>
        public ActionResult GetFileData()
        {
            string path = Request.Form["path"];
            var jsonM = new JsonHelper() { Status = "y", Msg = "success" };
            try
            {
                if (!FileHelper.IsExistDirectory(Server.MapPath(path)))
                {
                    jsonM.Status = "n";
                    jsonM.Msg = "目录不存在！";
                }
                else if (FileHelper.IsEmptyDirectory(Server.MapPath(path)))
                {
                    jsonM.Status = "empty";
                }
                else
                {
                    jsonM.Data = Common.Utils.DataTableToList<FileModel>(FileHelper.GetFileTable(Server.MapPath(path))).OrderByDescending(p => p.name).ToList();
                }
            }
            catch (Exception)
            {
                jsonM.Status = "err";
                jsonM.Msg = "获取文件失败！";
            }
            return Content(JsonConverter.Serialize(jsonM, true));
        }

3.8 FileHelper中的获取文件的方法

 /// <summary>
        /// 读取指定位置文件列表到集合中
        /// </summary>
        /// <param name="Path">指定路径</param>
        /// <returns></returns>
        public static DataTable GetFileTable(string Path)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add("name", typeof(string));
            dt.Columns.Add("ext", typeof(string));
            dt.Columns.Add("size", typeof(string));
            dt.Columns.Add("icon", typeof(string));
            dt.Columns.Add("isfolder", typeof(bool));
            dt.Columns.Add("isImage", typeof(bool));
            dt.Columns.Add("fullname", typeof(string));
            dt.Columns.Add("path", typeof(string));
            dt.Columns.Add("time", typeof(DateTime));

            DirectoryInfo dirinfo = new DirectoryInfo(Path);
            FileInfo fi;
            DirectoryInfo dir;
            string FileName = string.Empty, FileExt = string.Empty, FileSize = string.Empty, FileIcon = string.Empty, FileFullName = string.Empty, FilePath = string.Empty;
            bool IsFloder = false, IsImage = false;
            DateTime FileModify;
            try
            {
                foreach (FileSystemInfo fsi in dirinfo.GetFileSystemInfos())
                {
                    if (fsi is FileInfo)
                    {
                        fi = (FileInfo)fsi;
                        //获取文件名称
                        FileName = fi.Name.Substring(0, fi.Name.LastIndexOf('.'));
                        FileFullName = fi.Name;
                        //获取文件扩展名
                        FileExt = fi.Extension;
                        //获取文件大小
                        FileSize = GetDiyFileSize(fi);
                        //获取文件最后修改时间
                        FileModify = fi.LastWriteTime;
                        //文件图标
                        FileIcon = GetFileIcon(FileExt);
                        //是否为图片
                        IsImage = IsImageFile(FileExt.Substring(1, FileExt.Length - 1));
                        //文件路径
                        FilePath = urlconvertor(fi.FullName);
                    }
                    else
                    {
                        dir = (DirectoryInfo)fsi;
                        //获取目录名
                        FileName = dir.Name;
                        //获取目录最后修改时间
                        FileModify = dir.LastWriteTime;
                        //设置目录文件为文件夹
                        FileExt = "folder";
                        //文件夹图标
                        FileIcon = "fa fa-folder";
                        IsFloder = true;
                        //文件路径
                        FilePath = urlconvertor(dir.FullName);

                    }
                    DataRow dr = dt.NewRow();
                    dr["name"] = FileName;
                    dr["fullname"] = FileFullName;
                    dr["ext"] = FileExt;
                    dr["size"] = FileSize;
                    dr["time"] = FileModify;
                    dr["icon"] = FileIcon;
                    dr["isfolder"] = IsFloder;
                    dr["isImage"] = IsImage;
                    dr["path"] = FilePath;
                    dt.Rows.Add(dr);
                }
            }
            catch (Exception e)
            {

                throw e;
            }
            return dt;
        }

 

 

原创文章 转载请尊重劳动成果 http://yuangang.cnblogs.com