自己写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 = 20;
        }
        /// <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 = 20;

            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 = 20;

            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[0];    // 获取到ds的dt
                if (dt.Rows.Count > 0)
                {
                    //判断读取的行是否>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
    }
}

 

---

 

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

这里写的一个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),
                };
                return Convert.ToInt32(SqlHelper_DG.ExecuteScalar(SqlHelper_DG.ConnString, commandText,CommandType.Text,parms)) > 0 ? 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),
                };
                return SqlHelper_DG.ExecuteNonQuery(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms) > 0 ? 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),
                };
                return SqlHelper_DG.ExecuteNonQuery(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms) > 0 ? 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),
                };
                return SqlHelper_DG.ExecuteNonQuery(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms) > 0 ? 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;
            }
        }
    }
}

 

---

 

写到这里，相信大家都已经对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/