自己写ORM框架 SqlHelper_DG C#（java的写在链接里）

ORM框架想必大家都比较熟知了，即对象关系映射（英语：Object Relation Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。 当你开发一个应用程序的时候(不使用O/R MAPPING),你可能会写不少数据访问层的代码，用来从数据库保存，删除，读取对象信息，等等。

现在流行的ORM框架有：

JAVA系列：APACHE OJB，CAYENNE，JAXOR，JPA，HIBERNATE，IBATIS/MYBATIS，JRELATIONALFRAMEWORK，SMYLE，TOPLINK等

其中 TOPLINK 是 ORACLE 的商业产品，其他均为开源项目。其中 HIBERNATE的轻量级 ORM 模型逐步确立了在 JAVA ORM 架构中领导地位，甚至取代复杂而又繁琐的 EJB 模型而成为事实上的 JAVA ORM 工业标准。

.NET系列：EF（ENTITY FRAMWORK），NHIBERNATE，Ibits，ENTITYSCODEGENERATE，LINQ TOSQL，GROVE，RUNGOO.ENTERPRISEORM，FIRECODE CREATOR，MYGENERATION，CODESMITH PRO，CODEAUTO等

微软VS中自带的有EF（ENTITY FRAMWORK）框架。

---

你在DAL中写了很多的方法来读取对象数据，改变状态对象等等任务。而这些代码写起来总是重复的。我们可不可以写一个类来封装这些重复的劳动呢？

想必大家都有曾经想过写SqlHelper吧，实际上，从SqlHelper一步步写下来，封装到足够好之后，就会成为一个自己专属的ORM框架了。

在这里，小编写了一个很基础的类ORM的SqlHelper里面仅仅对Select查询语句进行了封装，由于考虑到了反射机制的诟病（这里不再讨论，关于反射效率问题有大多数的讨论，利与弊总是同时存在的，我们不纠结于这点）。对于常见的CRUD来说，CUD通常一个方法可以实现，并且Sql语句可以得到更大的封装结合配置文件和反射机制进行操作。小编这里采用的模式是SqlServer+SqlHelper+代码生成器（需要代码生成器的可以联系本人,不定期更新）来完成的代码编写工作，因此没有对CUD进行大量的封装，同时也提高了执行效率（你懂的）。

接下来我贴上我的代码（里面注释采用中文注释，比较完善有不懂的可以咨询本人）:

 public static readonly string ConnString = ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;

这里的读取数据库连接字符串采用在配置文件中读取的方式，需要在配置文件中进行配置一个连接名称为"ConStr"的连接字符串。如下Appconfig.XML：（这里配置为本机）

 <connectionStrings>
     <add name="ConStr" connectionString="Data Source=.;Initial Catalog=db_Test;Integrated Security=True"/>
 </connectionStrings>

内部的一些主要方法介绍：

ExecuteNonQuery 执行sql命令，返回受影响的行数。 一般用作CUD操作

ExecuteScalar 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）不带参数

ExecuteReader 执行sql语句或存储过程 返回DataReader

ExecuteDataSet 执行sql语句或存储过程，返回DataSet

public static List<T> ReturnListByModels<T>(DataSet ds) 反射返回一个List T 类型的结果集 如List<User> 用于Reader操作

public static T ReturnModelByModels<T>(SqlDataReader reader) 反射返回一个T类型的结果 如User 用于Reader操作

SqlHelper_DG代码如下：

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Configuration;
 using System.Data;
 using System.Data.SqlClient;
 using System.Reflection;

 namespace SqlHelper_Framework4_5_DG
 {
     /// <summary>
     /// SqlHelper
     /// 此类为抽象类，不允许实例化，在应用时直接调用即可;
     /// author qixiao（DG）;
     /// release Time :20160506;
     /// </summary>
     public abstract class SqlHelper_DG
     {
         #region ConStr链接字符串---ConStr链接字符串声明
         /// <summary>
         /// 连接字符串 ConnString 公共静态只读 不允许进行修改 在后续调用中目前不支持代码修改链接字符串--DG
         /// </summary>
         public static readonly string ConnString = ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;
         #endregion

         #region ExcuteNonQuery 执行sql语句或者存储过程,返回影响的行数---ExcuteNonQuery
         /// <summary>
         /// 执行sql语句或存储过程，返回受影响的行数,不带参数。--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
         /// <returns>返回受影响的行数</returns>
         public static int ExecuteNonQuery(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType);//参数增加了commandType 可以自己编辑执行方式
                         return cmd.ExecuteNonQuery();
                     }
                 }
             }
             catch (Exception)
             {
                 return default(int);
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程，返回受影响的行数。--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型 t</param>
         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
         /// <returns>返回受影响的行数</returns>
         public static int ExecuteNonQuery(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);//参数增加了commandType 可以自己编辑执行方式
                         return cmd.ExecuteNonQuery();
                     }
                 }
             }
             catch (Exception)
             {
                 return default(int);
             }

         }
         /// <summary>
         /// 执行sql命令，返回受影响的行数。--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型</param>
         /// <param name="obj">object[]参数数组，允许空</param>
         /// <returns>返回受影响的行数</returns>
         public static int ExecuteNonQuery(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);//参数增加了commandType 可以自己编辑执行方式
                         return cmd.ExecuteNonQuery();
                     }
                 }
             }
             catch (Exception)
             {
                 return default(int);
             }

         }
         #endregion

         #region ExecuteScalar 执行sql语句或者存储过程,执行单条语句，返回自增的id---ScalarExecuteScalar
         /// <summary>
         /// 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）不带参数--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
         /// <returns></returns>
         public static object ExecuteScalar(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType);
                         return cmd.ExecuteScalar();
                     }

                 }
             }
             catch (Exception)
             {
                 return default(int);
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型</param>
         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
         /// <returns></returns>
         public static object ExecuteScalar(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);
                         return cmd.ExecuteScalar();
                     }

                 }
             }
             catch (Exception)
             {
                 return default(int);
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型</param>
         /// <param name="obj">object[]参数数组，允许空</param>
         /// <returns></returns>
         public static object ExecuteScalar(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);
                         return cmd.ExecuteScalar();
                     }
                 }
             }
             catch (Exception)
             {

                 return default(int);
             }
         }
         #endregion

         #region ExecuteReader 执行sql语句或者存储过程,返回DataReader---DaataReader
         /// <summary>
         /// 执行sql语句或存储过程 返回DataReader 不带参数--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
         /// <returns></returns>
         public static SqlDataReader ExecuteReader(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
         {
             //sqlDataReader不能用using 会关闭conn 导致不能获取到返回值。注意：DataReader获取值时必须保持连接状态
             try
             {
                 SqlConnection conn = new SqlConnection(ConnString);
                 SqlCommand cmd = new SqlCommand();
                 PreparCommand(conn, cmd, commandTextOrSpName, commandType);
                 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
             }
             catch (Exception)
             {
                 return null;
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程 返回DataReader--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型</param>
         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
         /// <returns></returns>
         public static SqlDataReader ExecuteReader(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
         {
             //sqlDataReader不能用using 会关闭conn 导致不能获取到返回值。注意：DataReader获取值时必须保持连接状态
             try
             {
                 SqlConnection conn = new SqlConnection(ConnString);
                 SqlCommand cmd = new SqlCommand();
                 PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);
                 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
             }
             catch (Exception)
             {
                 return null;
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程 返回DataReader--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型</param>
         /// <param name="obj">object[]参数数组，允许空</param>
         /// <returns></returns>
         public static SqlDataReader ExecuteReader(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
         {
             //sqlDataReader不能用using 会关闭conn 导致不能获取到返回值。注意：DataReader获取值时必须保持连接状态
             try
             {
                 SqlConnection conn = new SqlConnection(ConnString);
                 SqlCommand cmd = new SqlCommand();
                 PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);
                 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
             }
             catch (Exception)
             {
                 return null;
             }
         }
         #endregion

         #region ExecuteDataset 执行sql语句或者存储过程,返回一个DataSet---DataSet
         /// <summary>
         /// 执行sql语句或存储过程，返回DataSet 不带参数--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
         /// <returns></returns>
         public static DataSet ExecuteDataSet(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType);
                         using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                         {
                             DataSet ds = new DataSet();
                             da.Fill(ds);
                             return ds;
                         }
                     }
                 }
             }
             catch (Exception)
             {
                 return null;
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程，返回DataSet--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型</param>
         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
         /// <returns></returns>
         public static DataSet ExecuteDataSet(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);
                         using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                         {
                             DataSet ds = new DataSet();
                             da.Fill(ds);
                             return ds;
                         }
                     }
                 }
             }
             catch (Exception)
             {
                 return null;
             }
         }
         /// <summary>
         /// 执行sql语句或存储过程，返回DataSet--DG
         /// </summary>
         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">命令类型 </param>
         /// <param name="obj">object[]参数数组，允许空</param>
         /// <returns></returns>
         public static DataSet ExecuteDataSet(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
         {
             try
             {
                 using (SqlConnection conn = new SqlConnection(ConnString))
                 {
                     using (SqlCommand cmd = new SqlCommand())
                     {
                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);
                         using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                         {
                             DataSet ds = new DataSet();
                             da.Fill(ds);
                             return ds;
                         }
                     }
                 }
             }
             catch (Exception)
             {
                 return null;
             }
         }
         #endregion

         #region ---PreparCommand 构建一个通用的command对象供内部方法进行调用---
         /// <summary>
         /// 不带参数的设置sqlcommand对象--DG
         /// </summary>
         /// <param name="conn">sqlconnection对象</param>
         /// <param name="cmd">sqlcommmand对象</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">语句的类型</param>
         private static void PreparCommand(SqlConnection conn, SqlCommand cmd, string commandTextOrSpName, CommandType commandType)
         {
             //打开连接
             if (conn.State != ConnectionState.Open)
             {
                 conn.Open();
             }

             //设置SqlCommand对象的属性值
             cmd.Connection = conn;
             cmd.CommandType = commandType;
             cmd.CommandText = commandTextOrSpName;
             cmd.CommandTimeout = ;
         }
         /// <summary>
         /// 设置一个等待执行的SqlCommand对象--DG
         /// </summary>
         /// <param name="conn">sqlconnection对象</param>
         /// <param name="cmd">sqlcommmand对象</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">语句的类型</param>
         /// <param name="parms">参数，sqlparameter类型，需要指出所有的参数名称</param>
         private static void PreparCommand(SqlConnection conn, SqlCommand cmd, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
         {
             //打开连接
             if (conn.State != ConnectionState.Open)
             {
                 conn.Open();
             }

             //设置SqlCommand对象的属性值
             cmd.Connection = conn;
             cmd.CommandType = commandType;
             cmd.CommandText = commandTextOrSpName;
             cmd.CommandTimeout = ;

             cmd.Parameters.Clear();
             if (parms != null)
             {
                 cmd.Parameters.AddRange(parms);
             }
         }
         /// <summary>
         /// PreparCommand方法，可变参数为object需要严格按照参数顺序传参--DG
         /// </summary>
         /// <param name="conn">sqlconnection对象</param>
         /// <param name="cmd">sqlcommmand对象</param>
         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
         /// <param name="commandType">语句的类型</param>
         /// <param name="parms">参数，object类型，需要按顺序赋值</param>
         private static void PreparCommand(SqlConnection conn, SqlCommand cmd, string commandTextOrSpName, CommandType commandType, params object[] parms)
         {

             //打开连接
             if (conn.State != ConnectionState.Open)
             {
                 conn.Open();
             }

             //设置SqlCommand对象的属性值
             cmd.Connection = conn;
             cmd.CommandType = commandType;
             cmd.CommandText = commandTextOrSpName;
             cmd.CommandTimeout = ;

             cmd.Parameters.Clear();
             if (parms != null)
             {
                 cmd.Parameters.AddRange(parms);
             }
         }
         //之所以会用object参数方法是为了我们能更方便的调用存储过程，不必去关系存储过程参数名是什么，知道它的参数顺序就可以了 sqlparameter必须指定每一个参数名称
         #endregion

         #region 通过Model反射返回结果集 Model为 T 泛型变量的真实类型---反射返回结果集Private
         /// <summary>
         /// 反射返回一个List T 类型的结果集--DG
         /// </summary>
         /// <typeparam name="T">Model中对象类型</typeparam>
         /// <param name="ds">DataSet结果集</param>
         /// <returns></returns>
         public static List<T> ReturnListByModels<T>(DataSet ds)
         {
             try
             {
                 List<T> list = new List<T>();//实例化一个list对象
                 T model = System.Activator.CreateInstance<T>();                     //实例化一个T类型对象
                 PropertyInfo[] propertyInfos = model.GetType().GetProperties();     //获取T对象的所有公共属性

                 DataTable dt = ds.Tables[];    // 获取到ds的dt
                 )
                 {
                     //判断读取的行是否>0 即数据库数据已被读取
                     foreach (DataRow row in dt.Rows)
                     {
                         T model1 = System.Activator.CreateInstance<T>();//实例化一个对象，便于往list里填充数据
                         foreach (PropertyInfo propertyInfo in propertyInfos)
                         {
                             //遍历模型里所有的字段
                             if (row[propertyInfo.Name] != System.DBNull.Value)
                             {
                                 //判断值是否为空，如果空赋值为null见else
                                 if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
                                 {
                                     //如果convertsionType为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
                                     NullableConverter nullableConverter = new NullableConverter(propertyInfo.PropertyType);
                                     //将convertsionType转换为nullable对的基础基元类型
                                     propertyInfo.SetValue(model1, Convert.ChangeType(row[propertyInfo.Name], nullableConverter.UnderlyingType), null);
                                 }
                                 else
                                 {
                                     propertyInfo.SetValue(model1, Convert.ChangeType(row[propertyInfo.Name], propertyInfo.PropertyType), null);
                                 }
                             }
                             else
                             {
                                 propertyInfo.SetValue(model1, null, null);//如果数据库的值为空，则赋值为null
                             }
                         }
                         list.Add(model1);//将对象填充到list中
                     }
                 }
                 return list;
             }
             catch (Exception)
             {
                 return null;
             }
         }
         /// <summary>
         /// 反射返回一个T类型的结果--DG
         /// </summary>
         /// <typeparam name="T">Model中对象类型</typeparam>
         /// <param name="reader">SqlDataReader结果集</param>
         /// <returns></returns>
         public static T ReturnModelByModels<T>(SqlDataReader reader)
         {
             try
             {
                 T model = System.Activator.CreateInstance<T>();                     //实例化一个T类型对象
                 PropertyInfo[] propertyInfos = model.GetType().GetProperties();     //获取T对象的所有公共属性
                 using (reader)
                 {
                     if (reader.Read())
                     {
                         foreach (PropertyInfo propertyInfo in propertyInfos)
                         {
                             //遍历模型里所有的字段
                             if (reader[propertyInfo.Name] != System.DBNull.Value)
                             {
                                 //判断值是否为空，如果空赋值为null见else
                                 if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
                                 {
                                     //如果convertsionType为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
                                     NullableConverter nullableConverter = new NullableConverter(propertyInfo.PropertyType);
                                     //将convertsionType转换为nullable对的基础基元类型
                                     propertyInfo.SetValue(model, Convert.ChangeType(reader[propertyInfo.Name], nullableConverter.UnderlyingType), null);
                                 }
                                 else
                                 {
                                     propertyInfo.SetValue(model, Convert.ChangeType(reader[propertyInfo.Name], propertyInfo.PropertyType), null);
                                 }
                             }
                             else
                             {
                                 propertyInfo.SetValue(model, null, null);//如果数据库的值为空，则赋值为null
                             }
                         }
                         return model;//返回T类型的赋值后的对象 model
                     }
                 }
                 return default(T);//返回引用类型和值类型的默认值0或null
             }
             catch (Exception)
             {
                 return default(T);//返回引用类型和值类型的默认值0或null
             }
         }
         #endregion
     }
 }

SqlHelper_DG

---

接下来我们介绍一下使用方法 ：

这里写的一个tb_TestService数据访问层（用本人的代码生成器自动生成的）,实现的是一个简单的增删改查CRUD操作，里面包含了大部分的SqlHelper_DG的使用方法，大家自己在里面找吧！本人就不在具体说明了。

 using Model;
 using SqlHelper_Framework4_5_DG;
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SqlClient;
 using System.Text;

 namespace DAL
 {
     /// <summary>
     ///七小代码生成器
     ///版本号：2.0.0
     ///Author:EnglishName：Qixiao，中文名：七小(東哥)
     ///生成器编写时间：20160507，地点：亚洲中国天津
     ///代码标准：東哥的SqlHelper_DG
     /// </summary>

     /// <summary>
     /// 实体类tb_TestService（可添加属性说明）
     /// </summary>
     public class tb_TestService
     {
         /// <summary>
         /// 计算当前表内的符合条件的所有数据的数量
         /// </summary>
         /// <param name="safeSqlConditionInBLL">安全的sql条件语句,从BLL层获取</param>
         /// <returns></returns>
         public int DataCount(string safeSqlConditionInBLL = "")
         {
             try
             {
                 string commandText = "select count(0) from tb_Test WHERE " + safeSqlConditionInBLL;
                 return Convert.ToInt32(SqlHelper_DG.ExecuteScalar(SqlHelper_DG.ConnString, commandText));
             }
             catch (Exception)
             {
                 return default(int);
             }
         }
         /// <summary>
         /// 检测是否存在条件所指示的数据------------这个方法需要按需求来修改条件，不能盲目使用！！！
         /// </summary>
         /// <param name="tb_TestObject">从对象中提取中要查找的字段是否存在(对象方式是防止数据注入！)</param>
         /// <returns></returns>
         public Boolean IsExistWhereFeild(tb_Test tb_TestObject)
         {
             try
             {
                 string commandText = "select count(0) from tb_Test WHERE Str1=@Str1";
                 SqlParameter[] parms = new SqlParameter[]{
                 new SqlParameter("@Str1",tb_TestObject.Str1),
                 };
                  ? true : false;
             }
             catch (Exception)
             {
                 return false;
             }
         }
         /// <summary>
         /// Insert插入语句，返回插入的结果：成功true，失败false
         /// </summary>
         /// <param name="tb_TestObject">要插入的对象，屏蔽掉自增的字段</param>
         /// <returns></returns>
         public Boolean IsInsert(tb_Test tb_TestObject)
         {
             try
             {
                 string commandText = "INSERT INTO tb_Test ( Str1,Id2,Str2) VALUES (@Str1,@Id2,@Str2)";
                 SqlParameter[] parms = new SqlParameter[]{
                 new SqlParameter("@Str1",tb_TestObject.Str1),
                 new SqlParameter("@Id2",tb_TestObject.Id2),
                 new SqlParameter("@Str2",tb_TestObject.Str2),
                 };
                  ? true : false;
             }
             catch (Exception)
             {
                 return false;
             }
         }
         /// <summary>
         /// Update修改语句，返回修改的结果：成功true，失败false
         /// </summary>
         /// <param name="tb_TestObject">要修改的结果对象，屏蔽掉自增的列，条件可修改</param>
         /// <returns></returns>
         public Boolean IsUpdate(tb_Test tb_TestObject)
         {
             try
             {
                 string commandText = "UPDATE tb_Test SET Str1=@Str1,Id2=@Id2,Str2=@Str2 WHERE Id=@Id";
                 SqlParameter[] parms = new SqlParameter[]{
                     new SqlParameter("@Id",tb_TestObject.Id),
                     new SqlParameter("@Str1",tb_TestObject.Str1),
                     new SqlParameter("@Id2",tb_TestObject.Id2),
                     new SqlParameter("@Str2",tb_TestObject.Str2),
                 };
                  ? true : false;
             }
             catch (Exception)
             {
                 return false;
             }
         }
         /// <summary>
         /// Delete删除语句，返回删除的结果：成功true，失败false
         /// </summary>
         /// <param name="tb_TestObject">条件对象，唯一字段或者自定义删除条件</param>
         /// <returns></returns>
         public Boolean IsDelete(tb_Test tb_TestObject)
         {
             try
             {
                 string commandText = "DELETE FROM tb_Test WHERE Id=@Id";
                 SqlParameter[] parms = new SqlParameter[]{
                 new SqlParameter("@Id",tb_TestObject.Id),
                 };
                  ? true : false;
             }
             catch (Exception)
             {
                 return false;
             }
         }
         /// <summary>
         /// Select Model语句，返回查询的Model结果
         /// </summary>
         /// <param name="tb_TestObject">条件对象，按需求来确定查找的条件</param>
         /// <returns></returns>
         public T SelectSingleLine_RTModel<T>(tb_Test tb_TestObject)
         {
             try
             {
                 string commandText = "SELECT TOP (1) * FROM tb_Test WHERE Id=@Id";//这里需要按需求来确定需要查找的是哪个参数 因为要返回一行数据，所以搜索的条件值必须是唯一的，主键是最佳选择！
                 SqlParameter[] parms = new SqlParameter[]{
                 new SqlParameter("@Id",tb_TestObject.Id),
                 };
                 return SqlHelper_DG.ReturnModelByModels<T>(SqlHelper_DG.ExecuteReader(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms));
             }
             catch (Exception)
             {
                 return default(T);
             }
         }
         /// <summary>
         /// Select List语句，返回查询的List结果集
         /// </summary>
         /// <param name="safeSqlCondition">查询的条件,从BLL层传来的安全的sql语句</param>
         /// <returns></returns>
         public List<T> SelectALL<T>(string safeSqlCondition = " 1=1 ")
         {
             try
             {
                 string commandText = "SELECT * FROM tb_Test WHERE " + safeSqlCondition;//这里修改条件语句 默认全部
                 return SqlHelper_DG.ReturnListByModels<T>(SqlHelper_DG.ExecuteDataSet(SqlHelper_DG.ConnString, commandText));
             }
             catch (Exception)
             {
                 return null;
             }
         }
         /// <summary>
         /// 用RowNumber方法进行分页处理返回List结果集，效率最佳但不支持低版本SqlServer
         /// </summary>
         /// <param name="PageSize">int页大小，每页容纳的行数</param>
         /// <param name="PageNumber">int页码，第几页</param>
         /// <param name="DataOrderBy">object表中按这个字段顺序排序,可以是任意字段,可以加修饰符如DESC</param>
         /// <param name="safeSqlCondition">所有集合中先找出符合这个条件的结果再进行分页处理 查询的条件,从BLL层传来的安全的sql语句</param>
         /// <returns></returns>
         public List<T> SelectALLPaginByRowNumber<T>(int PageSize, int PageNumber, string DataOrderBy,string safeSqlCondition="1=1")
         {
             try
             {
                 StringBuilder commandText=new StringBuilder ();
                 commandText.Append("SELECT TOP " + PageSize + " * FROM (SELECT ROW_NUMBER() OVER (ORDER BY " + DataOrderBy + ") AS RowNumber,* FROM tb_Test ");
                 commandText.Append(" WHERE " + safeSqlCondition + " ");//这里修改条件语句
                 commandText.Append(" ) AS T  WHERE RowNumber > (" + PageSize + "*(" + PageNumber + "-1))");
                 return SqlHelper_DG.ReturnListByModels<T>(SqlHelper_DG.ExecuteDataSet(SqlHelper_DG.ConnString, commandText.ToString()));
             }
             catch (Exception)
             {
                 return null;
             }
         }
     }
 }

tb_TestService

---

写到这里，相信大家都已经对ORM框架的实现机制有一定的了解，并且能完美的实现一个SqlHelper来进行对自己数据访问代码的封装！如果喜欢，大家可以进一步对Service层的代码进行封装放到一个类里面，更加方便自己对数据库的访问，可以更加简便地访问数据库，有朝一日写出一个属于自己的ORM框架！

---

有关于 Java 的 DBUtils 介绍详情请参考：http://www.cnblogs.com/qixiaoyizhan/p/5818599.html

2016-08-29 16:44:12

本文为七小站主原创作品，转载请注明出处：http://www.cnblogs.com/qixiaoyizhan/