欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

ORM之Dapper

程序员文章站 2022-10-19 23:00:24
一、前言 上一篇【分层架构设计】我们已经有了架构的轮廓,现在我们就在这个轮廓里面造*。项目要想开始,肯定先得确定ORM框架,目前市面上的ORM框架有很多,对于.net人员来说很容易就想到以ADO.NET为基础所发展出来的ORM框架EntityFramework。不得不说EntityFramewor ......

一、前言

上一篇【】我们已经有了架构的轮廓,现在我们就在这个轮廓里面造*。项目要想开始,肯定先得确定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的运用,我们才能够对他进行定制化的优化。