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

轻量ORM-SqlRepoEx (十一)扩展

程序员文章站 2022-04-15 10:49:33
以下为 SqlRepoEx.MsSql.ServiceCollection 代码 public static IServiceCollection AddSqlRepo(this IServiceCollection serviceCollection) { serviceCollection.Ad ......

以下为 sqlrepoex.mssql.servicecollection 代码

        public static iservicecollection addsqlrepo(this iservicecollection servicecollection)

        {

            servicecollection.addtransient<irepositoryfactory, repositoryfactory>();

            servicecollection.addtransient<istatementfactoryprovider, mssqlstatementfactoryprovider>();

            servicecollection.addtransient<ientitymapper, datareaderentitymapper>();

            servicecollection.addtransient<iwritablepropertymatcher, writablepropertymatcher>();

            servicecollection.addtransient<isqllogger, sqllogger>();

            servicecollection.addtransient<istatementexecutor, mssqlstatementexecutor>();

            return servicecollection;

        }

本质上,其处出现的接口及其实现类,其接口的实现类都是可以自定义的

其中,ientitymapper,istatementexecutor两个接口去扩展更具有意义。

其他的高级扩展暂时未开放,不作介绍

我们以dapper的扩展为例,参照实现,扩展自己定制的功能

一、ientitymapper 实例映射器接口,其功能主要是 将数据提供者idatareader中的数据,转换到应用程序可用的数据或数据集中

 其接口定义为

 

    /// <summary>
    /// 实例映射器接口,将idatareader中的数据转换成tentity类型实例
    /// 用户可以实现自已的映射器,来实现业务中数据与tentity类之间的转换
    /// 默认的映射器为 datareaderentitymapper ,sqlrepoex中还实现了
    /// 与dapper互动的dapperentitymapper。
    /// ientitymapper必需实现并指定,以供 sqlrepoex 使用。
    /// </summary>
    public interface ientitymapper
    {
 
        ienumerable<tentity> map<tentity>(idatareader reader) where tentity : class, new();
 
        list<tentity> maplist<tentity>(idatareader reader) where tentity : class, new();
 
        tlentity mapentitylist<tlentity, t>(idatareader reader) where tlentity : list<t>, new() where t : class, new();
    }

 

sqlrepoex.adapter.dapper中的实现

 

 /// <summary>
    /// 支持 dapper 的实例映射器
    /// https://github.com/stackexchange/dapper
    /// </summary>
    public class dapperentitymapper : ientitymapper
    {
        /// <summary>
        /// 从访问关系数据库的数据提供者idatareader。读取一个或多个正向的结果集流,并将此
        /// 数据集映射到dto列表中。 
        /// </summary>
        /// <typeparam name="tentity">dto 类型</typeparam>
        /// <param name="reader">访问关系数据库的数据提供者</param>
        /// <returns></returns>
        public ienumerable<tentity> map<tentity>(idatareader reader) where tentity : class, new()
        {
            return reader.parse<tentity>().tolist();
        }
 
        /// <summary>
        /// 从访问关系数据库的数据提供者idatareader。读取一个或多个正向的结果集流,并将此
        /// 数据集映射到dto列表中。 
        /// </summary>
        /// <typeparam name="tlentity">list dto 类型</typeparam>
        /// <typeparam name="t">dto 类型</typeparam>
        /// <param name="reader">访问关系数据库的数据提供者</param>
        /// <returns></returns>
        public tlentity mapentitylist<tlentity, t>(idatareader reader)
            where tlentity : list<t>, new()
            where t : class, new()
        {
            var list = new tlentity();
            list.addrange(reader.parse<t>());
            return list;
        }
 
        /// <summary>
        /// 从访问关系数据库的数据提供者idatareader。读取一个或多个正向的结果集流,并将此
        /// 数据集映射到dto列表中。 
        /// </summary>
        /// <typeparam name="tentity">dto 类型</typeparam>
        /// <param name="reader">访问关系数据库的数据提供者</param>
        /// <returns></returns>
        public list<tentity> maplist<tentity>(idatareader reader) where tentity : class, new()
        {
            return reader.parse<tentity>().tolist();
        }
    }

 

 二、istatementexecutor 语句执行器接口,其功能是 sqlrepoex 执行sql的各种操作

 

其接口定义为

 

    /// <summary>
    /// sql语句执行器(必需)。sqlrepoex需要此接口的实现类来执行sql语句。
    /// 用户可自定义此接口实现类,以达到所需执行效果。
    /// </summary> 
public interface istatementexecutor
    {
        int executenonquery(string sql);
 
        task<int> executenonqueryasync(string sql);
 
 
        int executenonquerystoredprocedure(string name, params parameterdefinition[] parameterdefinitions);
 
        task<int> executenonquerystoredprocedureasync(string name,
            params parameterdefinition[] parameterdefinitions);
 
        idatareader executereader(string sql);
 
        task<idatareader> executereaderasync(string sql);
 
        idatareader executestoredprocedure(string name, params parameterdefinition[] parametersdefinitions);
 
        task<idatareader> executestoredprocedureasync(string name,
            params parameterdefinition[] parametersdefinitions);
 
        istatementexecutor useconnectionprovider(iconnectionprovider connectionprovider);
    }

 

sqlrepoex.adapter.dapper中的实现

 

/// <summary>
    /// dapper语句执行器
    /// https://github.com/stackexchange/dapper
    /// </summary>
    public class dapperstatementexecutor : istatementexecutor
    {
        private iconnectionprovider connectionprovider;
        private dbconnection dbconnection;
 
        private dynamicparameters turnparameters(parameterdefinition[] parameterdefinitions)
        {
            if (parameterdefinitions == null)
            {
                return null;
            }
 
            if (parameterdefinitions.length == 0)
            {
                return null;
            }
 
            var p = new dynamicparameters();
            foreach (var pd in parameterdefinitions)
            {
                p.add(pd.name, pd.value, pd.dbtype, pd.direction, pd.size);
 
            }
            return p;
        }
 
        /// <summary>
        /// dapper语句执行器构造
        /// </summary>
        /// <param name="connectionprovider">数据连接提供者</param>
        public dapperstatementexecutor(iconnectionprovider connectionprovider)
        {
            this.connectionprovider = connectionprovider;
            this.dbconnection = connectionprovider.getdbconnection;
        }
        /// <summary>
        /// 执行并返回 parameterdirection.returnvalue中的值。
        /// </summary>
        /// <param name="sql">需要执行的sql</param>
        /// <returns></returns>
        public int executenonquery(string sql)
        {
            return dbconnection.execute(sql);
        }
        /// <summary>
        /// 异步执行并返回 parameterdirection.returnvalue中的值。
        /// </summary>
        /// <param name="sql">需要执行的sql</param>
        /// <returns></returns>
        public task<int> executenonqueryasync(string sql)
        {
            return dbconnection.executeasync(sql);
        }
        /// <summary>
        /// 执行指定存储过程,并返回 parameterdirection.returnvalue中的值。
        /// </summary>
        /// <param name="name">存储过程名</param>
        /// <param name="parameterdefinitions">存储过程参数列表</param>
        /// <returns>返回 parameterdirection.returnvalue 中的值</returns>
        public int executenonquerystoredprocedure(string name, params parameterdefinition[] parameterdefinitions)
        {
            var args = turnparameters(parameterdefinitions);
 
            return dbconnection.execute(name, args, commandtype: commandtype.storedprocedure);
        }
        /// <summary>
        /// 异步执行指定存储过程,并返回 parameterdirection.returnvalue中的值。
        /// </summary>
        /// <param name="name">存储过程名</param>
        /// <param name="parameterdefinitions">存储过程参数列表</param>
        /// <returns>返回 parameterdirection.returnvalue 中的值</returns>
        public task<int> executenonquerystoredprocedureasync(string name, params parameterdefinition[] parameterdefinitions)
        {
            var args = turnparameters(parameterdefinitions);
 
            return dbconnection.executeasync(name, args, commandtype: commandtype.storedprocedure);
        }
        /// <summary>
        /// 执行指定sql,并以idatareader形式返回。
        /// </summary>
        /// <param name="sql">需要执行的sql</param>
        /// <returns></returns>
        public idatareader executereader(string sql)
        {
            return dbconnection.executereader(sql);
        }
        /// <summary>
        /// 异步执行指定sql,并以idatareader形式返回。
        /// </summary>
        /// <param name="sql">需要执行的sql</param>
        /// <returns></returns>
        public task<idatareader> executereaderasync(string sql)
        {
            return dbconnection.executereaderasync(sql);
        }
        /// <summary>
        /// 执行指定存储过程,并以idatareader形式返回。
        /// </summary>
        /// <param name="name">存储过程名</param>
        /// <param name="parametersdefinitions">参数列表</param>
        /// <returns></returns>
        public idatareader executestoredprocedure(string name, params parameterdefinition[] parametersdefinitions)
        {
            var args = turnparameters(parametersdefinitions);
            return dbconnection.executereader(name, args, commandtype: commandtype.storedprocedure);
        }
        /// <summary>
        /// 异步执行指定存储过程,并以idatareader形式返回。
        /// </summary>
        /// <param name="name">存储过程名</param>
        /// <param name="parametersdefinitions">参数列表</param>
        /// <returns></returns>
        public task<idatareader> executestoredprocedureasync(string name, params parameterdefinition[] parametersdefinitions)
        {
            var args = turnparameters(parametersdefinitions);
 
            return dbconnection.executereaderasync(name, args, commandtype: commandtype.storedprocedure);
        }
        /// <summary>
        /// 指定数据连接提供者
        /// </summary>
        /// <param name="connectionprovider">数据连接提供者</param>
        /// <returns></returns>
        public istatementexecutor useconnectionprovider(iconnectionprovider connectionprovider)
        {
            this.connectionprovider = connectionprovider;
            return this;
        }
    }