前言
此篇讲到的是 图片上传 功能，每个网站必定会有这样类似的功能，上传文件、上传图片等等。那么接下来，看看我们ef+uploadfile+ ftp 如何玩转上传图片吧
效果预览
具体实现
一个简单数据库 只有一个主键id，一个身份证正面路径和一个身份证背面路径三个字段。
首先呢，我们把实体类新建好如下：
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 ; }
}
其中 我们将身份信息实体继承自baseentity,我们看看baseentity里面是什么东东，代码如下：
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);
}
}
这里，我们将baseentity定义成一个抽象类，里面包含一些静态方法和重载方法
======================回到html=======
我们先回过头来讲页面，上面演示的是一个很简单的单页面，html代码如下：
<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>
现在我们看页面将会毫无样式，所以我们先引用下样式，这里引用了bootstrap 和一个 style2.css ，引入样式后 界面如下：
其中，关于选择框是用了一个js单独封装起来了，是代码中的zh.js，代码如下：
/*!
* 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测试数据/kartik-v/bootstrap-fileinput
* @author kangqf <kangqingfei@gmail测试数据>
*
* 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);
好了，界面大概就整成这样子，现在需要我们实现功能了。首先用js将上传控件初始化一下：
//上传控件初始化
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();
})
ftp上传操作
注意，再initfileupload方法中 上传了图片，会自动访问uploadurl 这个url地址，存放图片，我们先看看这个action如何通过ftp上传指定服务器的。
fileupload方法如下
/// <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 = "网络异常，请稍后再试" });
}
}
其中 _fileextension _filepath _filesize 是分别从配置文件中读取出来的如下：
private static string _fileextension = configurationmanager.appsettings[ "filetype" ];
private readonly string _filepath = configurationmanager.appsettings[ "uploadpath" ];
private readonly string _filesize = configurationmanager.appsettings[ "filesizem" ];
方法中有一个 fileupload 上传文件的方法 如下：
/// <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 ;
}
}
其中
ftpupfile 是一个ftp上传文件帮助类，大家可以直接照搬 ，代码如下：
/// <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测试数据positingquality = 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测试数据positingquality = 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
}
然后我们通过在fileuploaded的回调函数中绑定url即可显示上传后的图片，效果如下图：
不过这个只是上传到ftp服务器上了，并没有保存到数据库，现在我们要做的就是通过ef的方式将上传的图片保存到数据库。
保存图片
首先我们要建一个操作的接口基类，并且还要约束成baseentity,代码如下
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测试数据mit();
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测试数据mon.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测试数据mandtext = 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测试数据mandtype = 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;
}
}
}
注意，我们在
这个实现类中定义了一个私有方法，指明了数据库访问的上下文dbcontext
dbcontext类如下：
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);
}
}
}
我们将name=dbcontext 意思是去寻找webconfig中具有相同名称的值 ，所以，我们在配置文件中配置该项如下：
再configuration节点下面新建
<connectionstrings>
<add name= "dbcontext" providername= "system.data.sqlclient" connectionstring= "server=.;database=test;uid=sa;pwd=sa;" />
</connectionstrings>
忘了说，这里对实现类中的一些扩展方法做了延伸，新建一个dynamicqueryable类，代码如下：
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测试数据ma) 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测试数据ma) 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测试数据ma) 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测试数据ma;
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" ;
}
此时，我们需要将我们的实体和数据库字段映射对应起来，新建一个imagemap类代码如下：
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" );
}
}
其中totable就是指明数据库表名，
那么如何将上传的图片保存更新到数据库呢？
接下来我们新建一个接口类iresourcesimage 并继承操作基类 irepository<imagemodel>
定义一个上传身份信息的规则如下：
bool updateidproof( string idprooffront, string idproofback, int pid);
接下来我们新建一个resourcesimage 实现上述接口。代码如下：
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;
}
这样做其实并不科学，需要手动实例化这种仓储操作，科学的方式可以使用ioc（控制反转）.
中间层做好之后，我们只需要在homecontroller中调用此方法即可，代码如下：
至此，我们就实现了本地通过ftp方式上传图片代码，并将图片以相对路径保存在数据库中，数据库存放格式如下：
demo下载
git下载
以上所述是小编给大家介绍的c# 中实现ftp 图片上传功能，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
原文链接：http://HdhCmsTestcnblogs测试数据/zhangxiaoyong/p/7018616.html
dy("nrwz");
查看更多关于C# 中实现ftp 图片上传功能(多快好省)的详细内容...