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/