如何简化数据库的访问与操作，兼谈泛型的应用

一、一些说明及申明

    不积跬步无以至千里，不纳滴水无以成江海。本文谈到的仅仅是实际开发过程的一个简单应用，虽然显得很不深奥，但并不影响一些编程思想在其中的具体体现。授之与鱼，不如授之与渔。我期望的是，通过某个简单应用的编码过程，让大家理解某种（个）技术的发明初衷，以及它的适用场景。

    可惜的是，这里大量的内容基于个人的经验总结和理解，毕竟书读得不够、不透，如果某些措辞不当或者指代混乱希望您见谅，好在不是正式出版物，草根说错话肯定比“专家”要少挨很多砖:)

    不过两年多的工作经历，自我感觉技术上尚是浅薄，师弟、师妹们可多了解些我的工作心得，或许能少走弯路；至于大侠、小虾之辈，哂笑之后若肯指教一二最好，或者请以宽容之心释己之怀啊！

---

二、面向对象的抽象过程

    在进行后台开发时，我们时常要进行数据库的访问与操作，.net 提供了 IDbConnection, IDbCommand 以及 IDbDataParameter 等接口可以满足我们的日常需要。通常，我们这样获取数据或进行操作：

//ExecuteReader
using (SqlConnection con = new SqlConnection("my connection string")) {
    using (SqlCommand cmd = new SqlCommand("my command string", con)) {
        con.Open();
        using (SqlDataReader reader = cmd.ExecuteReader()) {
            while (reader.Read()) {
                //Todo
            }
        }
    }
}

//ExecuteScalar
using (SqlConnection con = new SqlConnection("my connection string")) {
    using (SqlCommand cmd = new SqlCommand("my command string", con)) {
        con.Open();
        object result = cmd.ExecuteScalar();
    }
}

//ExecuteNonQuery
using (SqlConnection con = new SqlConnection("my connection string")) {
    using (SqlCommand cmd = new SqlCommand("my command string", con)) {
        con.Open();
        int result = cmd.ExecuteNonQuery();
    }
}

    我在做了相当长一段时间如上编码之后，发觉可以进行如下简化，创建 SqlHelper 进行辅助。相信当前很多开发人员也是这么做的（指思路相似，细节处肯定不同）：

class SqlHelper {
    public static SqlDataReader ExecuteReader(string conStr, string cmdStr) {
        //ExecuteReader
        SqlConnection con = new SqlConnection(conStr);
        SqlCommand cmd = new SqlCommand(cmdStr, con);
        con.Open();
        return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);//这表示操作完成后关闭该 Reader
    }

    public static object ExecuteScalar(string conStr, string cmdStr) {
        //ExecuteScalar
        using (SqlConnection con = new SqlConnection(conStr)) {
            using (SqlCommand cmd = new SqlCommand(cmdStr, con)) {
                con.Open();
                return cmd.ExecuteScalar();
            }
        }
    }

    public static int ExecuteNonQuery(string conStr, string cmdStr) {
        //ExecuteNonQuery
        using (SqlConnection con = new SqlConnection(conStr)) {
            using (SqlCommand cmd = new SqlCommand(cmdStr, con)) {
                con.Open();
                return cmd.ExecuteNonQuery();
            }
        }
    }
}

    当需要传参时，要么通过 string.format() 等方法拼接 cmdStr （很不安全），要么通过原始方法，或者通过如下变通方案：

struct Parameter{
    public string Name{get;set;}
    public object Value{get;set;}
}
public static int ExecuteNonQuery(string conStr, string cmdStr, params Parameter[] pars) {
    //ExecuteNonQuery
    using (SqlConnection con = new SqlConnection(conStr)) {
        using (SqlCommand cmd = new SqlCommand(cmdStr, con)) {
            foreach (Parameter p in pars) {
                cmd.Parameters.AddWithValue(p.Name, p.Value);
            }
            con.Open();
            return cmd.ExecuteNonQuery();
        }
    }
}

    到这一步，看上去数据库访问已经简化得差不多：

int result = SqlHelper.ExecuteNonQuery("my connection string", "my command string", 
    new Parameter() { Name = "Number", Value = 1 }, new Parameter() { Name = "Text", Value = "afaefawf" });

    或者只是一些细节上的优化：

class SqlHelperII {

    public static SqlHelperII InstanceForStudentsSystem { get; private set; }

    static SqlHelperII() {
        InstanceForStudentsSystem = new SqlHelperII(System.Configuration.ConfigurationSettings
.AppSettings["StudentsSystemConnectionString"]);
    }

    public SqlHelperII(string connectionString) {
        this.ConnectionString = connectionString;
    }

    public string ConnectionString { get; private set; }

    public int ExecuteNonQuery(string cmdStr, params string[] pars) {
        //ExecuteNonQuery
        using (SqlConnection con = new SqlConnection(this.ConnectionString)) {
            using (SqlCommand cmd = new SqlCommand(cmdStr, con)) {
                for (int i = 0; i < pars.Length; i += 2) {
                    cmd.Parameters.AddWithValue(pars[i], pars[i + 1]);
                }
                con.Open();
                return cmd.ExecuteNonQuery();
            }
        }
    }

}

    以往的操作可以这样进行：

int result = SqlHelperII.InstanceForStudentsSystem.ExecuteNonQuery("my command string",
"Number", 1.ToString(), "Text", "afaefawf");

    事实上，一般情况下我个人认为这样确实足够了，但上面的代码全假设在了 SqlServer 数据库之上，一旦遇到 MySql 之类，就需要编写某个 MySqlHelper 等。另外，我在年初某个项目与 MID 层进行交互时突然悟到，其实任何数据类操作都可以抽象成类数据库的访问方式；当时我为此做了个 MIDServicesHelper，其实现了 ExecuteReader，ExecuteScalar，ExecuteNonQuery 三个方法（我的实践证明，这三个方法大概是足够用了）。

    接下来的时间里，我创建了这样的一个接口 IDbExecutor：

namespace Queen.Data {

    /// <summary>
    /// 数据库服务接口, 负责进行数据的存储、读取等基本操作.
    /// 它可以是一个传统的 Sql 数据库， 也可以是其他支持数据操作的系统.
    /// </summary>
    public interface IDbExecutor {

        /// <summary>
        /// 链接串
        /// </summary>
        string ConnectionString {
            get;
            set;
        }

        /// <summary>
        /// 超时设置
        /// </summary>
        int CommandTimeout {
            get;
            set;
        }

        /// <summary>
        /// 获取执行影响行数.
        /// 实现该接口时注意释放所有相关资源!
        /// </summary>
        /// <param name="cmdText"></param>
        /// <param name="keyValuePairs"></param>
        /// <returns></returns>
        int ExecuteNonQuery(string cmdText, params string[] keyValuePairs);

        /// <summary>
        /// 获取执行值.
        /// 实现该接口时注意释放所有相关资源!
        /// </summary>
        /// <param name="cmdText"></param>
        /// <param name="keyValuePairs"></param>
        /// <returns></returns>
        object ExecuteScalar(string cmdText, params string[] keyValuePairs);

        /// <summary>
        /// 获取数据读取流.
        /// 调用该接口时务必释放读取流, using(IDataReader reader = XX.ExecuteReader()){ ... }
        /// 实现该接口时请勿释放任何资源, 返回调用 System.Data.SqlCommand.ExecuteReader(
System.Data.CommandBehavior.CloseConnection)
        /// </summary>
        /// <param name="cmdText">数据库执行文本.</param>
        /// <param name="keyValuePairs">参数组, 比如 "@ParaA", "valueA", "@ParaB", "valueB"</param>
        /// <returns>数据读出流</returns>
        System.Data.IDataReader ExecuteReader(string cmdText, params string[] keyValuePairs);

    }
}

    凡后来我主导的项目里总会多出这样一个文件及类型 DbExecutor，其内部可定义支持 SqlServer、MySql  甚至其它数据库的内部类，但数据库类型对外界“基本”透明（组织 SQL 语句时必须知道数据库类型，SqlServer、MySql 有各自的 SQL 语言特性!）：

static class DbExecutor {

    public static Queen.Data.IDbExecutor Students { get; private set; }
    public static Queen.Data.IDbExecutor Families { get; private set; }

    static DbExecutor() {
        //Init students, families ...
    }

    private class SqlServerExecutor : Queen.Data.IDbExecutor {

        #region IDbExecutor 成员

        public string ConnectionString {
            get {
                throw new NotImplementedException();
            }
            set {
                throw new NotImplementedException();
            }
        }

        public int CommandTimeout {
            get {
                throw new NotImplementedException();
            }
            set {
                throw new NotImplementedException();
            }
        }

        public int ExecuteNonQuery(string cmdText, params string[] keyValuePairs) {
            throw new NotImplementedException();
        }

        public object ExecuteScalar(string cmdText, params string[] keyValuePairs) {
            throw new NotImplementedException();
        }

        public System.Data.IDataReader ExecuteReader(string cmdText, params string[] keyValuePairs) {
            throw new NotImplementedException();
        }

        #endregion
    }

    private class MySqlExecutor : Queen.Data.IDbExecutor {

        #region IDbExecutor 成员

        public string ConnectionString {
            get {
                throw new NotImplementedException();
            }
            set {
                throw new NotImplementedException();
            }
        }

        public int CommandTimeout {
            get {
                throw new NotImplementedException();
            }
            set {
                throw new NotImplementedException();
            }
        }

        public int ExecuteNonQuery(string cmdText, params string[] keyValuePairs) {
            throw new NotImplementedException();
        }

        public object ExecuteScalar(string cmdText, params string[] keyValuePairs) {
            throw new NotImplementedException();
        }

        public System.Data.IDataReader ExecuteReader(string cmdText, params string[] keyValuePairs) {
            throw new NotImplementedException();
        }

        #endregion
    }
}

    这样做的好处在于，不但在代码量上减少了开发人员的维护成本，也在系统的迁移上极大减少了代码替换工作（虽然迁移的可能性比较小），同时，也给系统的数据库操作监控带来了便利（比如增加日志功能等，后文将举例实现）。

---

三、泛型编程

    但针对数据库操作这块，我还是严重感觉不够优雅，我觉得 SqlServerExecutor、MyServerExecutor 等虽然引用了不同的驱动程序，但这些驱动程序均实现了同一类接口（IDbConnection等），通过继承实现多个版本的 XxxExecutor 简直太丑陋了！而后，通过学习、领会泛型编程思想，我当前使用的版本产生了：

using System.Data;

namespace Queen.Data {
    /// <summary>
    /// 提供 Sql 语言支持的数据库服务, 必须声明为 IDbExecutor 才能使用相关服务.
    /// </summary>
    /// <typeparam name="TConnection">链接类型</typeparam>
    /// <typeparam name="TCommand">命令类型</typeparam>
    /// <typeparam name="TDataParameter">数据参数类型</typeparam>
    public class SqlExecutor<TConnection, TCommand, TDataParameter> : IDbExecutor
        where TConnection : IDbConnection, new()
        where TCommand : IDbCommand, new()
        where TDataParameter : IDbDataParameter, new() {

        /// <summary>
        /// Sql 命令类型.
        /// </summary>
        public System.Data.CommandType CommandType {
            get;
            set;
        }

        #region Construct

        public SqlExecutor() {
            CommandType = System.Data.CommandType.Text;
            ((IDbExecutor)this).CommandTimeout = 30;
        }

        public SqlExecutor(System.Data.CommandType commandType) {
            CommandType = commandType;
            ((IDbExecutor)this).CommandTimeout = 30;
        }

        public SqlExecutor(System.Data.CommandType commandType, int commandTimeout) {
            CommandType = commandType;
            ((IDbExecutor)this).CommandTimeout = commandTimeout;
        }

        #endregion

        #region ISqlExecutor 成员

        string IDbExecutor.ConnectionString {
            get;
            set;
        }

        /// <summary>
        /// 链接串, 默认 30(秒)
        /// </summary>
        int IDbExecutor.CommandTimeout {
            get;
            set;
        }

        int IDbExecutor.ExecuteNonQuery(string cmdText, params string[] keyValuePairs) {
            using (TConnection con = new TConnection()) {
                con.ConnectionString = ((IDbExecutor)this).ConnectionString;
                using (TCommand cmd = new TCommand()) {
                    cmd.CommandText = cmdText;
                    cmd.Connection = con;
                    if (keyValuePairs != null) {
                        for (int i = 0; i < keyValuePairs.Length - 1; i += 2) {
                            TDataParameter p = new TDataParameter();
                            p.ParameterName = keyValuePairs[i];
                            p.Value = keyValuePairs[i + 1];
                            cmd.Parameters.Add(p);
                        }
                    }
                    cmd.CommandType = CommandType;
                    cmd.CommandTimeout = ((IDbExecutor)this).CommandTimeout;
                    con.Open();
                    return cmd.ExecuteNonQuery();
                }
            }
        }

        object IDbExecutor.ExecuteScalar(string cmdText, params string[] keyValuePairs) {
            using (TConnection con = new TConnection()) {
                con.ConnectionString = ((IDbExecutor)this).ConnectionString;
                using (TCommand cmd = new TCommand()) {
                    cmd.CommandText = cmdText;
                    cmd.Connection = con;
                    if (keyValuePairs != null) {
                        for (int i = 0; i < keyValuePairs.Length - 1; i += 2) {
                            TDataParameter p = new TDataParameter();
                            p.ParameterName = keyValuePairs[i];
                            p.Value = keyValuePairs[i + 1];
                            cmd.Parameters.Add(p);
                        }
                    }
                    cmd.CommandType = CommandType;
                    cmd.CommandTimeout = ((IDbExecutor)this).CommandTimeout;
                    con.Open();
                    return cmd.ExecuteScalar();
                }
            }
        }

        /// <summary>
        /// 获取数据读取流
        /// 调用该接口时务必释放读取流, using(IDataReader reader = XX.ExecuteReader()){ ... }.
        /// </summary>
        /// <param name="cmdText"></param>
        /// <param name="keyValuePairs"></param>
        /// <returns></returns>
        System.Data.IDataReader IDbExecutor.ExecuteReader(string cmdText, params string[] keyValuePairs) {
            TConnection con = new TConnection();
            con.ConnectionString = ((IDbExecutor)this).ConnectionString;
            TCommand cmd = new TCommand();
            cmd.CommandText = cmdText;
            cmd.Connection = con;
            if (keyValuePairs != null) {
                for (int i = 0; i < keyValuePairs.Length - 1; i += 2) {
                    TDataParameter p = new TDataParameter();
                    p.ParameterName = keyValuePairs[i];
                    p.Value = keyValuePairs[i + 1];
                    cmd.Parameters.Add(p);
                }
            }
            cmd.CommandType = CommandType;
            cmd.CommandTimeout = ((IDbExecutor)this).CommandTimeout;
            con.Open();
            return cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }

        #endregion

    }
}

只需指定 TConnection, TCommand, TDataParameter 的具体类型，该辅助类并能支持对应工作了；也就是把 SqlServer、MySql 等的具体辅助类合并到了一起并做了实现，真的是一劳永逸啊！相应的，DbExecutor 简化成了：

/// <summary>
/// 数据访问代理
/// </summary>
public static class DbExecutor {
    private static IDbExecutor _files;
    public static IDbExecutor Files { get { return _files; } private set { _files = value; } }
    private static IDbExecutor _BK;
    public static IDbExecutor BK { get { return _BK; } private set { _BK = value; } }
    private static IDbExecutor _ResourcesProcedure;
    public static IDbExecutor ResourcesProcedure { get { return _ResourcesProcedure; } private set {
 _ResourcesProcedure = value; } }
    private static IDbExecutor _Resources;
    public static IDbExecutor Resources { get { return _Resources; } private set { _Resources = value; } }
    static DbExecutor() {
        Files = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>();
        Files.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Files"]
.ConnectionString;

        BK = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>();
        BK.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["bk"]
.ConnectionString;

        Resources = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>();
        Resources.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings[
"Resources"].ConnectionString;


        ResourcesProcedure = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>(
System.Data.CommandType.StoredProcedure);
        ResourcesProcedure.ConnectionString = System.Configuration.ConfigurationManager
.ConnectionStrings["Resources"].ConnectionString;
    }

}

---

四、装饰者设计模式的应用

    最近，组内希望添加数据库操作人员记录，我只是做了如下的改动便完成了简易日志功能（请参见“装饰者设计模式”）：

using System;
using System.Collections.Generic;
using System.Text;
using Queen.Data;
using MySql.Data.MySqlClient;
using System.Web;

/// <summary>
/// 数据访问代理
/// </summary>
public static class DbExecutor {
    private static IDbExecutor _files;
    public static IDbExecutor Files { get { return _files; } private set { _files = value; } }
    private static IDbExecutor _BK;
    public static IDbExecutor BK { get { return _BK; } private set { _BK = value; } }
    private static IDbExecutor _ResourcesProcedure;
    public static IDbExecutor ResourcesProcedure { get { return _ResourcesProcedure; }
private set { _ResourcesProcedure = value; } }
    private static IDbExecutor _Resources;
    public static IDbExecutor Resources { get { return _Resources; } private set { _Resources = value; } }
    static DbExecutor() {
        Files = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>();
        Files.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Files"]
.ConnectionString;
        Files = new DecorateExecutor(Files);

        BK = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>();
        BK.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["bk"]
.ConnectionString;
        BK = new DecorateExecutor(BK);

        Resources = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>();
        Resources.ConnectionString = System.Configuration.ConfigurationManager
.ConnectionStrings["Resources"].ConnectionString;
        Resources = new DecorateExecutor(Resources);


        ResourcesProcedure = new SqlExecutor<MySqlConnection, MySqlCommand, MySqlParameter>(
System.Data.CommandType.StoredProcedure);
        ResourcesProcedure.ConnectionString = System.Configuration.ConfigurationManager
.ConnectionStrings["Resources"].ConnectionString;
        ResourcesProcedure = new DecorateExecutor(ResourcesProcedure);
    }

    #region DecorateExecutor, logable

    class DecorateExecutor : IDbExecutor {

        private IDbExecutor value;

        public DecorateExecutor(IDbExecutor value) {
            this.value = value;
        }

        #region IDbExecutor 成员

        public int CommandTimeout {
            get {
                return this.value.CommandTimeout;
            }
            set {
                this.value.CommandTimeout = value;
            }
        }

        public string ConnectionString {
            get {
                return this.value.ConnectionString;
            }
            set {
                this.value.ConnectionString = value;
            }
        }

        public int ExecuteNonQuery(string cmdText, params string[] keyValuePairs) {
            if (null != HttpContext.Current && null != HttpContext.Current.User && null
!= HttpContext.Current.User.Identity && !string.IsNullOrEmpty(HttpContext.Current.User.Identity.Name)) {
                System.Diagnostics.Trace.WriteLine(string.Format("{0}\t{1} 进行了操作 {2}...",
                    DateTime.Now.ToShortTimeString(), HttpContext.Current.User.Identity.Name,
cmdText.Length > 20 ? cmdText.Substring(0, 20) : cmdText));
            }
            return this.value.ExecuteNonQuery(cmdText, keyValuePairs);
        }

        public System.Data.IDataReader ExecuteReader(string cmdText, params string[] keyValuePairs) {
            if (null != HttpContext.Current && null != HttpContext.Current.User && null
!= HttpContext.Current.User.Identity && !string.IsNullOrEmpty(HttpContext.Current.User.Identity.Name)) {
                System.Diagnostics.Trace.WriteLine(string.Format("{0}\t{1} 进行了操作 {2}...",
                    DateTime.Now.ToShortTimeString(), HttpContext.Current.User.Identity.Name,
cmdText.Length > 20 ? cmdText.Substring(0, 20) : cmdText));
            }
            return this.value.ExecuteReader(cmdText, keyValuePairs);
        }

        public object ExecuteScalar(string cmdText, params string[] keyValuePairs) {
            if (null != HttpContext.Current && null != HttpContext.Current.User && null
!= HttpContext.Current.User.Identity && !string.IsNullOrEmpty(HttpContext.Current.User.Identity.Name)) {
                System.Diagnostics.Trace.WriteLine(string.Format("{0}\t{1} 进行了操作 {2}...",
                    DateTime.Now.ToShortTimeString(), HttpContext.Current.User.Identity.Name,
 cmdText.Length > 20 ? cmdText.Substring(0, 20) : cmdText));
            }
            return this.value.ExecuteScalar(cmdText, keyValuePairs);
        }

        #endregion
    }

    #endregion

}

---

五、小结：

    优雅的代码让人看着赏心悦目，虽然每个人的审美会有不同，但至少要让自己觉得舒服。我尝试着在编码的过程中积累软件设计的经验，充分发挥面向对象的长处，使得代码的可复用性、可维护性（可调试的能力？）、可扩展性达到极致。在本文前半段，我与大家分享了我在抽象数据库访问行为时的心得（不过是 IDbExecutor 接口），而在接下来的文字里，我使用了泛型编程技巧，使得传统的面向对象（通过继承等手段扩展、复用代码？）得到了看似质的突破，极大缓解了“继承泛滥”的苦恼。

    面向过程编程，大量的操作是参数的传递，由于参数之间有逻辑上的关联，且“过程”本身又针对某类关联参数，于是有了“面向对象”。这样一来，人们掌握系统全局的能力得到了加强，从 .net 框架提供的各种服务来看，面向对象实质上降低了编程的门槛，并且提高了人们的生产效率。

    通常，除非使用反射，我们很难使得代码不经过扩展而达到“向后兼容”。但反射本身并不优雅，而且执行效率会降低，泛型的推出解决了这样一个矛盾。我个人的理解是，可以将所谓“泛型”看成“类型参数”，传统上，参数基本是基于数据的，而引入了类型参数后，不但不会失去强类型的类型安全特点，还能使得代码被编译器优化，提高执行效率（是指“值类型的装箱、拆箱”操作等）。

    但从来没有完美的事，在当真要进行数据库转换、系统迁移的时候，比如从 SqlServer 变为 MySql 时，当前的 IDbExecutor 是不可能让数据库类型透明的：因为开发人员在组织 SQL 语句时必须知道数据库类型，SqlServer、MySql 有各自的 SQL 语言特性，相同的 SQL 语句并不能保证在两个数据库平台上成功运行！解决这个缺陷的办法，除了阉割当前数据库的 SQL 语言特性外（指禁止使用），我看是无解的；但分页操作（关键字 TOP/LIMIT）是无法回避的，而且，在 SqlServer 中参数使用“@p”，而 MySql 中使用“?p”，诸如此类，因此，这个缺陷就是无解的！数据库类型变化时，SQL 语句的改造再所难免，只不过从代码变化的量上，当前的数据访问方式要小得多！

（完）