ORM之Dapper

一、前言

上一篇【】我们已经有了架构的轮廓，现在我们就在这个轮廓里面造*。项目要想开始，肯定先得确定orm框架，目前市面上的orm框架有很多，对于.net人员来说很容易就想到以ado.net为基础所发展出来的orm框架entityframework。不得不说entityframework是一个功能很强大的orm框架，到现在最新的ef分别是ef6（.net framework）和ef core（.net core）两个版本。

但是这里我使用的另一个叫dapper的orm框架，原因是因为ef太重了，而dapper是一个轻量级开源的orm类，他是通过扩展idbconnection提供一些有用的扩展方法去查询您的数据库，所以ado.net支持的数据库，他都可以支持。在速度方面具有“king of micro orm”的头衔，几乎与使用原始的ado.net数据读取器一样快。第一次使用了他之后，就深深的喜欢上他了。

github地址：https://github.com/stackexchange/dapper

dapper文档：

二、dapper实现

2.1、dapper的方法

从dapper文档中，我们知道，dapper支持一下的方法：

execute：执行一次或多次命令并返回受影响的行数，包括存储过程
query：执行查询，返回类型为t的数据(返回数据为集合)
queryfirst：执行查询并映射第一个结果，如果没有就为null
queryfirstordefault：行查询并映射第一个结果，如果序列不包含任何元素，则可以映射默认值
querysingle：行查询并映射第一个结果，如果序列中没有一个元素，则抛出异常
querysingleordefault：执行查询并映射第一个结果，如果序列为空则映射默认值;如果序列中有多个元素，则此方法抛出异常
querymultiple：在同一命令中执行多个查询并映射结果

dapper还提供了上面方法相同功能的异步方法，同时每个方法也支持多种形式的传参。

2.2、dapper的使用

在前面的项目中，我们在 “04-datalayer”文件下面添加类库“pft.snail.dataaccess”。pft.snail.dataaccess主要是 用来完成dapper方法的使用。

在pft.snail.dataaccess项目下面创建文件“dappersqldb.cs”，代码如下：

 public class dappersqldb
    {
        /// <summary>
        /// 连接字符串
        /// </summary>
        public string connectionstring { get; set; }
        /// <summary>
        /// 数据库连接时间
        /// </summary>
        private int _commondtimeout { get { return 1200; } }

        public dappersqldb()
        {
        }
        public dappersqldb(string connectionstring)
        {
            connectionstring = connectionstring;
        }

        #region 查询

        /// <summary>
        /// 查询列表
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public list<t> query<t>(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return conn.query<t>(sql, param, commandtimeout: _commondtimeout).tolist();
            }
        }

        /// <summary>
        /// 异步查询列表
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public async task<ienumerable<t>> queryasync<t>(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return await conn.queryasync<t>(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /// <summary>
        /// 查询列表第一条数据
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public t queryfirstordefault<t>(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return conn.queryfirstordefault<t>(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /// <summary>
        /// 异步查询列表第一条数据
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public async task<t> queryfirstordefaultasync<t>(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return await conn.queryfirstordefaultasync<t>(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /// <summary>
        /// 查询选择单个值
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public t executescalar<t>(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return conn.executescalar<t>(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /// <summary>
        /// 异步查询选择单个值
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public async task<t> executescalarasync<t>(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return await conn.executescalarasync<t>(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /*调用方式
         * var multi=dbsqlhelper.querymultiple("",null);
         * var invoice = multi.read<invoice>().first();
         * var invoiceitems = multi.read<invoiceitem>().tolist();
         */
        /// <summary>
        /// 执行多个查询并映射结果
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public gridreader querymultiple(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return conn.querymultiple(sql, param, commandtimeout: _commondtimeout);
            }

        }

        /* 调用方式
         * await dbsqlhelper.querymultipleasync(sql, para, async (reader) =>
         *  {
         *      rs.a= (await reader.readfirstasync<singlevalue<decimal>>()).value;
         *      rs.b= (await reader.readfirstasync<singlevalue<decimal>>()).value;
         *      ...
         *  });
         */
        /// <summary>
        /// 异步执行多个查询并映射结果
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <param name="readercallback"></param>
        /// <returns></returns>
        public async task querymultipleasync(string sql, object param, action<gridreader> readercallback)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                using (var reader = await conn.querymultipleasync(sql, param, commandtimeout: _commondtimeout))
                {
                    if (readercallback != null)
                    {
                        readercallback(reader);
                    }
                }

            }
        }

        #endregion

        #region 执行sql

        /// <summary>
        /// 执行sql语句
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public int execute(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return conn.execute(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /// <summary>
        /// 异步执行sql语句
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public async task<int> executeasync(string sql, object param)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return await conn.executeasync(sql, param, commandtimeout: _commondtimeout);
            }
        }

        /// <summary>
        /// 执行sql语句（主要指存储过程）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public int execute(string sql, object param, commandtype type)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return conn.execute(sql, param, commandtimeout: _commondtimeout, commandtype: type);
            }
        }

        /// <summary>
        /// 异步执行sql语句（主要指存储过程）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public async task<int> executeasync(string sql, object param, commandtype type)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                return await conn.executeasync(sql, param, commandtimeout: _commondtimeout, commandtype: type);
            }
        }
        #endregion





    }

同时nuget添加system.data.sqlclient和dapper的引用。

上面已经实现了数据的增删改查操作，但是再使用过程就会发现，没有事务机制和分页功能。

添加事务功能

在pft.snail.dataaccess中添加接口“itransaction.cs”

public interface itransaction
    {
        list<t> query<t>(string sql, object param);
        t queryfirstordefault<t>(string sql, object param);
        t executescalar<t>(string sql, object param);
        int execute(string sql, object param);

    }

在“dappersqldb.cs”添加事务对象

        #region 事务方法

        /// <summary>
        /// 事务执行方法对象
        /// </summary>
        private class transaction : idisposable, itransaction
        {
            private idbconnection conn = null;
            private idbtransaction tran = null;
            public transaction(idbconnection conn, idbtransaction tran)
            {
                this.conn = conn;
                this.tran = tran;
            }


            list<t> itransaction.query<t>(string sql, object param)
            {
                return conn.query<t>(sql, param, tran).tolist();
            }

            t itransaction.queryfirstordefault<t>(string sql, object param)
            {
                return conn.queryfirstordefault<t>(sql, param, tran);
            }

            t itransaction.executescalar<t>(string sql, object param)
            {
                return conn.executescalar<t>(sql, param, tran);
            }

            int itransaction.execute(string sql, object param)
            {
                return conn.execute(sql, param, tran);
            }

            void idisposable.dispose()
            {
                if (this.tran != null)
                {
                    this.tran.dispose();
                }

                if (this.conn != null)
                {
                    this.conn.dispose();
                }
            }
        }

        #endregion

添加事务方法

/*调用方式
         * dbsqlhelper.executetransaction((trans) =>
         * {
         *     trans.execute(sqlinsertct, selectedclass);
         *     trans.execute(sqlinsertict, selectedclass);
         * });
         */
        /// <summary>
        /// 事务方法
        /// </summary>
        /// <param name="tranaction"></param>
        /// <param name="level"></param>
        /// <param name="newconnectionstring"></param>
        public void executetransaction(action<itransaction> tranaction, isolationlevel? level = null, string newconnectionstring = null)
        {
            using (idbconnection conn = new sqlconnection(connectionstring))
            {
                conn.open();
                idbtransaction tran = null;
                if (level == null)
                {
                    tran = conn.begintransaction();
                }
                else
                {
                    tran = conn.begintransaction(level.value);
                }
                using (transaction tranhelper = new transaction(conn, tran))
                {
                    try
                    {
                        tranaction(tranhelper);
                        tran.commit();
                    }
                    catch
                    {
                        tran.rollback();
                        throw;
                    }
                }
            }
        }

添加分页功能

在“pft.snail.dto”中添加“common”文件夹，下面在添加“pageresponse.cs”

/// <summary>
    /// 通用分页返回
    /// </summary>
    /// <typeparam name="t"></typeparam>
    public class pageresponse<t>
    {
        /// <summary>
        /// 总条数
        /// </summary>
        public long totalcount { get; set; }

        /// <summary>
        /// 返回
        /// </summary>
        public list<t> items { get; set; }

        /// <summary>
        /// 当前页
        /// </summary>
        public long pageindex { get; set; }

        /// <summary>
        /// 每页条数
        /// </summary>
        public long pagesize { get; set; }

        /// <summary>
        /// 总页数
        /// </summary>
        public long totalpages { get; set; }

        /// <summary>
        /// 返回筛选集合
        /// </summary>
        public dictionary<string, list<string>> resultfilter = new dictionary<string, list<string>>();

    }

在“dappersqldb.cs”添加分页功能

        /// <summary>
        /// sqlserver 分页查询（只支持sqlserver2012以上数据库）
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="page"></param>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public pageresponse<t> querypagesql<t>(pagerequest page, string sql, object param)
        {
            var pageresult = new pageresponse<t>();
            pageresult.pageindex = page.pageindex;

            var querynumsql = new stringbuilder($"select count(1) from ({sql}) as maptable");
            pageresult.totalcount = executescalar<int>(querynumsql.tostring(), param);
            if (pageresult.totalcount == 0)
            {
                return pageresult;
            }

            var pagemincount = (page.pageindex - 1) * page.pagesize + 1;
            if (pageresult.totalcount < pagemincount)
            {
                page.pageindex = (int)((pageresult.totalcount - 1) / page.pagesize) + 1;
            }

            var querysql = new stringbuilder($@"select maptable.* from ({sql}) as maptable ");
            if (!string.isnullorwhitespace(page.sortby))
            {
                querysql.appendline(page.getorderbysql());
            }
            querysql.appendline($" offset {(page.pageindex - 1) * page.pagesize} rows fetch next {page.pagesize} rows only;");

            pageresult.items = query<t>(querysql.tostring(), param);
            return pageresult;
        }

分页的代码只支持sql2012以上的版本，如果是一下的版本，可以自己重构代码。

到现在才算把dapper框架的运用方法全部实现了。

三、总结

虽然实现了dapper框架的运用方法，但是在真实的项目中，运用这样的方法或多或少有很多不便。同时在架构的设计来说，也不是太合理，因为repository依赖dappersqldb的具体实现，需要抽象出接口。既然存在所说的问题，那为什么不直接写出最终方法呢？这是因为必须弄清楚dapper的运用，我们才能够对他进行定制化的优化。