C#中实现ftp图片上传功能的方法是什么

public class ImageModel:BaseEntity { /// <summary> /// 用户Id /// </summary> public int ID { get; set; } /// <summary> ///身份证正面相对路径 /// </summary> public string IDProofFront { get; set; } /// <summary> ///身份证背面相对路径 /// </summary> public string IDProofBack { get; set; } }

public abstract partial class BaseEntity { public override bool Equals(object obj) { return Equals(obj as BaseEntity); } private Type GetUnproxiedType() { return GetType(); } public virtual bool Equals(BaseEntity other) { if (other == null) return false; if (ReferenceEquals(this, other)) return true; return false; } public override int GetHashCode() { return base.GetHashCode(); } public static bool operator ==(BaseEntity x, BaseEntity y) { return Equals(x, y); } public static bool operator !=(BaseEntity x, BaseEntity y) { return !(x == y); } }

<form enctype="multipart/form-data" id="form" action="/Home/UpLoadImage" method="post"> <p class="full_w" style="margin-top: 100px; margin-left: 30%; width: 800px;"> <p class="h_title"> <b>用户上传的文件</b></p> <p class="entry"> 步骤： <span class="red" style="color: red">(上传资料必须是bmp,gif,jpg,jpeg,png类型,不能大于2M)</span> <ol> <li>先按『选择』键选择上传文件；</li> <li>按『上传』键上传文件；</li> <li>按『保存』键保存文件；</li> </ol> </p> <p class="entry"> <p class="sep"></p> </p> <p class="entry"> <p id="wrapper" style="text-align: center; position: relative;"> <p class="form-group"> <input id="uploadfile" type="file" value="浏览..." class="file" name="FileName" data-upload-url="#" style="position: absolute; top: 0; right: 0; min-width: 100%; min-height: 100%; text-align: right; opacity: 0; background: none repeat scroll 0 0 transparent; cursor: inherit; display: block;" /> </p> </p> </p> <table> <tbody> <tr> <td class="entry">身份证正面</td> <td> @if (Model == null || Model.ID == null || string.IsNullOrEmpty(Model.IDProofFront)) { <a href="javascript:void(0);" rel="external nofollow" rel="external nofollow" target="_blank" class="winView"> <img style="border: none; width: 150px; height: 100px" src="/img/noupload.png" /> </a> } else { <a href="@(ViewBag.pathSrc + Model.IDProofFront)" rel="external nofollow" target="_blank"class="winView" > <img style="border: none; width: 150px; height: 100px" src="@(ViewBag.pathSrc + Model.IDProofFront)" /> </a> } @Html.HiddenFor(m => m.IDProofFront) @Html.HiddenFor(m => m.ID) </td> <td> <a href="javascript:void(0)" rel="external nofollow" rel="external nofollow" class="easyui-linkbutton btnFinleUP" data-op="1" data-type="image">上传</a> </td> </tr> <tr> <td class="entry">身份证背面</td> <span id="lblinfosi" style="color: Green"></span> <td> @if (Model == null || Model.ID == null || string.IsNullOrEmpty(Model.IDProofBack)) { <a href="javascript:void(0);" rel="external nofollow" rel="external nofollow" target="_blank" class="winView"> <img style="border: none; width: 150px; height: 100px" src="/img/noupload.png" /> </a> } else { <a href="@(ViewBag.pathSrc + Model.IDProofBack)" rel="external nofollow" target="_blank" class="winView" > <img style="border: none; width: 150px; height: 100px" src="@(ViewBag.pathSrc + Model.IDProofBack)" /> </a> } @Html.HiddenFor(m => m.IDProofBack) </td> <td> <a href="javascript:void(0)" rel="external nofollow" rel="external nofollow" class="easyui-linkbutton btnFinleUP" data-op="2" data-type="image">上传</a> </td> </tr> </tbody> </table> <p class="entry"> <button class="button" name="btnSaveAll" value="保存" id="btnSaveAll" style="height: 30px; width: 80px; text-align: center;">保存</button> <a href="/Home/Index" rel="external nofollow" style="height: 30px; text-align: center; width: 80px; background: #ffffff; border: 1px solid #DCDCDC; border-radius: 2px; color: #444444; cursor: pointer; display: inline-block; font: 700 11px Tahoma, Arial, sans-serif; margin-right: 10px; padding: 7px 12px 7px 12px; position: relative; text-decoration: none; text-shadow: 0px 1px 0px #FFFFFF;">返回</a> </p> </p> </form>

/*! * FileInput Chinese Translations * * This file must be loaded after 'fileinput.js'. Patterns in braces '{}', or * any HTML markup tags in the messages must not be converted or translated. * * @see http://github.com/kartik-v/bootstrap-fileinput * @author kangqf <kangqingfei@gmail.com> * * NOTE: this file must be saved in UTF-8 encoding. */ (function ($) { "use strict"; $.fn.fileinputLocales['zh'] = { fileSingle: '文件', filePlural: '个文件', browseLabel: '选择 …', removeLabel: '移除', removeTitle: '清除选中文件', cancelLabel: '取消', cancelTitle: '取消进行中的上传', uploadLabel: '上传', uploadTitle: '上传选中文件', msgNo: '没有', msgNoFilesSelected: '', msgCancelled: '取消', msgZoomModalHeading: '详细预览', msgSizeTooSmall: 'File "{name}" (<b>{size} KB</b>) is too small and must be larger than <b>{minSize} KB</b>.', msgSizeTooLarge: '文件 "{name}" (<b>{size} KB</b>) 超过了允许大小 <b>{maxSize} KB</b>.', msgFilesTooLess: '你必须选择最少 <b>{n}</b> {files} 来上传. ', msgFilesTooMany: '选择的上传文件个数 <b>({n})</b> 超出最大文件的限制个数 <b>{m}</b>.', msgFileNotFound: '文件 "{name}" 未找到!', msgFileSecured: '安全限制，为了防止读取文件 "{name}".', msgFileNotReadable: '文件 "{name}" 不可读.', msgFilePreviewAborted: '取消 "{name}" 的预览.', msgFilePreviewError: '读取 "{name}" 时出现了一个错误.', msgInvalidFileName: 'Invalid or unsupported characters in file name "{name}".', msgInvalidFileType: '不正确的类型 "{name}". 只支持 "{types}" 类型的文件.', msgInvalidFileExtension: '不正确的文件扩展名 "{name}". 只支持 "{extensions}" 的文件扩展名.', msgFileTypes: { 'image': 'image', 'html': 'HTML', 'text': 'text', 'video': 'video', 'audio': 'audio', 'flash': 'flash', 'pdf': 'PDF', 'object': 'object' }, msgUploadAborted: '该文件上传被中止', msgUploadThreshold: 'Processing...', msgUploadEmpty: 'No valid data available for upload.', msgValidationError: '验证错误', msgLoading: '加载第 {index} 文件共 {files} …', msgProgress: '加载第 {index} 文件共 {files} - {name} - {percent}% 完成.', msgSelected: '{n} {files} 选中', msgFoldersNotAllowed: '只支持拖拽文件! 跳过 {n} 拖拽的文件夹.', msgImageWidthSmall: '宽度的图像文件的"{name}"的必须是至少{size}像素.', msgImageHeightSmall: '图像文件的"{name}"的高度必须至少为{size}像素.', msgImageWidthLarge: '宽度的图像文件"{name}"不能超过{size}像素.', msgImageHeightLarge: '图像文件"{name}"的高度不能超过{size}像素.', msgImageResizeError: '无法获取的图像尺寸调整。', msgImageResizeException: '错误而调整图像大小。<pre>{errors}</pre>', msgAjaxError: 'Something went wrong with the {operation} operation. Please try again later!', msgAjaxProgressError: '{operation} failed', ajaxOperations: { deleteThumb: 'file delete', uploadThumb: 'single file upload', uploadBatch: 'batch file upload', uploadExtra: 'form data upload' }, dropZoneTitle: '拖拽文件到这里 …<br>支持多文件同时上传', dropZoneClickTitle: '<br>(或点击{files}按钮选择文件)', fileActionSettings: { removeTitle: '删除文件', uploadTitle: '上传文件', zoomTitle: '查看详情', dragTitle: '移动 / 重置', indicatorNewTitle: '没有上传', indicatorSuccessTitle: '上传', indicatorErrorTitle: '上传错误', indicatorLoadingTitle: '上传 ...' }, previewZoomButtonTitles: { prev: '预览上一个文件', next: '预览下一个文件', toggleheader: '缩放', fullscreen: '全屏', borderless: '无边界模式', close: '关闭当前预览' } }; })(window.jQuery);

//上传控件初始化 function initFileUpload() { $("#uploadfile").fileinput({ //uploadExtraData: { kvId: '10' }, language: 'zh', //设置语言 showUpload: false, //是否显示上传按钮 uploadAsync: true, //默认异步上传 showRemove: false, autoReplace: true, maxFileCount: 1, maxFileSize: 10240, dropZoneTitle: '拖拽文件到这里 …<br>仅限.pdf, .jpg, .jpeg, .gif', enctype: 'multipart/form-data', fileActionSettings: { uploadClass: "hidden", zoomClass: "hidden", removeClass: "hidden" }, allowedFileExtensions: ['jpg', 'png', 'gif', 'pdf'],//接收的文件后缀 msgFilesTooMany: "选择上传的文件数量({n}) 超过允许的最大数值{m}！", uploadUrl: "/FileUpload/FileUpLoad", //上传的地址 }).on("filebatchselected", function (event, files) { $(".file-preview-success").remove(); }) $("#uploadfile").on("fileuploaded", function (event, data, previewId, index) { console.log("accountData 初始化后 FileOpt" + accountData); console.log("accountData.FileOpt " + accountData.FileOpt); var obj = data.response; if (obj.Status != 500 && obj.Data != undefined) { var src = accountData.PathSrc + obj.Data.FileName; showName = obj.Data.FileName; //alert(showName); var pId = accountData.PId; var fileObj = undefined; var field = ""; var isPdf = false; debugger; if (accountData.FileOpt == 1) { fileObj = $("#IDProofFront"); //$("#PersonInfo_OldIDFile").val(obj.Data.FileName); field = "IDProofFront"; fileObj.val(obj.Data.FileName); } else if (accountData.FileOpt == 2) { fileObj = $("#IDProofBack"); field = "IDProofBack"; $("#IDProofBack").val(showName); fileObj.val(obj.Data.FileName); } //fileObj = $("#IDProofFront"); //$("#IDProofFront").val(obj.Data.FileName); //field = "IDProofFront"; //fileObj.val(obj.Data.FileName); fileObj.prev().attr("href", src); src = isPdf == true ? "/Content/images/PDF.png" : src; fileObj.prev().find("img").attr("src", src); } else { console.error(obj.Data); } }); $('#uploadfile').on('filesuccessremove', function (event, id) { }); $('#uploadfile').on('fileerror', function (event, data, msg) { }); //上传 $(".btnFinleUP").click(function () { var fileName = $("#uploadfile").val(); var obj = document.getElementById("uploadfile"); var type = $(this).attr("data-op"); //alert("当前点击的type是：" + type); var fileType = $(this).attr("data-type"); var files = $("#uploadfile").fileinput("getFileStack"); if (files.length == 0) { layer.msg('请选择要上传的文件', function () { }); return; } var array = fileType.split(","); var selectType = files[0].type.toLowerCase(); var falg = false; for (var i = 0; i < array.length; i++) { if (selectType.indexOf(array[i]) == -1) { falg = false; } else falg = true; if (falg) break; } if (!falg) { layer.msg('只能选择' + fileType + ' 类型的文件', function () { }); return; } accountData.FileOpt = type; $("#uploadfile").fileinput("upload"); }); }

/// <summary> /// 通过ftp上传指定服务器 /// </summary> /// <returns></returns> public ActionResult FileUpLoad() { bool flag = false; string msg = string.Empty; int size = Convert.ToInt16(_fileSize) * 1024 * 1024; try { Dictionary<string, string> fileDict = new Dictionary<string, string>(); for (int i = 0; i < Request.Files.Count; i++) { HttpPostedFileBase file = Request.Files[i]; string extension = Path.GetExtension(file.FileName); string[] fileExtensions = _fileExtension.Split(';'); if (fileExtensions.Any(o => o.Equals(extension, StringComparison.OrdinalIgnoreCase))) { if (file.ContentLength <= size) { string fileName = string.Format("{0}_{1}", DateTime.Now.ToString("yyyyMMddHHmmssfff"), Path.GetFileName(file.FileName)); if (file.ContentLength <= 10 * 1024 * 1024) { byte[] buffer = new byte[file.ContentLength]; file.InputStream.Read(buffer, 0, file.ContentLength); flag = FileUpLoad(buffer, file.FileName, out fileName, out msg); } else//图片压缩有问题>> { var stream = ImageHelper.GetPicThumbnail(file.InputStream, 40); byte[] buffer = new byte[stream.Length]; stream.Read(buffer, 0, (int)stream.Length); flag = FileUpLoad(buffer, file.FileName, out fileName, out msg); } fileDict.Add(Request.Files.AllKeys[i], fileName); } else { msg = string.Format("上传文件不能大于{0}M", _fileSize); } } else { msg = string.Format("上传的文件类型不正确"); } } return Json(new { Result = "0", MSG = "" + msg, Data = fileDict }); } catch (Exception ex) { return Json(new { Result = "0", MSG = "网络异常，请稍后再试" }); } }

private static string _fileExtension = ConfigurationManager.AppSettings["FileType"]; private readonly string _filePath = ConfigurationManager.AppSettings["UploadPath"]; private readonly string _fileSize = ConfigurationManager.AppSettings["FileSizem"];

/// <summary> /// 上传文件 /// </summary> /// <param name="fileBytes"></param> /// <param name="originalName"></param> /// <param name="msg"></param> /// <returns></returns> protected bool FileUpLoad(byte[] fileBytes, string originalName, out string newFileName, out string msg) { msg = ""; newFileName = ""; try { FTPUpFile ftp = new FTPUpFile(); newFileName = ftp.UpFile(fileBytes, originalName); if (string.IsNullOrEmpty(newFileName)) { msg = "上传文件时出错！"; return false; } return true; } catch (Exception ex) { msg = ex.Message; return false; } }

/// <summary> /// FTP上传文件 /// </summary> public class FTPUpFile { string Filetype = ConfigurationManager.AppSettings["FileType"]; string ipaddress = ConfigurationManager.AppSettings["IPaddress"]; string Username = ConfigurationManager.AppSettings["UserName"]; string Password = ConfigurationManager.AppSettings["Password"]; /// <summary> /// FTP上传文件 /// </summary> /// <param name="filename">上传文件路径</param> /// <param name="ftpServerIP">FTP服务器的IP和端口</param> /// <param name="ftpPath">FTP服务器下的哪个目录</param> /// <param name="ftpUserID">FTP用户名</param> /// <param name="ftpPassword">FTP密码</param> public bool Upload(string filename, string ftpServerIP, string ftpPath, string ftpUserID, string ftpPassword) { FileInfo fileInf = new FileInfo(filename); string uri = "ftp://" + ftpServerIP + "/" + ftpPath + "/" + fileInf.Name; try { FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri)); // ftp用户名和密码 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword); reqFTP.KeepAlive = false; // 指定执行什么命令 reqFTP.Method = WebRequestMethods.Ftp.UploadFile; // 指定数据传输类型 reqFTP.UseBinary = true; // 上传文件时通知服务器文件的大小 reqFTP.ContentLength = fileInf.Length; //this.Invoke(InitUProgress, fileInf.Length); // 缓冲大小设置为2kb int buffLength = 4096; byte[] buff = new byte[buffLength]; int contentLen; // 打开一个文件流 (System.IO.FileStream) 去读上传的文件 FileStream fs = fileInf.OpenRead(); // 把上传的文件写入流 Stream strm = reqFTP.GetRequestStream(); contentLen = fs.Read(buff, 0, buffLength); while (contentLen != 0) { strm.Write(buff, 0, contentLen); contentLen = fs.Read(buff, 0, buffLength); } // 关闭两个流 strm.Close(); strm.Dispose(); fs.Close(); fs.Dispose(); return true; } catch (Exception ex) { return false; } } /// <summary> /// 新建目录 /// </summary> /// <param name="ftpPath"></param> /// <param name="dirName"></param> public void MakeDir(string ftpPath, string dirName, string username, string password) { try { //实例化FTP连接 FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpPath + dirName)); // ftp用户名和密码 request.Credentials = new NetworkCredential(username, password); // 默认为true，连接不会被关闭 request.KeepAlive = false; //指定FTP操作类型为创建目录 request.Method = WebRequestMethods.Ftp.MakeDirectory; //获取FTP服务器的响应 FtpWebResponse response = (FtpWebResponse)request.GetResponse(); response.Close(); } catch (Exception ex) { //Respons } } /// <summary> /// 删除指定文件 /// </summary> /// <param name="ftpPath"></param> /// <param name="dirName"></param> /// <param name="username"></param> /// <param name="password"></param> public void DeleteFile(string ftpPath, string username, string password) { try { // string uri = "ftp://" + ftpServerIP + "/" + ftpPath + "/" + fileInf.Name; //ftpPath = "ftp://192.168.1.111:2005/2012-12-05/20121206O5CATICE.docx"; //password = "111"; //username = "yuanluluoli"; //实例化FTP连接 FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpPath)); request.Method = WebRequestMethods.Ftp.DeleteFile; // ftp用户名和密码 request.Credentials = new NetworkCredential(username, password); // 默认为true，连接不会被关闭 request.KeepAlive = false; //获取FTP服务器的响应 FtpWebResponse response = (FtpWebResponse)request.GetResponse(); response.Close(); } catch (Exception ex) { //Respons } } /// <summary> /// 检查目录是否存在 /// </summary> /// <param name="ftpPath">要检查的目录的路径</param> /// <param name="dirName">要检查的目录名</param> /// <returns>存在返回true，否则false</returns> public bool CheckDirectoryExist(string ftpPath, string dirName, string username, string password) { bool result = false; try { //实例化FTP连接 FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpPath)); // ftp用户名和密码 request.Credentials = new NetworkCredential(username, password); request.KeepAlive = false; //指定FTP操作类型为创建目录 request.Method = WebRequestMethods.Ftp.ListDirectoryDetails; //获取FTP服务器的响应 FtpWebResponse response = (FtpWebResponse)request.GetResponse(); StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.Default); StringBuilder str = new StringBuilder(); string line = sr.ReadLine(); while (line != null) { str.Append(line); str.Append("|"); line = sr.ReadLine(); } string[] datas = str.ToString().Split('|'); for (int i = 0; i < datas.Length; i++) { if (datas[i].Contains("<DIR>")) { int index = datas[i].IndexOf("<DIR>"); string name = datas[i].Substring(index + 5).Trim(); if (name == dirName) { result = true; break; } } } sr.Close(); sr.Dispose(); response.Close(); } catch (Exception) { return false; } return result; } /// <summary> /// 上传文件 /// </summary> /// <param name="buffer">文件的Byte数组</param> /// <param name="originalName">文件原始名字(带后缀名)</param> /// <param name="perStr">新文件名的前缀</param> /// <returns></returns> public string UpFile(byte[] buffer, string originalName, string perStr = "") { if (buffer == null || buffer.Length <= 0 || string.IsNullOrEmpty(originalName)) throw new ArgumentException("参数错误！"); string filePathstr = string.Empty; string filepathsql = null; try { string pathstr = perStr + DateTime.Now.ToString().Replace("/", "").Replace("-", "").Replace(":", "").Replace(" ", ""); string rodumlist = GeneralHelper.GetMixPwd(10);//10位随机数 filePathstr = "~/File/" + pathstr + rodumlist + Path.GetExtension(originalName); //Stream sr = upfile.PostedFile.InputStream; //byte[] file = new byte[sr.Length]; //sr.Read(file, 0, file.Length); StreamWriter sw = new StreamWriter(HttpContext.Current.Server.MapPath(filePathstr)); sw.BaseStream.Write(buffer, 0, buffer.Length); sw.Flush(); sw.Close(); // file.SaveAs(HttpContext.Current.Server.MapPath(filePathstr));//把文件上传到服务器的绝对路径上 bool check; string ftpPath = DateTime.Now.ToString("yyyy-MM-dd"); string uri = @"ftp://" + ipaddress + "/"; //检查是否存在此目录文件夹 if (CheckDirectoryExist(uri, ftpPath, Username, Password)) { //存在此文件夹就直接上传 check = Upload(HttpContext.Current.Server.MapPath(filePathstr), ipaddress, ftpPath, Username, Password); } else { MakeDir(uri, ftpPath, Username, Password);//创建 check = Upload(HttpContext.Current.Server.MapPath(filePathstr), ipaddress, ftpPath, Username, Password); } //成功就更新 if (check) { filepathsql = ftpPath + "/" + pathstr + rodumlist + Path.GetExtension(originalName); } //检查是否存在此文件 if (File.Exists(HttpContext.Current.Server.MapPath(filePathstr))) { File.Delete(HttpContext.Current.Server.MapPath(filePathstr)); } return filepathsql; } catch (Exception ex) { File.Delete(HttpContext.Current.Server.MapPath(filePathstr)); throw ex; } } /// <summary> /// 上传文件 /// 不修改名字及后缀名 /// </summary> /// <param name="originalFilePath">上传文件的绝对路径</param> /// <returns></returns> public string UpFile(string originalFilePath) { if (string.IsNullOrEmpty(originalFilePath)) throw new ArgumentException("参数错误！"); string filepathsql = null; try { //检查是否存在此文件 if (!File.Exists(originalFilePath)) throw new Exception("文件不存在！"); //Stream sr = upfile.PostedFile.InputStream; //byte[] file = new byte[sr.Length]; //sr.Read(file, 0, file.Length); // file.SaveAs(HttpContext.Current.Server.MapPath(filePathstr));//把文件上传到服务器的绝对路径上 bool check; string ftpPath = DateTime.Now.ToString("yyyy-MM-dd"); string uri = @"ftp://" + ipaddress + "/"; //检查是否存在此目录文件夹 if (CheckDirectoryExist(uri, ftpPath, Username, Password)) { //存在此文件夹就直接上传 check = Upload(originalFilePath, ipaddress, ftpPath, Username, Password); } else { MakeDir(uri, ftpPath, Username, Password);//创建 check = Upload(originalFilePath, ipaddress, ftpPath, Username, Password); } //成功就更新 if (check) { filepathsql = ftpPath + "/" + Path.GetFileName(originalFilePath); } //检查是否存在此文件 if (File.Exists(originalFilePath)) { File.Delete(originalFilePath); } return filepathsql; } catch (Exception ex) { //File.Delete(originalFilePath); throw ex; } } public string Ftp_Up(HtmlInputFile upfile) { //Encrypt En = new Encrypt(); string filePathstr = string.Empty; string filepathsql = null; try { string pathstr = DateTime.Now.ToString().Replace("/", "").Replace("-", "").Replace(":", "").Replace(" ", ""); string rodumlist = GeneralHelper.GetMixPwd(10);//10位随机数 filePathstr = "~/File/" + pathstr + rodumlist + Path.GetExtension(upfile.PostedFile.FileName); Stream sr = upfile.PostedFile.InputStream; byte[] file = new byte[sr.Length]; sr.Read(file, 0, file.Length); StreamWriter sw = new StreamWriter(HttpContext.Current.Server.MapPath(filePathstr)); sw.BaseStream.Write(file, 0, file.Length); sw.Flush(); sw.Close(); sr.Flush(); sr.Close(); // file.SaveAs(HttpContext.Current.Server.MapPath(filePathstr));//把文件上传到服务器的绝对路径上 bool check; string ftpPath = DateTime.Now.ToString("yyyy-MM-dd"); string uri = @"ftp://" + ipaddress + "/"; //检查是否存在此目录文件夹 if (CheckDirectoryExist(uri, ftpPath, Username, Password)) { //存在此文件夹就直接上传 check = Upload(HttpContext.Current.Server.MapPath(filePathstr), ipaddress, ftpPath, Username, Password); } else { MakeDir(uri, ftpPath, Username, Password);//创建 check = Upload(HttpContext.Current.Server.MapPath(filePathstr), ipaddress, ftpPath, Username, Password); } //成功就更新 if (check) { filepathsql = ftpPath + "/" + pathstr + rodumlist + Path.GetExtension(upfile.PostedFile.FileName); } //检查是否存在此文件 if (File.Exists(HttpContext.Current.Server.MapPath(filePathstr))) { File.Delete(HttpContext.Current.Server.MapPath(filePathstr)); } return filepathsql; } catch (Exception) { File.Delete(HttpContext.Current.Server.MapPath(filePathstr)); return filepathsql; // Response.Write("<script>alert(" + ex.Message + ");</script>"); } } /// <summary> /// 上传 /// </summary> /// <param name="file"></param> /// <returns></returns> public string Ftp_Up(HttpPostedFileBase postedFile) { string filePathstr = string.Empty; string filepathsql = null; try { string pathstr = DateTime.Now.ToString("yyyyMMddHHmmss"); string rodumlist = GeneralHelper.GetMixPwd(10);//10位随机数 string filename = System.IO.Path.GetFileName(postedFile.FileName); string eExtension = Path.GetExtension(filename); string strLocation = HttpContext.Current.Server.MapPath("~/File/"); filePathstr = strLocation + pathstr + rodumlist + eExtension; postedFile.SaveAs(filePathstr); bool check; string ftpPath = DateTime.Now.ToString("yyyy-MM-dd"); string uri = @"ftp://" + ipaddress + "/"; //检查是否存在此目录文件夹 if (CheckDirectoryExist(uri, ftpPath, Username, Password)) { //存在此文件夹就直接上传 check = Upload(filePathstr, ipaddress, ftpPath, Username, Password); } else { MakeDir(uri, ftpPath, Username, Password);//创建 check = Upload(filePathstr, ipaddress, ftpPath, Username, Password); } //成功就更新 if (check) { filepathsql = ftpPath + "/" + pathstr + rodumlist + eExtension; } //检查是否存在此文件 if (File.Exists(filePathstr)) { File.Delete(filePathstr); } return filepathsql; } catch (Exception ex) { //检查是否存在此文件 if (File.Exists(filePathstr)) { File.Delete(filePathstr); } return ""; // Response.Write("<script>alert(" + ex.Message + ");</script>"); } } /// <summary> /// FTP下载文件在服务器目录 /// </summary> /// <param name="pathname">本地保存目录路径和文件名称</param> /// <param name="filename">FTP目录路径和文件名称</param> /// <returns></returns> public bool FileDown(string pathname, string filename) { string uri = "ftp://" + ipaddress + "/" + filename; string FileName = pathname;//本地保存目录 //创建一个文件流 FileStream fs = null; Stream responseStream = null; try { //创建一个与FTP服务器联系的FtpWebRequest对象 FtpWebRequest request = (FtpWebRequest)WebRequest.Create(new Uri(uri)); //连接登录FTP服务器 request.Credentials = new NetworkCredential(Username, Password); request.KeepAlive = false; //设置请求的方法是FTP文件下载 request.Method = WebRequestMethods.Ftp.DownloadFile; //获取一个请求响应对象 FtpWebResponse response = (FtpWebResponse)request.GetResponse(); //获取请求的响应流 responseStream = response.GetResponseStream(); //判断本地文件是否存在，如果存在，则打开和重写本地文件 if (File.Exists(FileName)) fs = File.Open(FileName, FileMode.Open, FileAccess.ReadWrite); //判断本地文件是否存在，如果不存在，则创建本地文件 else { fs = File.Create(FileName); } if (fs != null) { int buffer_count = 65536; byte[] buffer = new byte[buffer_count]; int size = 0; while ((size = responseStream.Read(buffer, 0, buffer_count)) > 0) { fs.Write(buffer, 0, size); } fs.Flush(); fs.Close(); responseStream.Close(); } return true; } catch (Exception ex) { return false; } finally { if (fs != null) fs.Close(); if (responseStream != null) responseStream.Close(); } } /// <summary> /// 保存和上传图片 /// </summary> /// <param name="imgtwo">需要上传图片</param> /// <param name="date"></param> /// <returns>文件路径</returns> public string SaveUploadImg(Bitmap imgtwo) { string filePathstr = string.Empty; string filepathsql = null; try { string pathstr = DateTime.Now.ToString().Replace("/", "").Replace("-", "").Replace(":", "").Replace(" ", ""); string rodumlist = GeneralHelper.GetMixPwd(10);//10位随机数 filePathstr = "~/File/" + pathstr + rodumlist + ".jpg"; imgtwo.Save(HttpContext.Current.Server.MapPath(filePathstr));//把文件上传到服务器的绝对路径上 bool check; string ftpPath = DateTime.Now.ToString("yyyy-MM-dd"); string uri = @"ftp://" + ipaddress + "/"; //检查是否存在此目录文件夹 if (CheckDirectoryExist(uri, ftpPath, Username, Password)) { //存在此文件夹就直接上传 check = Upload(HttpContext.Current.Server.MapPath(filePathstr), ipaddress, ftpPath, Username, Password); } else { MakeDir(uri, ftpPath, Username, Password);//创建 check = Upload(HttpContext.Current.Server.MapPath(filePathstr), ipaddress, ftpPath, Username, Password); } //成功就更新 if (check) { filepathsql = ftpPath + "/" + pathstr + rodumlist + ".jpg"; } //检查是否存在此文件 if (File.Exists(HttpContext.Current.Server.MapPath(filePathstr))) { File.Delete(HttpContext.Current.Server.MapPath(filePathstr)); } imgtwo.Dispose(); return filepathsql; } catch (Exception ex) { File.Delete(HttpContext.Current.Server.MapPath(filePathstr)); return filepathsql; } } #region /// <summary> /// 文件大小 /// </summary> public bool _File_Length(int ContentLength) { bool length = false; int FileLen = ContentLength; if (FileLen > 2048 * 1024 == false)//不能超过2M { length = true; } return length; } #endregion //用来获取文件类型 public bool File_PastFileName(string fileName) { //bmp, doc, docx, gif, jpg, jpeg, pdf, png, tif, tiff bool isnot = true; string ext = Path.GetExtension(fileName); string[] type = Filetype.Split(';'); for (int i = 0; i < type.Length; i++) { if (type[i].ToLower() == ext.ToLower()) { isnot = false; break; } } return isnot; } }

public class ImageHelper { /// <summary> /// 图片压缩 /// </summary> /// <param name="sFile">原图路径</param> /// <param name="dFile">保存路径</param> /// <param name="flag">压缩质量(数字越小压缩率越高) 1-100</param> /// <param name="dWidth">宽度</param> /// <param name="dHeight">高度</param> /// <returns></returns> public static bool SavePicThumbnail(string sFile, string dFile, int flag, int dWidth = 0, int dHeight = 0) { System.Drawing.Image iSource = System.Drawing.Image.FromFile(sFile); return SavePicThumbnail(dFile, flag, iSource, dWidth, dHeight); } /// <summary> /// 图片压缩 /// </summary> /// <param name="sFile">原图流</param> /// <param name="dFile">保存路径</param> /// <param name="flag">压缩质量(数字越小压缩率越高) 1-100</param> /// <param name="dWidth">宽度</param> /// <param name="dHeight">高度</param> /// <returns></returns> public static bool SavePicThumbnail(Stream stream, string dFile, int flag, int dWidth = 0, int dHeight = 0) { System.Drawing.Image iSource = System.Drawing.Image.FromStream(stream); return SavePicThumbnail(dFile, flag, iSource, dWidth, dHeight); } #region GetPicThumbnail public static Stream GetPicThumbnail(Stream stream ,int flag, int dWidth = 0, int dHeight = 0) { System.Drawing.Image iSource = System.Drawing.Image.FromStream(stream); ImageFormat tFormat = iSource.RawFormat; int sW = 0, sH = 0; if (dHeight == 0 && dWidth == 0) { sW = iSource.Width; sH = iSource.Height; } else if (dWidth != 0) { sW = dWidth; sH = iSource.Height * dWidth / iSource.Width; } else if (dHeight != 0) { sH = dHeight; sW = iSource.Width * dHeight / iSource.Height; } Bitmap ob = new Bitmap(sW, sH); Graphics g = Graphics.FromImage(ob); g.Clear(Color.WhiteSmoke); g.CompositingQuality = CompositingQuality.HighQuality; g.SmoothingMode = SmoothingMode.HighQuality; g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.DrawImage(iSource, new Rectangle(0, 0, sW, sH), 0, 0, iSource.Width, iSource.Height, GraphicsUnit.Pixel); g.Dispose(); //以下代码为保存图片时，设置压缩质量 EncoderParameters ep = new EncoderParameters(); long[] qy = new long[1]; qy[0] = flag;//设置压缩的比例1-100 EncoderParameter eParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, qy); ep.Param[0] = eParam; MemoryStream ms = new MemoryStream(); try { ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders(); ImageCodecInfo jpegICIinfo = null; for (int x = 0; x < arrayICI.Length; x++) { if (arrayICI[x].FormatDescription.Equals("JPEG")) { jpegICIinfo = arrayICI[x]; break; } } if (jpegICIinfo != null) { ob.Save(ms, jpegICIinfo, ep);//dFile是压缩后的新路径 } else { ob.Save(ms, tFormat); } return stream; } catch { return null; } finally { iSource.Dispose(); ob.Dispose(); } } public static bool SavePicThumbnail(string dFile, int flag, System.Drawing.Image iSource, int dWidth = 0, int dHeight = 0) { ImageFormat tFormat = iSource.RawFormat; int sW = 0, sH = 0; if (dHeight == 0 && dWidth == 0) { sW = iSource.Width; sH = iSource.Height; } else if (dWidth != 0) { sW = dWidth; sH = iSource.Height * dWidth / iSource.Width; } else if (dHeight != 0) { sH = dHeight; sW = iSource.Width * dHeight / iSource.Height; } Bitmap ob = new Bitmap(sW, sH); Graphics g = Graphics.FromImage(ob); g.Clear(Color.WhiteSmoke); g.CompositingQuality = CompositingQuality.HighQuality; g.SmoothingMode = SmoothingMode.HighQuality; g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.DrawImage(iSource, new Rectangle(0, 0, sW, sH), 0, 0, iSource.Width, iSource.Height, GraphicsUnit.Pixel); g.Dispose(); //以下代码为保存图片时，设置压缩质量 EncoderParameters ep = new EncoderParameters(); long[] qy = new long[1]; qy[0] = flag;//设置压缩的比例1-100 EncoderParameter eParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, qy); ep.Param[0] = eParam; try { ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders(); ImageCodecInfo jpegICIinfo = null; for (int x = 0; x < arrayICI.Length; x++) { if (arrayICI[x].FormatDescription.Equals("JPEG")) { jpegICIinfo = arrayICI[x]; break; } } if (jpegICIinfo != null) { ob.Save(dFile, jpegICIinfo, ep);//dFile是压缩后的新路径 } else { ob.Save(dFile, tFormat); } return true; } catch { return false; } finally { iSource.Dispose(); ob.Dispose(); } } #endregion }

public interface IRepository<T> where T : BaseEntity { /// <summary> /// 根据过滤条件，获取记录 /// </summary> /// <param name="exp"></param> /// <param name="isNoTracking">(默认不跟踪实体状态)使用NoTracking的查询会在性能方面得到改善</param> /// <returns></returns> IQueryable<T> Find(Expression<Func<T, bool>> exp = null, bool isNoTracking = true); /// <summary> /// 根据过滤条件，获取记录 /// </summary> /// <param name="whereLambda"></param> /// <param name="isNoTracking">(默认不跟踪实体状态)使用NoTracking的查询会在性能方面得到改善</param> /// <param name="values"></param> /// <returns></returns> IQueryable<T> Find(string whereLambda = null, bool isNoTracking = true, params object[] values); IQueryable<TEntity> OtherTable<TEntity>() where TEntity : BaseEntity; IDbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity; /// <summary> /// 判断记录是否存在 /// </summary> /// <param name="exp"></param> /// <returns></returns> bool IsExist(Expression<Func<T, bool>> exp); /// <summary> /// 查找单个(如果没找到则返回为NULL) /// </summary> /// <param name="exp"></param> /// <param name="isNoTracking">(默认不跟踪实体状态)使用NoTracking的查询会在性能方面得到改善</param> /// <returns></returns> T FindSingle(Expression<Func<T, bool>> exp, bool isNoTracking = true); /// <summary> /// 得到分页记录 /// </summary> /// <param name="pageIndex">The pageindex.</param> /// <param name="pageSize">The pagesize.</param> /// <param name="total">总条数</param> /// <param name="exp">条件谓词</param> /// <param name="orderBy">排序，格式如："Id"/"Id descending"</param> IQueryable<T> Find(int pageIndex, int pageSize, out int total, Expression<Func<T, bool>> exp = null, string orderBy = ""); /// <summary> /// 得到分页记录 /// </summary> /// <param name="pageIndex">The pageindex.</param> /// <param name="pageSize">The pagesize.</param> /// <param name="total">总条数</param> /// <param name="whereLambda">条件谓词</param> /// <param name="orderBy">排序，格式如："Id"/"Id descending"</param> IQueryable<T> Find(int pageIndex, int pageSize, out int total, string whereLambda = "", string orderBy = "", params object[] values); /// <summary> /// 根据过滤条件获取记录数 /// </summary> int GetCount(Expression<Func<T, bool>> exp = null); /// <summary> /// 添加实体 /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> /// <returns></returns> int Add(T entity, bool isComit = true); /// <summary> /// 批量添加 /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> int Adds(List<T> entitis, bool isComit = true); /// <summary> /// 更新实体（会更新实体的所有属性） /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> /// <returns></returns> int Update(T entity, bool isComit = true); /// <summary> /// 删除实体 /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> /// <returns></returns> int Delete(T entity, bool isComit = true); /// <summary> /// 实现按需要只更新部分更新 /// <para>如：Update(u =>u.Id==1,u =>new User{Name="ok"});</para> /// </summary> /// <param name="where">The where.</param> /// <param name="entity">The entity.</param> int Update(Expression<Func<T, bool>> where, Expression<Func<T, T>> entity); /// <summary> /// 批量按条件删除 /// </summary> /// <param name="exp"></param> int Delete(Expression<Func<T, bool>> exp); /// <summary> /// 对数据库执行给定的 DDL/DML 命令。 /// </summary> /// <param name="sql">sql</param> /// <param name="parameters">参数</param> /// <returns></returns> int ExecuteSqlCommand(string sql, params SqlParameter[] parameters); /// <summary> /// 执行SQL查询语句 /// </summary> /// <param name="sql"></param> /// <returns></returns> DbRawSqlQuery<int> ExecuteSqlQuery(string sql); /// <summary> /// 执行原始的sql查询 /// </summary> /// <typeparam name="TElement">返回的泛型类型</typeparam> /// <param name="sql">sql</param> /// <param name="parameters">参数</param> /// <returns></returns> IList<TElement> SqlQuery<TElement>(string sql, params SqlParameter[] parameters); /// <summary> /// 开启一个事务 /// </summary> /// <param name="fun"></param> bool BeginTransaction(Func<bool> fun); /// <summary> /// 执行SQL语句或存储过程 /// 返回Datatable数据集 /// </summary> /// <param name="sql">SQL语句或存储过程例如：exec usp_procedure</param> /// <param name="parameters">参数列表</param> /// <returns></returns> DataTable SqlQueryForDataTable(string sql, DbParameter[] parameters); /// <summary> /// 返回Datatable数据集 /// </summary> /// <param name="proName">存储过程名</param> /// <param name="parameters">参数列表</param> /// <returns></returns> [Obsolete("此方法已过时,请改用SqlQueryForDataTable")] DataTable ExecuteForDataTable(string proName, IDataParameter[] parameters); }

public class BaseRepository<T> : IRepository<T> where T : BaseEntity { private DbContext Context { get { DbContext db = (DbContext)CallContext.GetData("DbContext"); if (db == null) { db = new DbContext(); // db.Database.Log = o => LoggingHelper.Instance.Logging(LogLevel.Debug, o); CallContext.SetData("DbContext", db); } return db; } } /// <summary> /// 根据过滤条件，获取记录 /// </summary> /// <param name="exp"></param> /// <param name="isNoTracking">(默认不跟踪实体状态)使用NoTracking的查询会在性能方面得到改善</param> /// <returns></returns> public IQueryable<T> Find(Expression<Func<T, bool>> exp = null, bool isNoTracking = true) { return Filter(exp, isNoTracking); } /// <summary> /// 根据过滤条件，获取记录 /// </summary> /// <param name="whereLambda"></param> /// <param name="isNoTracking">(默认不跟踪实体状态)使用NoTracking的查询会在性能方面得到改善</param> /// <param name="values"></param> /// <returns></returns> public IQueryable<T> Find(string whereLambda = null, bool isNoTracking = true, params object[] values) { return Filter(whereLambda, isNoTracking, values); } /// <summary> /// 判断记录是否存在 /// </summary> /// <param name="exp"></param> /// <returns></returns> public bool IsExist(Expression<Func<T, bool>> exp) { return Context.Set<T>().Any(exp); } /// <summary> /// 查找单个(如果没找到则返回为NULL) /// </summary> /// <param name="exp"></param> /// <param name="isNoTracking">(默认不跟踪实体状态)使用NoTracking的查询会在性能方面得到改善</param> /// <returns></returns> public T FindSingle(Expression<Func<T, bool>> exp, bool isNoTracking = true) { return Filter(exp, isNoTracking).FirstOrDefault(); } /// <summary> /// 得到分页记录 /// </summary> /// <param name="pageIndex">The pageindex.</param> /// <param name="pageSize">The pagesize.</param> /// <param name="total">总条数</param> /// <param name="exp">条件谓词</param> /// <param name="orderBy">排序，格式如："Id"/"Id descending"</param> public IQueryable<T> Find(int pageIndex, int pageSize, out int total, Expression<Func<T, bool>> exp = null, string orderBy = "") { if (pageIndex < 1) pageIndex = 1; var query = Filter(exp); if (!string.IsNullOrEmpty(orderBy)) query = query.OrderBy(orderBy); total = query.Count(); ///return query.Skip(pageSize * (pageIndex - 1)).Take(pageSize); return null; } /// <summary> /// 得到分页记录 /// </summary> /// <param name="pageIndex">The pageindex.</param> /// <param name="pageSize">The pagesize.</param> /// <param name="total">总条数</param> /// <param name="whereLambda">条件谓词</param> /// <param name="orderBy">排序，格式如："Id"/"Id descending"</param> public IQueryable<T> Find(int pageIndex, int pageSize, out int total, string whereLambda = "", string orderBy = "", params object[] values) { if (pageIndex < 1) pageIndex = 1; var query = Filter(whereLambda); if (string.IsNullOrEmpty(orderBy)) query = query.OrderBy(orderBy); total = query.Count(); // return query.Skip(pageSize * (pageIndex - 1)).Take(pageSize); return null; } /// <summary> /// 根据过滤条件获取记录数 /// </summary> public int GetCount(Expression<Func<T, bool>> exp = null) { return Filter(exp).Count(); } /// <summary> /// 添加书体 /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> /// <returns></returns> public int Add(T entity, bool isComit = true) { Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Added; return isComit ? Context.SaveChanges() : 0; } /// <summary> /// 批量添加 /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> public int Adds(List<T> entitis, bool isComit = true) { foreach (T item in entitis) { Context.Entry<T>(item).State = System.Data.Entity.EntityState.Added; } return isComit ? Context.SaveChanges() : 0; } /// <summary> /// 更新实体（会更新实体的所有属性） /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> /// <returns></returns> public int Update(T entity, bool isComit = true) { Context.Entry(entity).State = System.Data.Entity.EntityState.Modified; return isComit ? Context.SaveChanges() : 0; } /// <summary> /// 删除实体 /// </summary> /// <param name="entity">The entities.</param> /// <param name="isComit">是否提交（true）</param> /// <returns></returns> public int Delete(T entity, bool isComit = true) { Context.Set<T>().Remove(entity); return isComit ? Context.SaveChanges() : 0; } /// <summary> /// 实现按需要只更新部分更新 /// <para>如：Update(u =>u.Id==1,u =>new User{Name="ok"});</para> /// </summary> /// <param name="where">The where.</param> /// <param name="entity">The entity.</param> public int Update(Expression<Func<T, bool>> where, Expression<Func<T, T>> entity) { return Context.Set<T>().Where(where).Update(entity); } /// <summary> /// 批量按条件删除 /// </summary> /// <param name="exp"></param> public int Delete(Expression<Func<T, bool>> exp) { return Context.Set<T>().Where(exp).Delete(); } /// <summary> /// 对数据库执行给定的 DDL/DML 命令。 /// </summary> /// <param name="sql">sql</param> /// <param name="parameters">参数</param> /// <returns></returns> public int ExecuteSqlCommand(string sql, params SqlParameter[] parameters) { return Context.Database.ExecuteSqlCommand(sql, parameters); } /// <summary> /// 执行原始的sql查询 /// </summary> /// <typeparam name="TElement">返回的泛型类型</typeparam> /// <param name="sql">sql</param> /// <param name="parameters">参数</param> /// <returns></returns> public IList<TElement> SqlQuery<TElement>(string sql, params SqlParameter[] parameters) { return Context.Database.SqlQuery<TElement>(sql, parameters).ToList(); } public bool BeginTransaction(Func<bool> fun) { using (var trans = Context.Database.BeginTransaction()) { try { var result = fun(); trans.Commit(); return result; } catch (Exception) { trans.Rollback(); return false; } } } private IQueryable<T> Filter(Expression<Func<T, bool>> exp = null, bool isNoTracking = true) { var dbSet = Context.Set<T>().AsQueryable(); if (exp != null) dbSet = dbSet.Where(exp); if (isNoTracking) dbSet = dbSet.AsNoTracking(); return dbSet; } private IQueryable<T> Filter(string whereLambda = null, bool isNoTracking = true, params object[] values) { var dbSet = Context.Set<T>().AsQueryable(); if (whereLambda != null) dbSet = dbSet.Where(whereLambda, values); if (isNoTracking) dbSet = dbSet.AsNoTracking(); return dbSet; } public IQueryable<T> Table { get { return Find(whereLambda: null); } } public IQueryable<TEntity> OtherTable<TEntity>() where TEntity : BaseEntity { return Context.Set<TEntity>().AsNoTracking().AsQueryable(); } public IDbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity { return Context.Set<TEntity>(); } /// <summary> /// 执行SQL查询语句 /// </summary> /// <param name="sql"></param> /// <returns></returns> public DbRawSqlQuery<int> ExecuteSqlQuery(string sql) { try { return Context.Database.SqlQuery<int>(sql); } catch (Exception ex) { throw ex; } } /// <summary> /// 执行SQL语句或存储过程 /// 返回Datatable数据集 /// </summary> /// <param name="sql">SQL语句或存储过程例如：exec usp_procedure</param> /// <param name="parameters">参数列表</param> /// <returns></returns> public System.Data.DataTable SqlQueryForDataTable(string sql, params System.Data.Common.DbParameter[] parameters) { SqlConnection conn = new System.Data.SqlClient.SqlConnection(); try { conn = (SqlConnection)Context.Database.Connection; if (conn.State != ConnectionState.Open) { conn.Open(); } SqlCommand cmd = new SqlCommand(); StringBuilder sb = new StringBuilder(sql); if (parameters != null && parameters.Length > 0) { if (sql.StartsWith("exec ", StringComparison.OrdinalIgnoreCase)) sb.AppendFormat(" {0}", string.Join(",", parameters.Select(o => o.ParameterName).ToArray())); foreach (var item in parameters) { cmd.Parameters.Add(item); } } cmd.Connection = conn; cmd.CommandText = sb.ToString(); SqlDataAdapter adapter = new SqlDataAdapter(cmd); DataTable table = new DataTable(); adapter.Fill(table); conn.Close();//连接需要关闭 return table; } catch (Exception ex) { throw ex; } finally { if (conn.State == ConnectionState.Open) conn.Close(); } } /// <summary> /// 返回Datatable数据集 /// </summary> /// <param name="proName">存储过程名</param> /// <param name="parameters">参数列表</param> /// <returns></returns> [Obsolete("此方法已过时,请改用SqlQueryForDataTable")] public System.Data.DataTable ExecuteForDataTable(string proName, IDataParameter[] parameters) { try { SqlConnection conn = new System.Data.SqlClient.SqlConnection(); conn.ConnectionString = Context.Database.Connection.ConnectionString; if (conn.State != ConnectionState.Open) { conn.Open(); } SqlCommand cmd = new SqlCommand(proName, conn); cmd.CommandType = CommandType.StoredProcedure; if (parameters != null && parameters.Length > 0) { foreach (var item in parameters) { cmd.Parameters.Add(item); } } SqlDataAdapter adapter = new SqlDataAdapter(cmd); DataTable table = new DataTable(); adapter.Fill(table); return table; } catch (Exception ex) { throw ex; } } }

public class DbContext : System.Data.Entity.DbContext { static DbContext() { //Database.SetInitializer(new CreateDatabaseIfNotExists<PersonalDbContext>()); } public DbContext() : base("Name=DbContext") { } protected override void OnModelCreating(DbModelBuilder modelBuilder) { var typesToRegister = Assembly.GetExecutingAssembly().GetTypes() .Where(type => !String.IsNullOrEmpty(type.Namespace)) .Where(type => type.BaseType != null && type.BaseType.IsGenericType && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>)); foreach (var type in typesToRegister) { dynamic configurationInstance = Activator.CreateInstance(type); modelBuilder.Configurations.Add(configurationInstance); } } }

public static class DynamicQueryable { public static IQueryable<T> Where<T>(this IQueryable<T> source, string predicate, params object[] values) { return (IQueryable<T>)Where((IQueryable)source, predicate, values); } public static IQueryable Where(this IQueryable source, string predicate, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (predicate == null) throw new ArgumentNullException("predicate"); LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, typeof(bool), predicate, values); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), "Where", new Type[] { source.ElementType }, source.Expression, Expression.Quote(lambda))); } public static IQueryable Select(this IQueryable source, string selector, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (selector == null) throw new ArgumentNullException("selector"); LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, null, selector, values); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), "Select", new Type[] { source.ElementType, lambda.Body.Type }, source.Expression, Expression.Quote(lambda))); } public static IQueryable<dynamic> Select<T>(this IQueryable<T> source, string selector, params object[] values) { return (IQueryable<dynamic>)Select((IQueryable)source, selector, values); } public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values) { return (IQueryable<T>)OrderBy((IQueryable)source, ordering, values); } public static IQueryable<T> ThenBy<T>(this IQueryable<T> source, string ordering, params object[] values) { return (IQueryable<T>)ThenBy((IQueryable)source, ordering, values); } public static IQueryable ThenBy(this IQueryable source, string ordering, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (ordering == null) throw new ArgumentNullException("ordering"); ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(source.ElementType, "") }; ExpressionParser parser = new ExpressionParser(parameters, ordering, values); IEnumerable<DynamicOrdering> orderings = parser.ParseOrdering(); Expression queryExpr = source.Expression; string methodAsc = "ThenBy"; string methodDesc = "ThenByDescending"; foreach (DynamicOrdering o in orderings) { queryExpr = Expression.Call( typeof(Queryable), o.Ascending ? methodAsc : methodDesc, new Type[] { source.ElementType, o.Selector.Type }, queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters))); } return source.Provider.CreateQuery(queryExpr); } public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (ordering == null) throw new ArgumentNullException("ordering"); ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(source.ElementType, "") }; ExpressionParser parser = new ExpressionParser(parameters, ordering, values); IEnumerable<DynamicOrdering> orderings = parser.ParseOrdering(); Expression queryExpr = source.Expression; string methodAsc = "OrderBy"; string methodDesc = "OrderByDescending"; foreach (DynamicOrdering o in orderings) { queryExpr = Expression.Call( typeof(Queryable), o.Ascending ? methodAsc : methodDesc, new Type[] { source.ElementType, o.Selector.Type }, queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters))); methodAsc = "ThenBy"; methodDesc = "ThenByDescending"; } return source.Provider.CreateQuery(queryExpr); } public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string propertyName, bool ascending) where T : class { Type type = typeof(T); PropertyInfo property = type.GetProperty(propertyName); if (property == null) throw new ArgumentException("propertyName", "Not Exist"); ParameterExpression param = Expression.Parameter(type, "p"); Expression propertyAccessExpression = Expression.MakeMemberAccess(param, property); LambdaExpression orderByExpression = Expression.Lambda(propertyAccessExpression, param); string methodName = ascending ? "OrderBy" : "OrderByDescending"; MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName, new Type[] { type, property.PropertyType }, source.Expression, Expression.Quote(orderByExpression)); return source.Provider.CreateQuery<T>(resultExp); } public static IQueryable Take(this IQueryable source, int count) { if (source == null) throw new ArgumentNullException("source"); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), "Take", new Type[] { source.ElementType }, source.Expression, Expression.Constant(count))); } public static IQueryable Skip(this IQueryable source, int count) { if (source == null) throw new ArgumentNullException("source"); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), "Skip", new Type[] { source.ElementType }, source.Expression, Expression.Constant(count))); } public static IQueryable GroupBy(this IQueryable source, string keySelector, string elementSelector, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (keySelector == null) throw new ArgumentNullException("keySelector"); if (elementSelector == null) throw new ArgumentNullException("elementSelector"); LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, values); LambdaExpression elementLambda = DynamicExpression.ParseLambda(source.ElementType, null, elementSelector, values); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), "GroupBy", new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type }, source.Expression, Expression.Quote(keyLambda), Expression.Quote(elementLambda))); } public static bool Any(this IQueryable source) { if (source == null) throw new ArgumentNullException("source"); return (bool)source.Provider.Execute( Expression.Call( typeof(Queryable), "Any", new Type[] { source.ElementType }, source.Expression)); } public static int Count(this IQueryable source) { if (source == null) throw new ArgumentNullException("source"); return (int)source.Provider.Execute( Expression.Call( typeof(Queryable), "Count", new Type[] { source.ElementType }, source.Expression)); } } public abstract class DynamicClass { public override string ToString() { PropertyInfo[] props = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public); StringBuilder sb = new StringBuilder(); sb.Append("{"); for (int i = 0; i < props.Length; i++) { if (i > 0) sb.Append(", "); sb.Append(props[i].Name); sb.Append("="); sb.Append(props[i].GetValue(this, null)); } sb.Append("}"); return sb.ToString(); } } public class DynamicProperty { string name; Type type; public DynamicProperty(string name, Type type) { if (name == null) throw new ArgumentNullException("name"); if (type == null) throw new ArgumentNullException("type"); this.name = name; this.type = type; } public string Name { get { return name; } } public Type Type { get { return type; } } } public static class DynamicExpression { public static Expression Parse(Type resultType, string expression, params object[] values) { ExpressionParser parser = new ExpressionParser(null, expression, values); return parser.Parse(resultType); } public static LambdaExpression ParseLambda(Type itType, Type resultType, string expression, params object[] values) { return ParseLambda(new ParameterExpression[] { Expression.Parameter(itType, "") }, resultType, expression, values); } public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, params object[] values) { ExpressionParser parser = new ExpressionParser(parameters, expression, values); return Expression.Lambda(parser.Parse(resultType), parameters); } public static Expression<Func<T, S>> ParseLambda<T, S>(string expression, params object[] values) { return (Expression<Func<T, S>>)ParseLambda(typeof(T), typeof(S), expression, values); } public static Type CreateClass(params DynamicProperty[] properties) { return ClassFactory.Instance.GetDynamicClass(properties); } public static Type CreateClass(IEnumerable<DynamicProperty> properties) { return ClassFactory.Instance.GetDynamicClass(properties); } } internal class DynamicOrdering { public Expression Selector; public bool Ascending; } internal class Signature : IEquatable<Signature> { public DynamicProperty[] properties; public int hashCode; public Signature(IEnumerable<DynamicProperty> properties) { this.properties = properties.ToArray(); hashCode = 0; foreach (DynamicProperty p in properties) { hashCode ^= p.Name.GetHashCode() ^ p.Type.GetHashCode(); } } public override int GetHashCode() { return hashCode; } public override bool Equals(object obj) { return obj is Signature ? Equals((Signature)obj) : false; } public bool Equals(Signature other) { if (properties.Length != other.properties.Length) return false; for (int i = 0; i < properties.Length; i++) { if (properties[i].Name != other.properties[i].Name || properties[i].Type != other.properties[i].Type) return false; } return true; } } internal class ClassFactory { public static readonly ClassFactory Instance = new ClassFactory(); static ClassFactory() { } // Trigger lazy initialization of static fields ModuleBuilder module; Dictionary<Signature, Type> classes; int classCount; ReaderWriterLock rwLock; private ClassFactory() { AssemblyName name = new AssemblyName("DynamicClasses"); AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run); #if ENABLE_LINQ_PARTIAL_TRUST new ReflectionPermission(PermissionState.Unrestricted).Assert(); #endif try { module = assembly.DefineDynamicModule("Module"); } finally { #if ENABLE_LINQ_PARTIAL_TRUST PermissionSet.RevertAssert(); #endif } classes = new Dictionary<Signature, Type>(); rwLock = new ReaderWriterLock(); } public Type GetDynamicClass(IEnumerable<DynamicProperty> properties) { rwLock.AcquireReaderLock(Timeout.Infinite); try { Signature signature = new Signature(properties); Type type; if (!classes.TryGetValue(signature, out type)) { type = CreateDynamicClass(signature.properties); classes.Add(signature, type); } return type; } finally { rwLock.ReleaseReaderLock(); } } Type CreateDynamicClass(DynamicProperty[] properties) { LockCookie cookie = rwLock.UpgradeToWriterLock(Timeout.Infinite); try { string typeName = "DynamicClass" + (classCount + 1); #if ENABLE_LINQ_PARTIAL_TRUST new ReflectionPermission(PermissionState.Unrestricted).Assert(); #endif try { TypeBuilder tb = this.module.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public, typeof(DynamicClass)); FieldInfo[] fields = GenerateProperties(tb, properties); GenerateEquals(tb, fields); GenerateGetHashCode(tb, fields); Type result = tb.CreateType(); classCount++; return result; } finally { #if ENABLE_LINQ_PARTIAL_TRUST PermissionSet.RevertAssert(); #endif } } finally { rwLock.DowngradeFromWriterLock(ref cookie); } } FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties) { FieldInfo[] fields = new FieldBuilder[properties.Length]; for (int i = 0; i < properties.Length; i++) { DynamicProperty dp = properties[i]; FieldBuilder fb = tb.DefineField("_" + dp.Name, dp.Type, FieldAttributes.Private); PropertyBuilder pb = tb.DefineProperty(dp.Name, PropertyAttributes.HasDefault, dp.Type, null); MethodBuilder mbGet = tb.DefineMethod("get_" + dp.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, dp.Type, Type.EmptyTypes); ILGenerator genGet = mbGet.GetILGenerator(); genGet.Emit(OpCodes.Ldarg_0); genGet.Emit(OpCodes.Ldfld, fb); genGet.Emit(OpCodes.Ret); MethodBuilder mbSet = tb.DefineMethod("set_" + dp.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { dp.Type }); ILGenerator genSet = mbSet.GetILGenerator(); genSet.Emit(OpCodes.Ldarg_0); genSet.Emit(OpCodes.Ldarg_1); genSet.Emit(OpCodes.Stfld, fb); genSet.Emit(OpCodes.Ret); pb.SetGetMethod(mbGet); pb.SetSetMethod(mbSet); fields[i] = fb; } return fields; } void GenerateEquals(TypeBuilder tb, FieldInfo[] fields) { MethodBuilder mb = tb.DefineMethod("Equals", MethodAttributes.Public | MethodAttributes.ReuseSlot | MethodAttributes.Virtual | MethodAttributes.HideBySig, typeof(bool), new Type[] { typeof(object) }); ILGenerator gen = mb.GetILGenerator(); LocalBuilder other = gen.DeclareLocal(tb); Label next = gen.DefineLabel(); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Isinst, tb); gen.Emit(OpCodes.Stloc, other); gen.Emit(OpCodes.Ldloc, other); gen.Emit(OpCodes.Brtrue_S, next); gen.Emit(OpCodes.Ldc_I4_0); gen.Emit(OpCodes.Ret); gen.MarkLabel(next); foreach (FieldInfo field in fields) { Type ft = field.FieldType; Type ct = typeof(EqualityComparer<>).MakeGenericType(ft); next = gen.DefineLabel(); gen.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, field); gen.Emit(OpCodes.Ldloc, other); gen.Emit(OpCodes.Ldfld, field); gen.EmitCall(OpCodes.Callvirt, ct.GetMethod("Equals", new Type[] { ft, ft }), null); gen.Emit(OpCodes.Brtrue_S, next); gen.Emit(OpCodes.Ldc_I4_0); gen.Emit(OpCodes.Ret); gen.MarkLabel(next); } gen.Emit(OpCodes.Ldc_I4_1); gen.Emit(OpCodes.Ret); } void GenerateGetHashCode(TypeBuilder tb, FieldInfo[] fields) { MethodBuilder mb = tb.DefineMethod("GetHashCode", MethodAttributes.Public | MethodAttributes.ReuseSlot | MethodAttributes.Virtual | MethodAttributes.HideBySig, typeof(int), Type.EmptyTypes); ILGenerator gen = mb.GetILGenerator(); gen.Emit(OpCodes.Ldc_I4_0); foreach (FieldInfo field in fields) { Type ft = field.FieldType; Type ct = typeof(EqualityComparer<>).MakeGenericType(ft); gen.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, field); gen.EmitCall(OpCodes.Callvirt, ct.GetMethod("GetHashCode", new Type[] { ft }), null); gen.Emit(OpCodes.Xor); } gen.Emit(OpCodes.Ret); } } public sealed class ParseException : Exception { int position; public ParseException(string message, int position) : base(message) { this.position = position; } public int Position { get { return position; } } public override string ToString() { return string.Format(Res.ParseExceptionFormat, Message, position); } } internal class ExpressionParser { struct Token { public TokenId id; public string text; public int pos; } enum TokenId { Unknown, End, Identifier, StringLiteral, IntegerLiteral, RealLiteral, Exclamation, Percent, Amphersand, OpenParen, CloseParen, Asterisk, Plus, Comma, Minus, Dot, Slash, Colon, LessThan, Equal, GreaterThan, Question, OpenBracket, CloseBracket, Bar, ExclamationEqual, DoubleAmphersand, LessThanEqual, LessGreater, DoubleEqual, GreaterThanEqual, DoubleBar } interface ILogicalSignatures { void F(bool x, bool y); void F(bool? x, bool? y); } interface IArithmeticSignatures { void F(int x, int y); void F(uint x, uint y); void F(long x, long y); void F(ulong x, ulong y); void F(float x, float y); void F(double x, double y); void F(decimal x, decimal y); void F(int? x, int? y); void F(uint? x, uint? y); void F(long? x, long? y); void F(ulong? x, ulong? y); void F(float? x, float? y); void F(double? x, double? y); void F(decimal? x, decimal? y); } interface IRelationalSignatures : IArithmeticSignatures { void F(string x, string y); void F(char x, char y); void F(DateTime x, DateTime y); void F(TimeSpan x, TimeSpan y); void F(char? x, char? y); void F(DateTime? x, DateTime? y); void F(TimeSpan? x, TimeSpan? y); } interface IEqualitySignatures : IRelationalSignatures { void F(bool x, bool y); void F(bool? x, bool? y); } interface IAddSignatures : IArithmeticSignatures { void F(DateTime x, TimeSpan y); void F(TimeSpan x, TimeSpan y); void F(DateTime? x, TimeSpan? y); void F(TimeSpan? x, TimeSpan? y); } interface ISubtractSignatures : IAddSignatures { void F(DateTime x, DateTime y); void F(DateTime? x, DateTime? y); } interface INegationSignatures { void F(int x); void F(long x); void F(float x); void F(double x); void F(decimal x); void F(int? x); void F(long? x); void F(float? x); void F(double? x); void F(decimal? x); } interface INotSignatures { void F(bool x); void F(bool? x); } interface IEnumerableSignatures { void Where(bool predicate); void Any(); void Any(bool predicate); void All(bool predicate); void Count(); void Count(bool predicate); void Min(object selector); void Max(object selector); void Sum(int selector); void Sum(int? selector); void Sum(long selector); void Sum(long? selector); void Sum(float selector); void Sum(float? selector); void Sum(double selector); void Sum(double? selector); void Sum(decimal selector); void Sum(decimal? selector); void Average(int selector); void Average(int? selector); void Average(long selector); void Average(long? selector); void Average(float selector); void Average(float? selector); void Average(double selector); void Average(double? selector); void Average(decimal selector); void Average(decimal? selector); } static readonly Type[] predefinedTypes = { typeof(Object), typeof(Boolean), typeof(Char), typeof(String), typeof(SByte), typeof(Byte), typeof(Int16), typeof(UInt16), typeof(Int32), typeof(UInt32), typeof(Int64), typeof(UInt64), typeof(Single), typeof(Double), typeof(Decimal), typeof(DateTime), typeof(TimeSpan), typeof(Guid), typeof(Math), typeof(Convert) }; static readonly Expression trueLiteral = Expression.Constant(true); static readonly Expression falseLiteral = Expression.Constant(false); static readonly Expression nullLiteral = Expression.Constant(null); static readonly string keywordIt = "it"; static readonly string keywordIif = "iif"; static readonly string keywordNew = "new"; static Dictionary<string, object> keywords; Dictionary<string, object> symbols; IDictionary<string, object> externals; Dictionary<Expression, string> literals; ParameterExpression it; string text; int textPos; int textLen; char ch; Token token; public ExpressionParser(ParameterExpression[] parameters, string expression, object[] values) { if (expression == null) throw new ArgumentNullException("expression"); if (keywords == null) keywords = CreateKeywords(); symbols = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); literals = new Dictionary<Expression, string>(); if (parameters != null) ProcessParameters(parameters); if (values != null) ProcessValues(values); text = expression; textLen = text.Length; SetTextPos(0); NextToken(); } void ProcessParameters(ParameterExpression[] parameters) { foreach (ParameterExpression pe in parameters) if (!String.IsNullOrEmpty(pe.Name)) AddSymbol(pe.Name, pe); if (parameters.Length == 1 && String.IsNullOrEmpty(parameters[0].Name)) it = parameters[0]; } void ProcessValues(object[] values) { for (int i = 0; i < values.Length; i++) { object value = values[i]; if (i == values.Length - 1 && value is IDictionary<string, object>) { externals = (IDictionary<string, object>)value; } else { AddSymbol("@" + i.ToString(System.Globalization.CultureInfo.InvariantCulture), value); } } } void AddSymbol(string name, object value) { if (symbols.ContainsKey(name)) throw ParseError(Res.DuplicateIdentifier, name); symbols.Add(name, value); } public Expression Parse(Type resultType) { int exprPos = token.pos; Expression expr = ParseExpression(); if (resultType != null) if ((expr = PromoteExpression(expr, resultType, true)) == null) throw ParseError(exprPos, Res.ExpressionTypeMismatch, GetTypeName(resultType)); ValidateToken(TokenId.End, Res.SyntaxError); return expr; } #pragma warning disable 0219 public IEnumerable<DynamicOrdering> ParseOrdering() { List<DynamicOrdering> orderings = new List<DynamicOrdering>(); while (true) { Expression expr = ParseExpression(); bool ascending = true; if (TokenIdentifierIs("asc") || TokenIdentifierIs("ascending")) { NextToken(); } else if (TokenIdentifierIs("desc") || TokenIdentifierIs("descending")) { NextToken(); ascending = false; } orderings.Add(new DynamicOrdering { Selector = expr, Ascending = ascending }); if (token.id != TokenId.Comma) break; NextToken(); } ValidateToken(TokenId.End, Res.SyntaxError); return orderings; } #pragma warning restore 0219 // ?: operator Expression ParseExpression() { int errorPos = token.pos; Expression expr = ParseLogicalOr(); if (token.id == TokenId.Question) { NextToken(); Expression expr1 = ParseExpression(); ValidateToken(TokenId.Colon, Res.ColonExpected); NextToken(); Expression expr2 = ParseExpression(); expr = GenerateConditional(expr, expr1, expr2, errorPos); } return expr; } // ||, or operator Expression ParseLogicalOr() { Expression left = ParseLogicalAnd(); while (token.id == TokenId.DoubleBar || TokenIdentifierIs("or")) { Token op = token; NextToken(); Expression right = ParseLogicalAnd(); CheckAndPromoteOperands(typeof(ILogicalSignatures), op.text, ref left, ref right, op.pos); left = Expression.OrElse(left, right); } return left; } // &&, and operator Expression ParseLogicalAnd() { Expression left = ParseComparison(); while (token.id == TokenId.DoubleAmphersand || TokenIdentifierIs("and")) { Token op = token; NextToken(); Expression right = ParseComparison(); CheckAndPromoteOperands(typeof(ILogicalSignatures), op.text, ref left, ref right, op.pos); left = Expression.AndAlso(left, right); } return left; } // =, ==, !=, <>, >, >=, <, <= operators Expression ParseComparison() { Expression left = ParseAdditive(); while (token.id == TokenId.Equal || token.id == TokenId.DoubleEqual || token.id == TokenId.ExclamationEqual || token.id == TokenId.LessGreater || token.id == TokenId.GreaterThan || token.id == TokenId.GreaterThanEqual || token.id == TokenId.LessThan || token.id == TokenId.LessThanEqual) { Token op = token; NextToken(); Expression right = ParseAdditive(); bool isEquality = op.id == TokenId.Equal || op.id == TokenId.DoubleEqual || op.id == TokenId.ExclamationEqual || op.id == TokenId.LessGreater; if (isEquality && !left.Type.IsValueType && !right.Type.IsValueType) { if (left.Type != right.Type) { if (left.Type.IsAssignableFrom(right.Type)) { right = Expression.Convert(right, left.Type); } else if (right.Type.IsAssignableFrom(left.Type)) { left = Expression.Convert(left, right.Type); } else { throw IncompatibleOperandsError(op.text, left, right, op.pos); } } } else if (IsEnumType(left.Type) || IsEnumType(right.Type)) { if (left.Type != right.Type) { Expression e; if ((e = PromoteExpression(right, left.Type, true)) != null) { right = e; } else if ((e = PromoteExpression(left, right.Type, true)) != null) { left = e; } else { throw IncompatibleOperandsError(op.text, left, right, op.pos); } } } else { CheckAndPromoteOperands(isEquality ? typeof(IEqualitySignatures) : typeof(IRelationalSignatures), op.text, ref left, ref right, op.pos); } switch (op.id) { case TokenId.Equal: case TokenId.DoubleEqual: left = GenerateEqual(left, right); break; case TokenId.ExclamationEqual: case TokenId.LessGreater: left = GenerateNotEqual(left, right); break; case TokenId.GreaterThan: left = GenerateGreaterThan(left, right); break; case TokenId.GreaterThanEqual: left = GenerateGreaterThanEqual(left, right); break; case TokenId.LessThan: left = GenerateLessThan(left, right); break; case TokenId.LessThanEqual: left = GenerateLessThanEqual(left, right); break; } } return left; } // +, -, & operators Expression ParseAdditive() { Expression left = ParseMultiplicative(); while (token.id == TokenId.Plus || token.id == TokenId.Minus || token.id == TokenId.Amphersand) { Token op = token; NextToken(); Expression right = ParseMultiplicative(); switch (op.id) { case TokenId.Plus: if (left.Type == typeof(string) || right.Type == typeof(string)) goto case TokenId.Amphersand; CheckAndPromoteOperands(typeof(IAddSignatures), op.text, ref left, ref right, op.pos); left = GenerateAdd(left, right); break; case TokenId.Minus: CheckAndPromoteOperands(typeof(ISubtractSignatures), op.text, ref left, ref right, op.pos); left = GenerateSubtract(left, right); break; case TokenId.Amphersand: left = GenerateStringConcat(left, right); break; } } return left; } // *, /, %, mod operators Expression ParseMultiplicative() { Expression left = ParseUnary(); while (token.id == TokenId.Asterisk || token.id == TokenId.Slash || token.id == TokenId.Percent || TokenIdentifierIs("mod")) { Token op = token; NextToken(); Expression right = ParseUnary(); CheckAndPromoteOperands(typeof(IArithmeticSignatures), op.text, ref left, ref right, op.pos); switch (op.id) { case TokenId.Asterisk: left = Expression.Multiply(left, right); break; case TokenId.Slash: left = Expression.pide(left, right); break; case TokenId.Percent: case TokenId.Identifier: left = Expression.Modulo(left, right); break; } } return left; } // -, !, not unary operators Expression ParseUnary() { if (token.id == TokenId.Minus || token.id == TokenId.Exclamation || TokenIdentifierIs("not")) { Token op = token; NextToken(); if (op.id == TokenId.Minus && (token.id == TokenId.IntegerLiteral || token.id == TokenId.RealLiteral)) { token.text = "-" + token.text; token.pos = op.pos; return ParsePrimary(); } Expression expr = ParseUnary(); if (op.id == TokenId.Minus) { CheckAndPromoteOperand(typeof(INegationSignatures), op.text, ref expr, op.pos); expr = Expression.Negate(expr); } else { CheckAndPromoteOperand(typeof(INotSignatures), op.text, ref expr, op.pos); expr = Expression.Not(expr); } return expr; } return ParsePrimary(); } Expression ParsePrimary() { Expression expr = ParsePrimaryStart(); while (true) { if (token.id == TokenId.Dot) { NextToken(); expr = ParseMemberAccess(null, expr); } else if (token.id == TokenId.OpenBracket) { expr = ParseElementAccess(expr); } else { break; } } return expr; } Expression ParsePrimaryStart() { switch (token.id) { case TokenId.Identifier: return ParseIdentifier(); case TokenId.StringLiteral: return ParseStringLiteral(); case TokenId.IntegerLiteral: return ParseIntegerLiteral(); case TokenId.RealLiteral: return ParseRealLiteral(); case TokenId.OpenParen: return ParseParenExpression(); default: throw ParseError(Res.ExpressionExpected); } } Expression ParseStringLiteral() { ValidateToken(TokenId.StringLiteral); char quote = token.text[0]; string s = token.text.Substring(1, token.text.Length - 2); int start = 0; while (true) { int i = s.IndexOf(quote, start); if (i < 0) break; s = s.Remove(i, 1); start = i + 1; } //if (quote == '\'') { // if (s.Length != 1) // throw ParseError(Res.InvalidCharacterLiteral); // NextToken(); // return CreateLiteral(s[0], s); //} NextToken(); return CreateLiteral(s, s); } Expression ParseIntegerLiteral() { ValidateToken(TokenId.IntegerLiteral); string text = token.text; if (text[0] != '-') { ulong value; if (!UInt64.TryParse(text, out value)) throw ParseError(Res.InvalidIntegerLiteral, text); NextToken(); if (value <= (ulong)Int32.MaxValue) return CreateLiteral((int)value, text); if (value <= (ulong)UInt32.MaxValue) return CreateLiteral((uint)value, text); if (value <= (ulong)Int64.MaxValue) return CreateLiteral((long)value, text); return CreateLiteral(value, text); } else { long value; if (!Int64.TryParse(text, out value)) throw ParseError(Res.InvalidIntegerLiteral, text); NextToken(); if (value >= Int32.MinValue && value <= Int32.MaxValue) return CreateLiteral((int)value, text); return CreateLiteral(value, text); } } Expression ParseRealLiteral() { ValidateToken(TokenId.RealLiteral); string text = token.text; object value = null; char last = text[text.Length - 1]; if (last == 'F' || last == 'f') { float f; if (Single.TryParse(text.Substring(0, text.Length - 1), out f)) value = f; } else { double d; if (Double.TryParse(text, out d)) value = d; } if (value == null) throw ParseError(Res.InvalidRealLiteral, text); NextToken(); return CreateLiteral(value, text); } Expression CreateLiteral(object value, string text) { ConstantExpression expr = Expression.Constant(value); literals.Add(expr, text); return expr; } Expression ParseParenExpression() { ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); NextToken(); Expression e = ParseExpression(); ValidateToken(TokenId.CloseParen, Res.CloseParenOrOperatorExpected); NextToken(); return e; } Expression ParseIdentifier() { ValidateToken(TokenId.Identifier); object value; if (keywords.TryGetValue(token.text, out value)) { if (value is Type) return ParseTypeAccess((Type)value); if (value == (object)keywordIt) return ParseIt(); if (value == (object)keywordIif) return ParseIif(); if (value == (object)keywordNew) return ParseNew(); NextToken(); return (Expression)value; } if (symbols.TryGetValue(token.text, out value) || externals != null && externals.TryGetValue(token.text, out value)) { Expression expr = value as Expression; if (expr == null) { expr = Expression.Constant(value); } else { LambdaExpression lambda = expr as LambdaExpression; if (lambda != null) return ParseLambdaInvocation(lambda); } NextToken(); return expr; } if (it != null) return ParseMemberAccess(null, it); throw ParseError(Res.UnknownIdentifier, token.text); } Expression ParseIt() { if (it == null) throw ParseError(Res.NoItInScope); NextToken(); return it; } Expression ParseIif() { int errorPos = token.pos; NextToken(); Expression[] args = ParseArgumentList(); if (args.Length != 3) throw ParseError(errorPos, Res.IifRequiresThreeArgs); return GenerateConditional(args[0], args[1], args[2], errorPos); } Expression GenerateConditional(Expression test, Expression expr1, Expression expr2, int errorPos) { if (test.Type != typeof(bool)) throw ParseError(errorPos, Res.FirstExprMustBeBool); if (expr1.Type != expr2.Type) { Expression expr1as2 = expr2 != nullLiteral ? PromoteExpression(expr1, expr2.Type, true) : null; Expression expr2as1 = expr1 != nullLiteral ? PromoteExpression(expr2, expr1.Type, true) : null; if (expr1as2 != null && expr2as1 == null) { expr1 = expr1as2; } else if (expr2as1 != null && expr1as2 == null) { expr2 = expr2as1; } else { string type1 = expr1 != nullLiteral ? expr1.Type.Name : "null"; string type2 = expr2 != nullLiteral ? expr2.Type.Name : "null"; if (expr1as2 != null && expr2as1 != null) throw ParseError(errorPos, Res.BothTypesConvertToOther, type1, type2); throw ParseError(errorPos, Res.NeitherTypeConvertsToOther, type1, type2); } } return Expression.Condition(test, expr1, expr2); } Expression ParseNew() { NextToken(); ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); NextToken(); List<DynamicProperty> properties = new List<DynamicProperty>(); List<Expression> expressions = new List<Expression>(); while (true) { int exprPos = token.pos; Expression expr = ParseExpression(); string propName; if (TokenIdentifierIs("as")) { NextToken(); propName = GetIdentifier(); NextToken(); } else { MemberExpression me = expr as MemberExpression; if (me == null) throw ParseError(exprPos, Res.MissingAsClause); propName = me.Member.Name; } expressions.Add(expr); properties.Add(new DynamicProperty(propName, expr.Type)); if (token.id != TokenId.Comma) break; NextToken(); } ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected); NextToken(); Type type = DynamicExpression.CreateClass(properties); MemberBinding[] bindings = new MemberBinding[properties.Count]; for (int i = 0; i < bindings.Length; i++) bindings[i] = Expression.Bind(type.GetProperty(properties[i].Name), expressions[i]); return Expression.MemberInit(Expression.New(type), bindings); } Expression ParseLambdaInvocation(LambdaExpression lambda) { int errorPos = token.pos; NextToken(); Expression[] args = ParseArgumentList(); MethodBase method; if (FindMethod(lambda.Type, "Invoke", false, args, out method) != 1) throw ParseError(errorPos, Res.ArgsIncompatibleWithLambda); return Expression.Invoke(lambda, args); } Expression ParseTypeAccess(Type type) { int errorPos = token.pos; NextToken(); if (token.id == TokenId.Question) { if (!type.IsValueType || IsNullableType(type)) throw ParseError(errorPos, Res.TypeHasNoNullableForm, GetTypeName(type)); type = typeof(Nullable<>).MakeGenericType(type); NextToken(); } if (token.id == TokenId.OpenParen) { Expression[] args = ParseArgumentList(); MethodBase method; switch (FindBestMethod(type.GetConstructors(), args, out method)) { case 0: if (args.Length == 1) return GenerateConversion(args[0], type, errorPos); throw ParseError(errorPos, Res.NoMatchingConstructor, GetTypeName(type)); case 1: return Expression.New((ConstructorInfo)method, args); default: throw ParseError(errorPos, Res.AmbiguousConstructorInvocation, GetTypeName(type)); } } ValidateToken(TokenId.Dot, Res.DotOrOpenParenExpected); NextToken(); return ParseMemberAccess(type, null); } Expression GenerateConversion(Expression expr, Type type, int errorPos) { Type exprType = expr.Type; if (exprType == type) return expr; if (exprType.IsValueType && type.IsValueType) { if ((IsNullableType(exprType) || IsNullableType(type)) && GetNonNullableType(exprType) == GetNonNullableType(type)) return Expression.Convert(expr, type); if ((IsNumericType(exprType) || IsEnumType(exprType)) && (IsNumericType(type)) || IsEnumType(type)) return Expression.ConvertChecked(expr, type); } if (exprType.IsAssignableFrom(type) || type.IsAssignableFrom(exprType) || exprType.IsInterface || type.IsInterface) return Expression.Convert(expr, type); throw ParseError(errorPos, Res.CannotConvertValue, GetTypeName(exprType), GetTypeName(type)); } Expression ParseMemberAccess(Type type, Expression instance) { if (instance != null) type = instance.Type; int errorPos = token.pos; string id = GetIdentifier(); NextToken(); if (token.id == TokenId.OpenParen) { if (instance != null && type != typeof(string)) { Type enumerableType = FindGenericType(typeof(IEnumerable<>), type); if (enumerableType != null) { Type elementType = enumerableType.GetGenericArguments()[0]; return ParseAggregate(instance, elementType, id, errorPos); } } Expression[] args = ParseArgumentList(); MethodBase mb; switch (FindMethod(type, id, instance == null, args, out mb)) { case 0: throw ParseError(errorPos, Res.NoApplicableMethod, id, GetTypeName(type)); case 1: MethodInfo method = (MethodInfo)mb; if (!IsPredefinedType(method.DeclaringType)) throw ParseError(errorPos, Res.MethodsAreInaccessible, GetTypeName(method.DeclaringType)); if (method.ReturnType == typeof(void)) throw ParseError(errorPos, Res.MethodIsVoid, id, GetTypeName(method.DeclaringType)); return Expression.Call(instance, (MethodInfo)method, args); default: throw ParseError(errorPos, Res.AmbiguousMethodInvocation, id, GetTypeName(type)); } } else { MemberInfo member = FindPropertyOrField(type, id, instance == null); if (member == null) throw ParseError(errorPos, Res.UnknownPropertyOrField, id, GetTypeName(type)); return member is PropertyInfo ? Expression.Property(instance, (PropertyInfo)member) : Expression.Field(instance, (FieldInfo)member); } } static Type FindGenericType(Type generic, Type type) { while (type != null && type != typeof(object)) { if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type; if (generic.IsInterface) { foreach (Type intfType in type.GetInterfaces()) { Type found = FindGenericType(generic, intfType); if (found != null) return found; } } type = type.BaseType; } return null; } Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos) { ParameterExpression outerIt = it; ParameterExpression innerIt = Expression.Parameter(elementType, ""); it = innerIt; Expression[] args = ParseArgumentList(); it = outerIt; MethodBase signature; if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1) throw ParseError(errorPos, Res.NoApplicableAggregate, methodName); Type[] typeArgs; if (signature.Name == "Min" || signature.Name == "Max") { typeArgs = new Type[] { elementType, args[0].Type }; } else { typeArgs = new Type[] { elementType }; } if (args.Length == 0) { args = new Expression[] { instance }; } else { args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) }; } return Expression.Call(typeof(Enumerable), signature.Name, typeArgs, args); } Expression[] ParseArgumentList() { ValidateToken(TokenId.OpenParen, Res.OpenParenExpected); NextToken(); Expression[] args = token.id != TokenId.CloseParen ? ParseArguments() : new Expression[0]; ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected); NextToken(); return args; } Expression[] ParseArguments() { List<Expression> argList = new List<Expression>(); while (true) { argList.Add(ParseExpression()); if (token.id != TokenId.Comma) break; NextToken(); } return argList.ToArray(); } Expression ParseElementAccess(Expression expr) { int errorPos = token.pos; ValidateToken(TokenId.OpenBracket, Res.OpenParenExpected); NextToken(); Expression[] args = ParseArguments(); ValidateToken(TokenId.CloseBracket, Res.CloseBracketOrCommaExpected); NextToken(); if (expr.Type.IsArray) { if (expr.Type.GetArrayRank() != 1 || args.Length != 1) throw ParseError(errorPos, Res.CannotIndexMultiDimArray); Expression index = PromoteExpression(args[0], typeof(int), true); if (index == null) throw ParseError(errorPos, Res.InvalidIndex); return Expression.ArrayIndex(expr, index); } else { MethodBase mb; switch (FindIndexer(expr.Type, args, out mb)) { case 0: throw ParseError(errorPos, Res.NoApplicableIndexer, GetTypeName(expr.Type)); case 1: return Expression.Call(expr, (MethodInfo)mb, args); default: throw ParseError(errorPos, Res.AmbiguousIndexerInvocation, GetTypeName(expr.Type)); } } } static bool IsPredefinedType(Type type) { foreach (Type t in predefinedTypes) if (t == type) return true; return false; } static bool IsNullableType(Type type) { return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>); } static Type GetNonNullableType(Type type) { return IsNullableType(type) ? type.GetGenericArguments()[0] : type; } static string GetTypeName(Type type) { Type baseType = GetNonNullableType(type); string s = baseType.Name; if (type != baseType) s += '?'; return s; } static bool IsNumericType(Type type) { return GetNumericTypeKind(type) != 0; } static bool IsSignedIntegralType(Type type) { return GetNumericTypeKind(type) == 2; } static bool IsUnsignedIntegralType(Type type) { return GetNumericTypeKind(type) == 3; } static int GetNumericTypeKind(Type type) { type = GetNonNullableType(type); if (type.IsEnum) return 0; switch (Type.GetTypeCode(type)) { case TypeCode.Char: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return 1; case TypeCode.SByte: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: return 2; case TypeCode.Byte: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return 3; default: return 0; } } static bool IsEnumType(Type type) { return GetNonNullableType(type).IsEnum; } void CheckAndPromoteOperand(Type signatures, string opName, ref Expression expr, int errorPos) { Expression[] args = new Expression[] { expr }; MethodBase method; if (FindMethod(signatures, "F", false, args, out method) != 1) throw ParseError(errorPos, Res.IncompatibleOperand, opName, GetTypeName(args[0].Type)); expr = args[0]; } void CheckAndPromoteOperands(Type signatures, string opName, ref Expression left, ref Expression right, int errorPos) { Expression[] args = new Expression[] { left, right }; MethodBase method; if (FindMethod(signatures, "F", false, args, out method) != 1) throw IncompatibleOperandsError(opName, left, right, errorPos); left = args[0]; right = args[1]; } Exception IncompatibleOperandsError(string opName, Expression left, Expression right, int pos) { return ParseError(pos, Res.IncompatibleOperands, opName, GetTypeName(left.Type), GetTypeName(right.Type)); } MemberInfo FindPropertyOrField(Type type, string memberName, bool staticAccess) { BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly | (staticAccess ? BindingFlags.Static : BindingFlags.Instance); foreach (Type t in SelfAndBaseTypes(type)) { MemberInfo[] members = t.FindMembers(MemberTypes.Property | MemberTypes.Field, flags, Type.FilterNameIgnoreCase, memberName); if (members.Length != 0) return members[0]; } return null; } int FindMethod(Type type, string methodName, bool staticAccess, Expression[] args, out MethodBase method) { BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly | (staticAccess ? BindingFlags.Static : BindingFlags.Instance); foreach (Type t in SelfAndBaseTypes(type)) { MemberInfo[] members = t.FindMembers(MemberTypes.Method, flags, Type.FilterNameIgnoreCase, methodName); int count = FindBestMethod(members.Cast<MethodBase>(), args, out method); if (count != 0) return count; } method = null; return 0; } int FindIndexer(Type type, Expression[] args, out MethodBase method) { foreach (Type t in SelfAndBaseTypes(type)) { MemberInfo[] members = t.GetDefaultMembers(); if (members.Length != 0) { IEnumerable<MethodBase> methods = members. OfType<PropertyInfo>(). Select(p => (MethodBase)p.GetGetMethod()). Where(m => m != null); int count = FindBestMethod(methods, args, out method); if (count != 0) return count; } } method = null; return 0; } static IEnumerable<Type> SelfAndBaseTypes(Type type) { if (type.IsInterface) { List<Type> types = new List<Type>(); AddInterface(types, type); return types; } return SelfAndBaseClasses(type); } static IEnumerable<Type> SelfAndBaseClasses(Type type) { while (type != null) { yield return type; type = type.BaseType; } } static void AddInterface(List<Type> types, Type type) { if (!types.Contains(type)) { types.Add(type); foreach (Type t in type.GetInterfaces()) AddInterface(types, t); } } class MethodData { public MethodBase MethodBase; public ParameterInfo[] Parameters; public Expression[] Args; } int FindBestMethod(IEnumerable<MethodBase> methods, Expression[] args, out MethodBase method) { MethodData[] applicable = methods. Select(m => new MethodData { MethodBase = m, Parameters = m.GetParameters() }). Where(m => IsApplicable(m, args)). ToArray(); if (applicable.Length > 1) { applicable = applicable. Where(m => applicable.All(n => m == n || IsBetterThan(args, m, n))). ToArray(); } if (applicable.Length == 1) { MethodData md = applicable[0]; for (int i = 0; i < args.Length; i++) args[i] = md.Args[i]; method = md.MethodBase; } else { method = null; } return applicable.Length; } bool IsApplicable(MethodData method, Expression[] args) { if (method.Parameters.Length != args.Length) return false; Expression[] promotedArgs = new Expression[args.Length]; for (int i = 0; i < args.Length; i++) { ParameterInfo pi = method.Parameters[i]; if (pi.IsOut) return false; Expression promoted = PromoteExpression(args[i], pi.ParameterType, false); if (promoted == null) return false; promotedArgs[i] = promoted; } method.Args = promotedArgs; return true; } Expression PromoteExpression(Expression expr, Type type, bool exact) { if (expr.Type == type) return expr; if (expr is ConstantExpression) { ConstantExpression ce = (ConstantExpression)expr; if (ce == nullLiteral) { if (!type.IsValueType || IsNullableType(type)) return Expression.Constant(null, type); } else { string text; if (literals.TryGetValue(ce, out text)) { Type target = GetNonNullableType(type); Object value = null; switch (Type.GetTypeCode(ce.Type)) { case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Int64: case TypeCode.UInt64: value = ParseNumber(text, target); break; case TypeCode.Double: if (target == typeof(decimal)) value = ParseNumber(text, target); break; case TypeCode.String: value = ParseEnum(text, target); break; } if (value != null) return Expression.Constant(value, type); } } } if (IsCompatibleWith(expr.Type, type)) { if (type.IsValueType || exact) return Expression.Convert(expr, type); return expr; } return null; } static object ParseNumber(string text, Type type) { switch (Type.GetTypeCode(GetNonNullableType(type))) { case TypeCode.SByte: sbyte sb; if (sbyte.TryParse(text, out sb)) return sb; break; case TypeCode.Byte: byte b; if (byte.TryParse(text, out b)) return b; break; case TypeCode.Int16: short s; if (short.TryParse(text, out s)) return s; break; case TypeCode.UInt16: ushort us; if (ushort.TryParse(text, out us)) return us; break; case TypeCode.Int32: int i; if (int.TryParse(text, out i)) return i; break; case TypeCode.UInt32: uint ui; if (uint.TryParse(text, out ui)) return ui; break; case TypeCode.Int64: long l; if (long.TryParse(text, out l)) return l; break; case TypeCode.UInt64: ulong ul; if (ulong.TryParse(text, out ul)) return ul; break; case TypeCode.Single: float f; if (float.TryParse(text, out f)) return f; break; case TypeCode.Double: double d; if (double.TryParse(text, out d)) return d; break; case TypeCode.Decimal: decimal e; if (decimal.TryParse(text, out e)) return e; break; } return null; } static object ParseEnum(string name, Type type) { if (type.IsEnum) { MemberInfo[] memberInfos = type.FindMembers(MemberTypes.Field, BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static, Type.FilterNameIgnoreCase, name); if (memberInfos.Length != 0) return ((FieldInfo)memberInfos[0]).GetValue(null); } return null; } static bool IsCompatibleWith(Type source, Type target) { if (source == target) return true; if (!target.IsValueType) return target.IsAssignableFrom(source); Type st = GetNonNullableType(source); Type tt = GetNonNullableType(target); if (st != source && tt == target) return false; TypeCode sc = st.IsEnum ? TypeCode.Object : Type.GetTypeCode(st); TypeCode tc = tt.IsEnum ? TypeCode.Object : Type.GetTypeCode(tt); switch (sc) { case TypeCode.SByte: switch (tc) { case TypeCode.SByte: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.Byte: switch (tc) { case TypeCode.Byte: case TypeCode.Int16: case TypeCode.UInt16: case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Int64: case TypeCode.UInt64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.Int16: switch (tc) { case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.UInt16: switch (tc) { case TypeCode.UInt16: case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Int64: case TypeCode.UInt64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.Int32: switch (tc) { case TypeCode.Int32: case TypeCode.Int64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.UInt32: switch (tc) { case TypeCode.UInt32: case TypeCode.Int64: case TypeCode.UInt64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.Int64: switch (tc) { case TypeCode.Int64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.UInt64: switch (tc) { case TypeCode.UInt64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; } break; case TypeCode.Single: switch (tc) { case TypeCode.Single: case TypeCode.Double: return true; } break; default: if (st == tt) return true; break; } return false; } static bool IsBetterThan(Expression[] args, MethodData m1, MethodData m2) { bool better = false; for (int i = 0; i < args.Length; i++) { int c = CompareConversions(args[i].Type, m1.Parameters[i].ParameterType, m2.Parameters[i].ParameterType); if (c < 0) return false; if (c > 0) better = true; } return better; } // Return 1 if s -> t1 is a better conversion than s -> t2 // Return -1 if s -> t2 is a better conversion than s -> t1 // Return 0 if neither conversion is better static int CompareConversions(Type s, Type t1, Type t2) { if (t1 == t2) return 0; if (s == t1) return 1; if (s == t2) return -1; bool t1t2 = IsCompatibleWith(t1, t2); bool t2t1 = IsCompatibleWith(t2, t1); if (t1t2 && !t2t1) return 1; if (t2t1 && !t1t2) return -1; if (IsSignedIntegralType(t1) && IsUnsignedIntegralType(t2)) return 1; if (IsSignedIntegralType(t2) && IsUnsignedIntegralType(t1)) return -1; return 0; } Expression GenerateEqual(Expression left, Expression right) { return Expression.Equal(left, right); } Expression GenerateNotEqual(Expression left, Expression right) { return Expression.NotEqual(left, right); } Expression GenerateGreaterThan(Expression left, Expression right) { if (left.Type == typeof(string)) { return Expression.GreaterThan( GenerateStaticMethodCall("Compare", left, right), Expression.Constant(0) ); } return Expression.GreaterThan(left, right); } Expression GenerateGreaterThanEqual(Expression left, Expression right) { if (left.Type == typeof(string)) { return Expression.GreaterThanOrEqual( GenerateStaticMethodCall("Compare", left, right), Expression.Constant(0) ); } return Expression.GreaterThanOrEqual(left, right); } Expression GenerateLessThan(Expression left, Expression right) { if (left.Type == typeof(string)) { return Expression.LessThan( GenerateStaticMethodCall("Compare", left, right), Expression.Constant(0) ); } return Expression.LessThan(left, right); } Expression GenerateLessThanEqual(Expression left, Expression right) { if (left.Type == typeof(string)) { return Expression.LessThanOrEqual( GenerateStaticMethodCall("Compare", left, right), Expression.Constant(0) ); } return Expression.LessThanOrEqual(left, right); } Expression GenerateAdd(Expression left, Expression right) { if (left.Type == typeof(string) && right.Type == typeof(string)) { return GenerateStaticMethodCall("Concat", left, right); } return Expression.Add(left, right); } Expression GenerateSubtract(Expression left, Expression right) { return Expression.Subtract(left, right); } Expression GenerateStringConcat(Expression left, Expression right) { return Expression.Call( null, typeof(string).GetMethod("Concat", new[] { typeof(object), typeof(object) }), new[] { left, right }); } MethodInfo GetStaticMethod(string methodName, Expression left, Expression right) { return left.Type.GetMethod(methodName, new[] { left.Type, right.Type }); } Expression GenerateStaticMethodCall(string methodName, Expression left, Expression right) { return Expression.Call(null, GetStaticMethod(methodName, left, right), new[] { left, right }); } void SetTextPos(int pos) { textPos = pos; ch = textPos < textLen ? text[textPos] : '\0'; } void NextChar() { if (textPos < textLen) textPos++; ch = textPos < textLen ? text[textPos] : '\0'; } void NextToken() { while (Char.IsWhiteSpace(ch)) NextChar(); TokenId t; int tokenPos = textPos; switch (ch) { case '!': NextChar(); if (ch == '=') { NextChar(); t = TokenId.ExclamationEqual; } else { t = TokenId.Exclamation; } break; case '%': NextChar(); t = TokenId.Percent; break; case '&': NextChar(); if (ch == '&') { NextChar(); t = TokenId.DoubleAmphersand; } else { t = TokenId.Amphersand; } break; case '(': NextChar(); t = TokenId.OpenParen; break; case ')': NextChar(); t = TokenId.CloseParen; break; case '*': NextChar(); t = TokenId.Asterisk; break; case '+': NextChar(); t = TokenId.Plus; break; case ',': NextChar(); t = TokenId.Comma; break; case '-': NextChar(); t = TokenId.Minus; break; case '.': NextChar(); t = TokenId.Dot; break; case '/': NextChar(); t = TokenId.Slash; break; case ':': NextChar(); t = TokenId.Colon; break; case '<': NextChar(); if (ch == '=') { NextChar(); t = TokenId.LessThanEqual; } else if (ch == '>') { NextChar(); t = TokenId.LessGreater; } else { t = TokenId.LessThan; } break; case '=': NextChar(); if (ch == '=') { NextChar(); t = TokenId.DoubleEqual; } else { t = TokenId.Equal; } break; case '>': NextChar(); if (ch == '=') { NextChar(); t = TokenId.GreaterThanEqual; } else { t = TokenId.GreaterThan; } break; case '?': NextChar(); t = TokenId.Question; break; case '[': NextChar(); t = TokenId.OpenBracket; break; case ']': NextChar(); t = TokenId.CloseBracket; break; case '|': NextChar(); if (ch == '|') { NextChar(); t = TokenId.DoubleBar; } else { t = TokenId.Bar; } break; case '"': case '\'': char quote = ch; do { NextChar(); while (textPos < textLen && ch != quote) NextChar(); if (textPos == textLen) throw ParseError(textPos, Res.UnterminatedStringLiteral); NextChar(); } while (ch == quote); t = TokenId.StringLiteral; break; default: if (Char.IsLetter(ch) || ch == '@' || ch == '_') { do { NextChar(); } while (Char.IsLetterOrDigit(ch) || ch == '_'); t = TokenId.Identifier; break; } if (Char.IsDigit(ch)) { t = TokenId.IntegerLiteral; do { NextChar(); } while (Char.IsDigit(ch)); if (ch == '.') { t = TokenId.RealLiteral; NextChar(); ValidateDigit(); do { NextChar(); } while (Char.IsDigit(ch)); } if (ch == 'E' || ch == 'e') { t = TokenId.RealLiteral; NextChar(); if (ch == '+' || ch == '-') NextChar(); ValidateDigit(); do { NextChar(); } while (Char.IsDigit(ch)); } if (ch == 'F' || ch == 'f') NextChar(); break; } if (textPos == textLen) { t = TokenId.End; break; } throw ParseError(textPos, Res.InvalidCharacter, ch); } token.id = t; token.text = text.Substring(tokenPos, textPos - tokenPos); token.pos = tokenPos; } bool TokenIdentifierIs(string id) { return token.id == TokenId.Identifier && String.Equals(id, token.text, StringComparison.OrdinalIgnoreCase); } string GetIdentifier() { ValidateToken(TokenId.Identifier, Res.IdentifierExpected); string id = token.text; if (id.Length > 1 && id[0] == '@') id = id.Substring(1); return id; } void ValidateDigit() { if (!Char.IsDigit(ch)) throw ParseError(textPos, Res.DigitExpected); } void ValidateToken(TokenId t, string errorMessage) { if (token.id != t) throw ParseError(errorMessage); } void ValidateToken(TokenId t) { if (token.id != t) throw ParseError(Res.SyntaxError); } Exception ParseError(string format, params object[] args) { return ParseError(token.pos, format, args); } Exception ParseError(int pos, string format, params object[] args) { return new ParseException(string.Format(System.Globalization.CultureInfo.CurrentCulture, format, args), pos); } static Dictionary<string, object> CreateKeywords() { Dictionary<string, object> d = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); d.Add("true", trueLiteral); d.Add("false", falseLiteral); d.Add("null", nullLiteral); d.Add(keywordIt, keywordIt); d.Add(keywordIif, keywordIif); d.Add(keywordNew, keywordNew); foreach (Type type in predefinedTypes) d.Add(type.Name, type); return d; } } static class Res { public const string DuplicateIdentifier = "The identifier '{0}' was defined more than once"; public const string ExpressionTypeMismatch = "Expression of type '{0}' expected"; public const string ExpressionExpected = "Expression expected"; public const string InvalidCharacterLiteral = "Character literal must contain exactly one character"; public const string InvalidIntegerLiteral = "Invalid integer literal '{0}'"; public const string InvalidRealLiteral = "Invalid real literal '{0}'"; public const string UnknownIdentifier = "Unknown identifier '{0}'"; public const string NoItInScope = "No 'it' is in scope"; public const string IifRequiresThreeArgs = "The 'iif' function requires three arguments"; public const string FirstExprMustBeBool = "The first expression must be of type 'Boolean'"; public const string BothTypesConvertToOther = "Both of the types '{0}' and '{1}' convert to the other"; public const string NeitherTypeConvertsToOther = "Neither of the types '{0}' and '{1}' converts to the other"; public const string MissingAsClause = "Expression is missing an 'as' clause"; public const string ArgsIncompatibleWithLambda = "Argument list incompatible with lambda expression"; public const string TypeHasNoNullableForm = "Type '{0}' has no nullable form"; public const string NoMatchingConstructor = "No matching constructor in type '{0}'"; public const string AmbiguousConstructorInvocation = "Ambiguous invocation of '{0}' constructor"; public const string CannotConvertValue = "A value of type '{0}' cannot be converted to type '{1}'"; public const string NoApplicableMethod = "No applicable method '{0}' exists in type '{1}'"; public const string MethodsAreInaccessible = "Methods on type '{0}' are not accessible"; public const string MethodIsVoid = "Method '{0}' in type '{1}' does not return a value"; public const string AmbiguousMethodInvocation = "Ambiguous invocation of method '{0}' in type '{1}'"; public const string UnknownPropertyOrField = "No property or field '{0}' exists in type '{1}'"; public const string NoApplicableAggregate = "No applicable aggregate method '{0}' exists"; public const string CannotIndexMultiDimArray = "Indexing of multi-dimensional arrays is not supported"; public const string InvalidIndex = "Array index must be an integer expression"; public const string NoApplicableIndexer = "No applicable indexer exists in type '{0}'"; public const string AmbiguousIndexerInvocation = "Ambiguous invocation of indexer in type '{0}'"; public const string IncompatibleOperand = "Operator '{0}' incompatible with operand type '{1}'"; public const string IncompatibleOperands = "Operator '{0}' incompatible with operand types '{1}' and '{2}'"; public const string UnterminatedStringLiteral = "Unterminated string literal"; public const string InvalidCharacter = "Syntax error '{0}'"; public const string DigitExpected = "Digit expected"; public const string SyntaxError = "Syntax error"; public const string TokenExpected = "{0} expected"; public const string ParseExceptionFormat = "{0} (at index {1})"; public const string ColonExpected = "':' expected"; public const string OpenParenExpected = "'(' expected"; public const string CloseParenOrOperatorExpected = "')' or operator expected"; public const string CloseParenOrCommaExpected = "')' or ',' expected"; public const string DotOrOpenParenExpected = "'.' or '(' expected"; public const string OpenBracketExpected = "'[' expected"; public const string CloseBracketOrCommaExpected = "']' or ',' expected"; public const string IdentifierExpected = "Identifier expected"; }

public class ImageMap : EntityTypeConfiguration<ImageModel> { public ImageMap() { // Primary Key this.HasKey(t => t.ID); // Properties this.Property(t => t.IDProofFront) .HasMaxLength(100); this.Property(t => t.IDProofBack) .HasMaxLength(100); // Table & Column Mappings this.ToTable("ImageModel"); this.Property(t => t.ID).HasColumnName("ID"); this.Property(t => t.IDProofFront).HasColumnName("IDProofFront"); this.Property(t => t.IDProofBack).HasColumnName("IDProofBack"); } }

public ResourcesImage() { } /// <summary> /// 上传身份信息采用此种方式 /// </summary> /// <param name="IDProofBack"></param> /// <param name="IDProofBack"></param> /// <param name="pId"></param> /// <returns></returns> public bool UpdateIDProof(string IDProofFront, string IDProofBack, int pId) { int flag = 0; if (IDProofFront != "" && IDProofFront != null) { flag = this.Update(m => m.ID == pId, u => new ImageModel { IDProofFront = IDProofFront }); if (flag == 1) { if (IDProofBack != "" && IDProofBack != null) flag = this.Update(m => m.ID == pId, u => new ImageModel { IDProofBack = IDProofBack }); } } else { if (IDProofBack != "" && IDProofBack != null) flag = this.Update(m => m.ID == pId, u => new ImageModel { IDProofBack = IDProofBack }); } return flag == 0 ? false : true; }

private readonly IResourcesImage _resourcesImage; public CodeBLL() { this._resourcesImage = new ResourcesImage(); } /// <summary> /// 根据字段更新用户的文件资料信息 /// </summary> /// <param name="fileNameField">字段</param> /// <param name="fileNameValue">字段值</param> /// <param name="pId"></param> /// <returns></returns> public bool UpdateFileName(string IDProofFront, string IDProofBack, int pId) { bool flag = false; flag = _resourcesImage.UpdateIDProof(IDProofFront, IDProofBack, pId); return flag; }

相关阅读