用 System.Reflection.Emit 来自动生成调用存储过程的实现

 

//使用的例子
namespace Lostinet.Sample
...{
using System;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms;

//定义一个接口，用于定义存储过程

interface INorthwindStoredProcedures
...{
//定义存储过程对应的方法

DataSet CustOrderHist(string CustomerID);

//如果储存过程名字和方法名字不同，应该用SqlAccessAttribute来进行说明
[SqlAccess("Employee Sales By Country")]
DataTable EmployeeSalesByCountry(DateTime Beginning_Date,DateTime Ending_Date);

//...more...

//MORE Ideas..

//直接执行SQL语句？
//[SqlAccess(SqlAccessType.SqlQuery,"SELECT * FROM Employees WHERE EmployeeID=@EmpId")]
//DataTable SelectEmployee(int EmpId);
}

class ConsoleApplication
...{
[STAThread]
static void Main(string[] args)
...{
using(SqlConnection conn=new SqlConnection("server=(local);trusted_connection=true;database=northwind"))
...{
//一句话就把实现创建了！
//需要传如 SqlConnection 和 SqlTransaction
//SqlTransaction可以为null

//这个好就好在，只要能得到SqlConnection/SqlTransaction就能用这个方法了，所以兼容 Lostinet.Data.SqlScope
INorthwindStoredProcedures nsp=(INorthwindStoredProcedures)
StoredProcedure.CreateStoredProcedureInterface(typeof(INorthwindStoredProcedures),conn,null);

//调用储存过程并且显示

ShowData("CustOrderHist ALFKI",nsp.CustOrderHist("ALFKI"));

ShowData("Employee Sales By Country",nsp.EmployeeSalesByCountry(new DateTime(1998,1,1),new DateTime(1999,1,1)));

}
}

static void ShowData(string title,object data)
...{
Form f=new Form();
f.Width=600;
f.Height=480;
f.Text=title;

DataGrid grid=new DataGrid(); 
grid.Dock=DockStyle.Fill;
grid.DataSource=data;

f.Controls.Add(grid);
f.ShowDialog();
}

}
}

//实现方法（不完整）#region //实现方法（不完整）
namespace Lostinet.Sample
...{
using System;
using System.Collections;
using System.Reflection;
using System.Reflection.Emit;
using System.Data;
using System.Data.SqlClient;

//这个类作为实现的基类，
//目的是提供储存 SqlConnection/SqlTransaction 和公用的一些方法
//这个类必须为public,否则无法继承
//但开发者不会显式访问这个类
public class SPInterfaceBase : IDisposable
...{
public SPInterfaceBase()
...{
}

public void Dispose()
...{
}

//CreateStoredProcedureInterface会把相关的值SqlConnection/SqlTransaction存到这里
public SqlConnection connection;
public SqlTransaction transaction;

//创建一个SqlCommand
public SqlCommand CreateCommand(string spname)
...{
SqlCommand cmd=new SqlCommand(spname,connection,transaction);
cmd.CommandType=CommandType.StoredProcedure;
//TODO:
//cmd.Parameters.Add("@ReturnValue",...
return cmd;
}

//由 Type 推算出 SqlDbType ， 未完成
SqlDbType GetSqlDbType(Type type)
...{
//TODO:switch(type)...

return SqlDbType.NVarChar;
}

//定义参数
public void DefineParameter(SqlCommand cmd,string name,Type type,ParameterDirection direction)
...{
SqlParameter param=new SqlParameter("@"+name,GetSqlDbType(type));
param.Direction=direction;
cmd.Parameters.Add(param);
}

//在SqlCommand执行前设置参数值
public void SetParameter(SqlCommand cmd,string name,object value)
...{
cmd.Parameters["@"+name].Value=(value==null?DBNull.Value:value);
}
//在SqlCommand执行后取得参数值
public object GetParameter(SqlCommand cmd,string name)
...{
return cmd.Parameters["@"+name].Value;
}

//根据不同的返回值执行不同的操作

public SqlDataReader ExecuteDataReader(SqlCommand cmd)
...{
return cmd.ExecuteReader();
}
public object ExecuteScalar(SqlCommand cmd)
...{
return cmd.ExecuteScalar();
}
public void ExecuteNonQuery(SqlCommand cmd)
...{
cmd.ExecuteNonQuery();
}
public DataSet ExecuteDataSet(SqlCommand cmd)
...{
DataSet ds=new DataSet();
using(SqlDataAdapter sda=new SqlDataAdapter(cmd))
...{
sda.Fill(ds);
}
return ds;
}
public DataTable ExecuteDataTable(SqlCommand cmd)
...{
DataTable table=new DataTable();
using(SqlDataAdapter sda=new SqlDataAdapter(cmd))
...{
sda.Fill(table);
}
return table;
}
public DataRow ExecuteDataRow(SqlCommand cmd)
...{
DataTable table=ExecuteDataTable(cmd);
if(table.Rows.Count==0)
return null;
return table.Rows[0];
}
}


public class StoredProcedure
...{
static public object CreateStoredProcedureInterface(Type interfaceType,SqlConnection connection,SqlTransaction transaction)
...{
//检查参数
if(interfaceType==null)throw(new ArgumentNullException("interfaceType"));
if(!interfaceType.IsInterface)
throw(new ArgumentException("argument is not interface","interfaceType"));
if(connection==null)throw(new ArgumentNullException("connection"));
if(transaction!=null)
...{
if(transaction.Connection!=connection)
throw(new ArgumentException("transaction.Connection!=connection","transaction"));
}

//创建StoredProcedure

StoredProcedure spemit=new StoredProcedure();
spemit.interfaceType=interfaceType;
spemit.connection=connection;
spemit.transaction=transaction;

//创建
return spemit.CreateInstance();
}

//用于储存已创建的类型
static Hashtable EmittedTypes=new Hashtable();

Type interfaceType;
SqlConnection connection;
SqlTransaction transaction;

private StoredProcedure()
...{
}

object CreateInstance()
...{
lock(interfaceType)
...{
//如果没有创建具体的实现，则创建它

if(emittedType==null)
...{
emittedType=(Type)EmittedTypes[interfaceType];

if(emittedType==null)
...{
CreateType();

//储存已创建类型
EmittedTypes[interfaceType]=emittedType;
}
}
}

//创建具体的实例
SPInterfaceBase spi=(SPInterfaceBase)Activator.CreateInstance(emittedType);

//设置SqlConnection/SqlTransaction
spi.connection=connection;
spi.transaction=transaction;

return spi;
}

Type emittedType;

TypeBuilder typeBuilder;

//创建类型
void CreateType()
...{
//创建 Assembly
//AssemblyBuilderAccess.Run-表示只用于运行，不在磁盘上保存
AssemblyName an=new AssemblyName();
an.Name="Assembly."+interfaceType.FullName+".Implementation";
AssemblyBuilder asmBuilder=AppDomain.CurrentDomain.DefineDynamicAssembly(an,AssemblyBuilderAccess.Run);

//创建Module
ModuleBuilder mdlBuilder=asmBuilder.DefineDynamicModule("Module."+interfaceType.FullName+".Implementation");

//创建Type，该类型继承 SPInterfaceBase
typeBuilder=mdlBuilder.DefineType(interfaceType.FullName+".Implementation",TypeAttributes.Class,typeof(SPInterfaceBase));

//实现所有的接口方法
EmitInterface(interfaceType);

//如果interfaceType是基于其他接口的
foreach(Type subinterface in interfaceType.GetInterfaces())
...{
//IDisposable不需要实现，由SPInterfaceBase实现了
if(subinterface==typeof(IDisposable))
continue;

EmitInterface(subinterface);
}


emittedType=typeBuilder.CreateType();
}

void EmitInterface(Type type)
...{
//实现接口
typeBuilder.AddInterfaceImplementation(type);

//列出接口的成员
foreach(MemberInfo member in type.GetMembers(BindingFlags.Instance|BindingFlags.Public))
...{
//约定-成员必须是方法，不能有属性啊，事件之类的
if(member.MemberType!=MemberTypes.Method)
throw(new Exception("Could Not Emit "+member.MemberType+" Automatically!"));

//取得接口中定义的方法
MethodInfo method=(MethodInfo)member;

//计算新方法的属性，在原来方法的属性上复制过来，并且不是Public/Abstract，加上Private
MethodAttributes methodattrs=method.Attributes;
methodattrs&=~(MethodAttributes.Public|MethodAttributes.Abstract);
methodattrs|=MethodAttributes.Private;


ParameterInfo[] paramInfos=method.GetParameters();
int paramlength=paramInfos.Length;

//取得参数的类型数组
Type[] paramTypes=new Type[paramlength];
for(int i=0;i<paramlength;i++)
...{
paramTypes[i]=paramInfos[i].ParameterType;
}

//在typeBuilder上建立新方法，参数类型与返回类型都与接口上的方法一致
MethodBuilder mthBuilder=typeBuilder.DefineMethod(method.Name,methodattrs,method.CallingConvention,method.ReturnType,paramTypes);

//复制新方法上的参数的名字和属性
for(int i=0;i<paramlength;i++)
...{
ParameterInfo pi=paramInfos[i];
//对于Instance,参数position由1开始
mthBuilder.DefineParameter(i+1,pi.Attributes,pi.Name);
}

//指定新方法是实现接口的方法的。
typeBuilder.DefineMethodOverride(mthBuilder,method);

//在类型上定义一个字段，这个字段用于储存被方法使用的SqlCommand
FieldBuilder field_cmd=typeBuilder.DefineField("_cmd_"+method.Name,typeof(SqlCommand),FieldAttributes.Private);

//ILGenerator 是用于生成实现代码的对象
ILGenerator ilg=mthBuilder.GetILGenerator();

//定义临时变量
LocalBuilder local_res=ilg.DeclareLocal(typeof(object));

//定义一个用于跳转的Label
Label label_cmd_ready=ilg.DefineLabel();

//this._cmd_MethodName
ilg.Emit(OpCodes.Ldarg_0); //this
ilg.Emit(OpCodes.Ldfld,field_cmd);//._cmd_MethodName

//if(this._cmd_MethodName!=null) 跳到 label_cmd_ready
ilg.Emit(OpCodes.Brtrue,label_cmd_ready);

//如果this._cmd_MethodName为null，则运行下面代码来创建SqlCommand



//this._cmd_MethodName=this.CreateCommand("MethodName");
ilg.Emit(OpCodes.Ldarg_0);

//this.CreateCommand
ilg.Emit(OpCodes.Ldarg_0);//参数0
ilg.Emit(OpCodes.Ldstr,SqlAccessAttribute.GetSPName(method));//参数1
//调用
ilg.Emit(OpCodes.Callvirt,typeof(SPInterfaceBase).GetMethod("CreateCommand",BindingFlags.Instance|BindingFlags.Public));

ilg.Emit(OpCodes.Stfld,field_cmd);// ._cmd_MethodName=

//this.DefineParameter(...)
if(paramlength!=0)
...{
//取得DefineParameter的引用
MethodInfo method_DefineParameter=typeof(SPInterfaceBase).GetMethod("DefineParameter",BindingFlags.Instance|BindingFlags.Public);

for(int i=0;i<paramlength;i++)
...{
//取得各参数
ParameterInfo pi=paramInfos[i];

//this.DefineParameter(this._cmd_MethodName,"ParameterName",typeof(ParameterType),ParameterDirection.Xxx);

//参数0 - this
ilg.Emit(OpCodes.Ldarg_0);

//参数1 - this._cmd_MethodName
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld,field_cmd);

//参数2 - "ParameterName"
ilg.Emit(OpCodes.Ldstr,pi.Name);

//参数3 - typeof(ParameterType)
ilg.Emit(OpCodes.Ldtoken,pi.ParameterType);

//参数4 - ParameterDirection.Xxx
if(pi.ParameterType.IsByRef)
...{
ilg.Emit(OpCodes.Ldc_I4,(int)ParameterDirection.InputOutput);
}
else if(pi.IsOut)
...{
ilg.Emit(OpCodes.Ldc_I4,(int)ParameterDirection.Output);
}
else
...{
ilg.Emit(OpCodes.Ldc_I4,(int)ParameterDirection.Input);
}

//调用DefineParameter
ilg.Emit(OpCodes.Callvirt,method_DefineParameter);
}
}
//到这里 _cmd_CommandName 已经 OK 了。

//设置label_cmd_ready就指这里
ilg.MarkLabel(label_cmd_ready);

//cmd!=null now.

if(paramlength!=0)
...{
//现在要把方法的参数的值设置到SqlParameter上

MethodInfo method_SetParameter=typeof(SPInterfaceBase).GetMethod("SetParameter",BindingFlags.Instance|BindingFlags.Public);

for(int i=0;i<paramlength;i++)
...{
ParameterInfo pi=paramInfos[i];

//如果参数是 out 的，则不需要设置
if(!pi.ParameterType.IsByRef&&pi.IsOut)
continue;

//this.SetParameter(this._cmd_MethodName,"ParameterName",ParameterName);

ilg.Emit(OpCodes.Ldarg_0);

ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld,field_cmd);

ilg.Emit(OpCodes.Ldstr,pi.Name);

//取得参数值，如果参数为ValueType，则Box到Object
ilg.Emit(OpCodes.Ldarg,i+1);
if(pi.ParameterType.IsValueType)
ilg.Emit(OpCodes.Box,pi.ParameterType);

ilg.Emit(OpCodes.Callvirt,method_SetParameter);
}
}

//现在要执行储存过程（执行SqlCommand）了

//这里根据返回值类型判断怎样执行SqlCommand

Type returnType=method.ReturnType;

//如果是 void 的，则不需要返回值
bool nores=returnType==typeof(void);

MethodInfo method_Execute=null;

if(nores)
...{
//不需要返回值
method_Execute=typeof(SPInterfaceBase).GetMethod("ExecuteNonQuery",BindingFlags.Instance|BindingFlags.Public);
}
else if(returnType==typeof(object))
...{
//返回object
method_Execute=typeof(SPInterfaceBase).GetMethod("ExecuteScalar",BindingFlags.Instance|BindingFlags.Public);
}
else if(returnType==typeof(DataSet))
...{
//返回DataSet
method_Execute=typeof(SPInterfaceBase).GetMethod("ExecuteDataSet",BindingFlags.Instance|BindingFlags.Public);
}
else if(returnType==typeof(DataTable))
...{
//返回DataTable
method_Execute=typeof(SPInterfaceBase).GetMethod("ExecuteDataTable",BindingFlags.Instance|BindingFlags.Public);
}
else if(returnType==typeof(DataRow))
...{
//返回DataRow
method_Execute=typeof(SPInterfaceBase).GetMethod("ExecuteDataRow",BindingFlags.Instance|BindingFlags.Public);
}
else
...{
//返回其他类型
foreach(Type retInterface in returnType.GetInterfaces())
...{
//如果是返回IDataReader
if(retInterface==typeof(IDataReader))
...{
//只支持SqlDataReader
if(!returnType.IsAssignableFrom(typeof(SqlDataReader)))
throw(new Exception("SqlDataReader could not convert to "+returnType.FullName));

method_Execute=typeof(SPInterfaceBase).GetMethod("ExecuteDataReader",BindingFlags.Instance|BindingFlags.Public);
break;
}
}
}

//如果找不到适合的策略，
if(method_Execute==null)
...{
//TODO:当然，这里应该有返回Int32,String,...的，不过懒得再写了。

//抛出异常，提示不支持该返回类型，要作者改改：）
throw(new NotSupportedException("NotSupport ReturnType:"+returnType.FullName));
}

//this.ExecuteXXX(this._cmd_MethodName)
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld,field_cmd);
ilg.Emit(OpCodes.Callvirt,method_Execute);

//如果有返回值的，则是
//local_res=this.ExecuteXXX(this._cmd_MethodName)
if(!nores)
...{
if(returnType.IsValueType)
ilg.Emit(OpCodes.Box,returnType);
ilg.Emit(OpCodes.Stloc,local_res);
}

if(paramlength!=0)
...{
//这里处理ref/out的参数
MethodInfo method_GetParameter=typeof(SPInterfaceBase).GetMethod("GetParameter",BindingFlags.Instance|BindingFlags.Public);

for(int i=0;i<paramlength;i++)
...{
ParameterInfo pi=paramInfos[i];

//如果不是ref/out则跳过
if(!pi.ParameterType.IsByRef&&!pi.IsOut)
continue;

//ParameterName=this.GetParameter(this._cmd_Methodname,"ParameterName")
ilg.Emit(OpCodes.Ldarg_0);

ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld,field_cmd);

ilg.Emit(OpCodes.Ldstr,pi.Name);

ilg.Emit(OpCodes.Callvirt,method_GetParameter);

//如果类型是值类型，则需要 Unbox
if(pi.ParameterType.IsValueType)
ilg.Emit(OpCodes.Unbox,pi.ParameterType);

ilg.Emit(OpCodes.Starg,i+1); 
}
}

//如果是 void , 则直接 return;
//否者是 return local_res ， 如果返回值类型是ValueType，则需要Unbox
if(!nores)
...{
ilg.Emit(OpCodes.Ldloc,local_res);
if(returnType.IsValueType)
ilg.Emit(OpCodes.Unbox,returnType);
}
ilg.Emit(OpCodes.Ret);

// //throw(new NotImplementedException());
// ilg.Emit(OpCodes.Newobj,typeof(NotImplementedException).GetConstructor(new Type[0]));
// ilg.Emit(OpCodes.Throw);

}
}
}

public enum SqlAccessType
...{
StoredProcedure
//TODO:
//,SqlQuery
}

[AttributeUsage(AttributeTargets.Method)]
public class SqlAccessAttribute : Attribute
...{
string _sp;

public SqlAccessAttribute(string spname)
...{
_sp=spname;
}

public string StoreProcedure
...{
get
...{
return _sp;
}
}

static public string GetSPName(MethodInfo method)
...{
if(method==null)throw(new ArgumentNullException("method"));

object[] attrs=method.GetCustomAttributes(typeof(SqlAccessAttribute),false);
if(attrs==null||attrs.Length==0)
return method.Name;

return ((SqlAccessAttribute)attrs[0]).StoreProcedure;
}

//TODO:
// public SqlAccessAttribute(SqlAccessType type,string text)
// {
//
// }
}

}
#endregion