当前位置： 移动技术网 > IT编程>开发语言>.net > 使用Dapper.Contrib 开发.net core程序，兼容多种数据库

使用Dapper.Contrib 开发.net core程序，兼容多种数据库

2018年11月14日  | 移动技术网IT编程  | 我要评论

吉雪萍近况,拳皇1.5,jianxian

关于dapper的介绍，我想很多人都对它有一定的了解，这个类似一个轻型的orm框架是目前应用非常火的一个东西，据说各方面的性能都不错，而且可以支持多种数据库，在开始介绍这个文章之前，我花了不少功夫来学习了dapper 的相关使用。dapper.contrib是对dapper的进一步封装，使对象的基本增删改查等操作进一步简化，我做了一个案例使用dapper.contrib 开发.net core程序，测试它对多种数据库的处理。

1、dapper.contrib的使用

前面介绍过，dapper.contrib是对dapper的进一步封装，使对象的基本增删改查等操作进一步简化。

它主要是通过特性映射的方式实现自定义类和数据库之间的关系处理，如下是实体类的定义信息。

    [table("t_customer")]
    public class customerinfo
    {
        [explicitkey]//非自增长的用此标识
        public virtual string id { get; set; }

        public virtual string name { get; set; }

        public virtual int age { get; set; }

        public virtual string creator { get; set; }

        public virtual datetime createtime { get; set; }

    }

dapper.contrib的所有实体配置选项

  • table：指定实体对应地数据库表名，如果类名和数据库表名不同，需要设置（如案例所示）
  • key：指定此列为自动增长主键
  • explicitkey：指定此列为非自动增长主键（例如guid，字符串列）
  • computed：计算属性，此列不作为更新
  • write：指定列是否可写

通过定义好实体类和数据库表的映射关系，就可以通过强类型处理相关的接口了，如下所示。

t get<t>(id);
ienumerable<t> getall<t>();
int insert<t>(t obj);
int insert<t>(enumerable<t> list);
bool update<t>(t obj);
bool update<t>(enumerable<t> list);
bool delete<t>(t obj);
bool delete<t>(enumerable<t> list);
bool deleteall<t>();

这样通过映射指定表名或者字段信息后，就可以知道类和表之间的关系，可以封装对应的强类型处理接口了。

2、dapper.contrib 开发.net core程序

我们创建一个空白的.net core程序框架后，就在它的基础上做一些dapper的数据库测试。

首先为了考虑多数据库的处理，我们需要创建一个配置文件，并可以动态配置不同的数据库，配置文件appsettings.json如下所示。

上面我配置了多种数据库的连接字符串，并且通过动态指定节点名称和数据库类型，来实现对项目指向不同数据库的访问。

例如我们准备需要让dapper支持我们常见的数据库类型，如下定义数据库类型。

    /// <summary>
    /// 数据库类型定义
    /// </summary>
    public enum databasetype
    {
        sqlserver,  //sqlserver数据库
        mysql,      //mysql数据库
        npgsql,     //postgresql数据库
        oracle,     //oracle数据库
        sqlite,     //sqlite数据库
        db2         //ibm db2数据库
    }

对于不同的数据库信息，我们需要根据不同的配置连接字符串，并创建对应的数据库连接对象供dapper使用，如对于sqlserver的数据库，那么创建的是sqlconnection对象，对于mysql，创建的是mysqlconnection连接对象，对于postgresql对应的是npgsqlconnection，以此类推。而dapper则通过对连接对象的扩展实现了多种数据请求。

对于多数据库的支持，我们需要统一解析配置内容appsetting.json的内容，并返回不同数据库的连接对象，如下是连接工厂的统一处理方式，通过 createconnection() 返回配置的连接对象。

    /// <summary>
    /// 数据库连接辅助类
    /// </summary>
    public class connectionfactory
    {
        /// <summary>
        /// 转换数据库类型
        /// </summary>
        /// <param name="databasetype">数据库类型</param>
        /// <returns></returns>
        private static databasetype getdatabasetype(string databasetype)
        {
            databasetype returnvalue = databasetype.sqlserver;
            foreach (databasetype dbtype in enum.getvalues(typeof(databasetype)))
            {
                if (dbtype.tostring().equals(databasetype, stringcomparison.ordinalignorecase))
                {
                    returnvalue = dbtype;
                    break;
                }
            }
            return returnvalue;
        }

        /// <summary>
        /// 获取数据库连接
        /// </summary>
        /// <returns></returns>
        public static idbconnection createconnection()
        {
            idbconnection connection = null;

            //获取配置进行转换
            var type = appconfig.getconfig("componentdbtype");
            var dbtype = getdatabasetype(type);

            //defaultdatabase 根据这个配置项获取对应连接字符串
            var database = appconfig.getconfig("defaultdatabase");
            if (string.isnullorempty(database))
            {
                database = "sqlserver";//默认配置
            }
            var strconn = appconfig.configuration.getconnectionstring(database);

            switch (dbtype)
            {
                case databasetype.sqlserver:
                    connection = new system.data.sqlclient.sqlconnection(strconn);
                    break;
                case databasetype.mysql:
                    connection = new mysql.data.mysqlclient.mysqlconnection(strconn);
                    break;
                case databasetype.npgsql:
                    connection = new npgsql.npgsqlconnection(strconn);
                    break;
                case databasetype.sqlite:
                    connection = new sqliteconnection(strconn);
                    break;
                case databasetype.oracle:
                    connection = new oracle.manageddataaccess.client.oracleconnection(strconn);
                    //connection = new system.data.oracleclient.oracleconnection(strconn);
                    break;
                case databasetype.db2:
                    //connection = new system.data.oledb.oledbconnection(strconn);
                    break;
            }

            return connection;
        }
    }

有了数据库对象工厂，我们的配置就可以动态化了。

下面我们来看看，获得这些连接对象后，如何通过dapper.contrib来获取对应的对象了，下面的类是常规的对数据库信息的处理，包括常规的增删改查等基础接口。

    /// <summary>
    /// 常规的数据访问层
    /// </summary>
    public class customer
    {
        public idbconnection connection
        {
            get
            {
                var connection = connectionfactory.createconnection();
                connection.open();
                return connection;
            }
        }

        public ienumerable<customerinfo> getall()
        {
            using (idbconnection dbconnection = connection)
            {
                return dbconnection.getall<customerinfo>();
                //return dbconnection.query<customerinfo>("select * from t_customer");
            }
        }


        public customerinfo findbyid(string id)
        {
            using (idbconnection dbconnection = connection)
            {
                return dbconnection.get<customerinfo>(id);
                //string query = "select * from t_customer where id = @id";
                //return dbconnection.query<customerinfo>(query, new { id = id }).firstordefault();
            }
        }

        public bool insert(customerinfo info)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.insert(info) > 0;
                result = true;
                //string query = "insert into t_customer (id, name, age, creator, createtime)"
                //                + " values(@id, @name, @age, @creator, @createtime)";
                //result = dbconnection.execute(query, info) > 0;
            }
            return result;
        }
        
        public bool update(customerinfo prod)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.update(prod);
                //string query = "update t_customer set name = @name,"
                //               + " age = @age, creator= @creator, createtime=@createtime"
                //               + " where id = @id";
                //result = dbconnection.execute(query, prod) > 0;
            }
            return result;
        }
        public bool delete(string id)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.delete(new customerinfo { id = id });
                //string query = "delete from t_customer where id = @id";
                //result = dbconnection.execute(query, new { id = id }) > 0;
            }
            return result;
        }
        public bool deleteall()
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.deleteall<customerinfo>();
                //string query = "delete from t_customer where id = @id";
                //result = dbconnection.execute(query, new { id = id }) > 0;
            }
            return result;
        }
    }

其中的备注部分的代码是等同于上面的执行代码的，是dapper 的sql版本的一种处理方式。

我们看到，对于customer表来说，使用对象的接口处理，我们已经隔离了很多硬编码的sql处理，不过我们还可以对它进行进一步的优化处理。

我们定义一个通用的basedal来剥离常规的增删改查处理，并且把同步和异步的操作分来两个文件来管理，同步处理的基类如下代码所示。

    /// <summary>
    /// 数据库访问基类
    /// </summary>
    /// <typeparam name="t">实体类类型</typeparam>
    public partial class basedal<t> where t : class
    {
        /// <summary>
        /// 对象的表名
        /// </summary>
        public string tablename { get; set; }

        /// <summary>
        /// 主键属性对象
        /// </summary>
        public propertyinfo primarykey { get; set; }

        public basedal()
        {
            this.tablename = entityhelper.gettablename(typeof(t));
            this.primarykey = entityhelper.getsinglekey<t>();
        }

        /// <summary>
        /// 数据库连接
        /// </summary>
        protected idbconnection connection
        {
            get
            {
                var connection = connectionfactory.createconnection();
                connection.open();
                return connection;
            }
        }

        /// <summary>
        /// 返回数据库所有的对象集合
        /// </summary>
        /// <returns></returns>
        public ienumerable<t> getall()
        {
            using (idbconnection dbconnection = connection)
            {
                return dbconnection.getall<t>();
            }
        }

        /// <summary>
        /// 查询数据库,返回指定id的对象
        /// </summary>
        /// <param name="id">主键的值</param>
        /// <returns></returns>
        public t findbyid(object id)
        {
            using (idbconnection dbconnection = connection)
            {
                return dbconnection.get<t>(id);
            }
        }

        /// <summary>
        /// 插入指定对象到数据库中
        /// </summary>
        /// <param name="info">指定的对象</param>
        /// <returns></returns>
        public bool insert(t info)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                dbconnection.insert(info);
                result = true;
            }
            return result;
        }
        /// <summary>
        /// 插入指定对象集合到数据库中
        /// </summary>
        /// <param name="list">指定的对象集合</param>
        /// <returns></returns>
        public bool insert(ienumerable<t> list)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.insert(list) > 0;
            }
            return result;
        }

        /// <summary>
        /// 更新对象属性到数据库中
        /// </summary>
        /// <param name="info">指定的对象</param>
        /// <returns></returns>
        public bool update(t info)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.update(info);
            }
            return result;
        }
        /// <summary>
        /// 更新指定对象集合到数据库中
        /// </summary>
        /// <param name="list">指定的对象集合</param>
        /// <returns></returns>
        public bool update(ienumerable<t> list)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.update(list);
            }
            return result;
        }
        /// <summary>
        /// 从数据库中删除指定对象
        /// </summary>
        /// <param name="info">指定的对象</param>
        /// <returns></returns>
        public bool delete(t info)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.delete(info);
            }
            return result;
        }
        /// <summary>
        /// 从数据库中删除指定对象集合
        /// </summary>
        /// <param name="list">指定的对象集合</param>
        /// <returns></returns>
        public bool delete(ienumerable<t> list)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.delete(list);
            }
            return result;
        }
        /// <summary>
        /// 根据指定对象的id,从数据库中删除指定对象
        /// </summary>
        /// <param name="id">对象的id</param>
        /// <returns></returns>
        public bool delete(object id)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                string query = string.format("delete from {0} where {1} = @id", tablename, primarykey.name);
                var parameters = new dynamicparameters();
                parameters.add("@id", id);

                result = dbconnection.execute(query, parameters) > 0;
            }
            return result;
        }
        /// <summary>
        /// 从数据库中删除所有对象
        /// </summary>
        /// <returns></returns>
        public bool deleteall()
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                result = dbconnection.deleteall<t>();
            }
            return result;
        }

    }

异步类的代码如下所示。

    /// <summary>
    /// 数据库访问基类
    /// </summary>
    /// <typeparam name="t">实体类类型</typeparam>
    public partial class basedal<t> where t : class
    {
        /// <summary>
        /// 返回数据库所有的对象集合
        /// </summary>
        /// <returns></returns>
        public virtual async task<ienumerable<t>> getallasync()
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.getallasync<t>();
            }
        }

        /// <summary>
        /// 查询数据库,返回指定id的对象
        /// </summary>
        /// <param name="id">主键的值</param>
        /// <returns></returns>
        public virtual async task<t> findbyidasync(object id)
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.getasync<t>(id);
            }
        }
        /// <summary>
        /// 插入指定对象到数据库中
        /// </summary>
        /// <param name="info">指定的对象</param>
        /// <returns></returns>
        public virtual async task<bool> insertasync(t info)
        {
            bool result = false;
            using (idbconnection dbconnection = connection)
            {
                await dbconnection.insertasync(info);
                result = true;
            }
            return await task<bool>.fromresult(result);
        }

        /// <summary>
        /// 插入指定对象集合到数据库中
        /// </summary>
        /// <param name="list">指定的对象集合</param>
        /// <returns></returns>
        public virtual async task<bool> insertasync(ienumerable<t> list)
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.insertasync(list) > 0;
            }
        }
        /// <summary>
        /// 更新对象属性到数据库中
        /// </summary>
        /// <param name="info">指定的对象</param>
        /// <returns></returns>
        public virtual async task<bool> updateasync(t info)
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.updateasync(info);
            }
        }

        /// <summary>
        /// 更新指定对象集合到数据库中
        /// </summary>
        /// <param name="list">指定的对象集合</param>
        /// <returns></returns>
        public virtual async task<bool> updateasync(ienumerable<t> list)
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.updateasync(list);
            }
        }

        /// <summary>
        /// 从数据库中删除指定对象
        /// </summary>
        /// <param name="info">指定的对象</param>
        /// <returns></returns>
        public virtual async task<bool> deleteasync(t info)
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.deleteasync(info);
            }
        }

        /// <summary>
        /// 从数据库中删除指定对象集合
        /// </summary>
        /// <param name="list">指定的对象集合</param>
        /// <returns></returns>
        public virtual async task<bool> deleteasync(ienumerable<t> list)
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.deleteasync(list);
            }
        }

        /// <summary>
        /// 根据指定对象的id,从数据库中删除指定对象
        /// </summary>
        /// <param name="id">对象的id</param>
        /// <returns></returns>
        public virtual async task<bool> deleteasync(object id)
        {
            using (idbconnection dbconnection = connection)
            {
                string query = string.format("delete from {0} where {1} = @id", tablename, primarykey.name);
                var parameters = new dynamicparameters();
                parameters.add("@id", id);

                return await dbconnection.executeasync(query, parameters) > 0;
            }
        }

        /// <summary>
        /// 从数据库中删除所有对象
        /// </summary>
        /// <returns></returns>
        public virtual async task<bool> deleteallasync()
        {
            using (idbconnection dbconnection = connection)
            {
                return await dbconnection.deleteallasync<t>();
            }
        }
    }

这样，我们如果需要增加一个如客户信息表的管理类，就很简单的继承基类就可以了，代码很少，但是增删改查接口一个也少不了。

    /// <summary>
    /// 继承基类对象管理
    /// </summary>
    public class customerdal :basedal<customerinfo>
    {
    }

为了测试一下数据访问层的处理接口，我创建了一个.net core的控制台程序进行测试，如下项目视图所示。

主要目的是确认数据处理的效果。

我们在program.cs类里面增加相关的测试代码，为了简便和处理效果没有用unittest处理。

            //创建管理对象，并测试接口
            var customer = new customerdal();
            var list = customer.getall();
            foreach (var item in list)
            {
                console.writeline(item.tojson());
                var info = customer.findbyid(item.id);
                console.writeline(info.tojson());
                console.writeline();
            }

            //插入记录
            var insertinfo = new customerinfo() { name = "test", age = 30, creator = "test" };
            var insertlist = new list<customerinfo>() { insertinfo };
            var flag = customer.insert(insertlist);
            console.writeline("插入操作" + (flag ? "成功" : "失败"));

            console.writeline("插入的新内容");
            insertinfo = customer.findbyid(insertinfo.id);
            console.writeline(insertinfo.tojson());

            console.writeline("更新内容");
            insertinfo.name = "test" + datetime.now.toshortdatestring();
            flag = customer.update(insertinfo);
            console.writeline("更新操作" + (flag ? "成功" : "失败"));

            console.writeline("更新的新内容");
            insertinfo = customer.findbyid(insertinfo.id);
            console.writeline(insertinfo.tojson());

            console.writeline("删除内容");
            flag = customer.delete(insertinfo.id);
            console.writeline("删除操作" + (flag ? "成功" : "失败"));


            console.writeline("所有内容");
            list = customer.getall();
            foreach (var item in list)
            {
                console.writeline(item.tojson());
                console.writeline();
            }

            console.readline();

测试mysql、sqlite数据库同样没有问题

mysql配置信息如下

处理的mysql记录信息如下。 

sqlite配置信息如下

处理sqlite数据信息如下

 

 而在处理postgresql的信息（配置节点npgsql里面）的时候，查询的主键好像和大小写有关系，导致插入记录出错。

而oracle我采用的是oracle.manageddataaccess.core进行访问，由于我本地oracle数据库侦听处理有点问题，因此没有测试成功，暂不予置评。

而对于数据库的支持问题，导致我重新审核一下是否采用dapper.contrib还是其他dapper方式来构建数据库访问基类的问题，我需要兼容多种数据库的信息，并且能够尽可能的封装常规的增删改查等操作，其中目前的基类还没有加入更加复杂的查询操作，分页操作等功能，在解决这些困惑问题，才会继续考虑把底层支持的接口全部完善。 

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网