轻量ORM-SqlRepoEx （十一）扩展

以下为 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;
        }
    }