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">  <div class="full_w" style="margin-top: 100px; margin-left: 30%; width: 800px;">   <div class="h_title"> <b>用户上传的文件</b></div>   <div class="entry">    步骤： <span class="red" style="color: red">(上传资料必须是bmp,gif,jpg,jpeg,png类型,不能大于2M)</span>    <ol>     <li>先按『选择』键选择上传文件；</li>     <li>按『上传』键上传文件；</li>     <li>按『保存』键保存文件；</li>    </ol>   </div>   <div class="entry">    <div class="sep"></div>   </div>   <div class="entry">    <div id="wrapper" style="text-align: center; position: relative;">     <div 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;" />     </div>    </div>   </div>   <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>   <div 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>   </div>  </div> </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");  }); }

 $(function () {  initFileUpload();})

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

 <add key="FileSizem" value="10"></add> <add key="FileType" value=".bmp;.gif;.jpg;.jpeg;.png;.pdf" /> <!---本地测试--> <add key="IPaddress" value="路径" /> <!--FTP上传文件的帐号--> <add key="UserName" value="账号" /> <!--FTP上传文件的密码--> <add key="Password" value="密码" /> <!--后台显示图片地址--> <add key="PathSrc" value="路径" />

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);      }    }  }

<connectionStrings>  <add name="DbContext" providerName="System.Data.SqlClient" connectionString="Server=.;Database=Test;Uid=sa;Pwd=sa;"/> </connectionStrings>

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.Divide(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");    }  }

bool UpdateIDProof(string IDProofFront, string IDProofBack, int pId);

 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;    }