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

本文主要是介绍用 System.Reflection.Emit 来自动生成调用储存过程的实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

/****************************************************************/
*
* 用 System.Reflection.Emit 来自动生成调用储存过程的实现！
*
* By http://lostinet.com
*
* Copyrights : Not-Reversed
*
/****************************************************************/

//使用的例子
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

这篇关于用 System.Reflection.Emit 来自动生成调用储存过程的实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！