[LINQ2Dapper]最完整Dapper To Linq扩展

此例子是使用LINQ2Dapper封装，效率优于EntityFramwork，并且支持.NetFramework和.NetCore框架，只依赖于Dapper

需要先引用包Kogel.Dapper.Extension和Kogel.Dapper.Extension.MsSql(目前还支持Oracle),Nuget上可以下载安装。

Model实体类

using Kogel.Dapper.Extension.Attributes;

public class users
    {
        /// <summary>
        /// 用户id(特性Identity标识该字段为主键)
        /// </summary>    
        [Identity]
        [Display(Name = "用户id")]
        public int id { get; set; }

/// <summary>
        /// code
        /// </summary>    
        [StringLength(50)]
        [Display(Name = "code")]
        public string code { get; set; }

/// <summary>
        /// 用户名称
        /// </summary>    
        [StringLength(50)]
        [Display(Name = "用户名称")]
        public string name { get; set; }

/// <summary>
        /// 创建方式(1自定义角色 2通用角色)
        /// </summary>    
        [Display(Name = "创建方式(1自定义角色 2通用角色)")]
        public int createWay { get; set; }

/// <summary>
        /// 创建时间
        /// </summary>    
        [Display(Name = "创建时间")]
        public DateTime createDate { get; set; }

/// <summary>
        /// 创建人
        /// </summary>    
        [StringLength(50)]
        [Display(Name = "创建人")]
        public string createUsers { get; set; }

/// <summary>
        /// 角色id
        /// </summary>    
        [Display(Name = "角色id")]
        public int roleId { get; set; }

Dapper帮助类（可以自己实现）

public enum Providers
    {
        SqlClient,
        OracleClient,
        // ReSharper disable once InconsistentNaming
        SQLite
    }
    public class Resource
    {
        /// <summary>
        /// 项目资源路径
        /// </summary>
        public static string url { get; set; }
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public static string connectionString { get; set; }
    }
    public class DapperHelper : IDbConnection, IDisposable
    {
        public IDbConnection Connection { get; }
        public string ConnectionString { get => Resource.connectionString; set => Connection.ConnectionString = value; }
        public int ConnectionTimeout => Connection.ConnectionTimeout;
        public string Database => Connection.Database;
        public ConnectionState State => Connection.State;
        /// <summary>
        /// Dapper帮助类创建
        /// </summary>
        /// <param name="providers">连接数据库对象</param>
        public DapperHelper(Providers providers = Providers.SqlClient)
        {
            switch (providers)
            {
                case Providers.SqlClient:
                    Connection = new SqlConnection(ConnectionString);
                    break;
                case Providers.OracleClient:
                    // Connection = new OracleConnection(connectionString);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(providers), providers, null);
            }
        }
        public DapperHelper(string connectionString, Providers providers = Providers.SqlClient)
        {
            switch (providers)
            {
                case Providers.SqlClient:
                    Connection = new SqlConnection(connectionString);
                    break;
                case Providers.OracleClient:
                    // Connection = new OracleConnection(connectionString);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(providers), providers, null);
            }
        }
        /// <summary>
        /// 对象释放
        /// </summary>
        public void Dispose()
        {
            Connection.Dispose();
        }
        #region 通用方法
        public IDbTransaction BeginTransaction() => Connection.BeginTransaction();
        public IDbTransaction BeginTransaction(System.Data.IsolationLevel il) => Connection.BeginTransaction(il);
        public void ChangeDatabase(string databaseName) => Connection.ChangeDatabase(databaseName);
        public void Close() => Connection.Close();
        public IDbCommand CreateCommand() => Connection.CreateCommand();
        /// <summary>
        /// 执行sql（返回影响行数）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public int Execute(string sql, object param = null, CommandType commandType = CommandType.Text) => Connection.Execute(sql, param, null, null, commandType);
        /// <summary>
        /// 执行sql（返回DataReader对象）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public IDataReader ExecuteReader(string sql, object param = null) => Connection.ExecuteReader(sql, param);
        /// <summary>
        /// 执行sql（返回第一行第一列的执行结果）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public object ExecuteScalar(string sql, object param = null, CommandType commandType = CommandType.Text) => Connection.ExecuteScalar(sql, param, null, null, commandType);
        public SqlMapper.GridReader QueryMultiple(string sql, object param = null) => Connection.QueryMultiple(sql, param);
        /// <summary>
        /// 查询sql（返回一个匿名类型的集合）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public IEnumerable<dynamic> Query(string sql, object param = null)
        {
            return Connection.Query(sql, param);
        }
        /// <summary>
        ///  查询sql（返回一个匿名类型）
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public dynamic QueryFirst(string sql, object param = null) => Connection.QueryFirst(sql, param);
        public dynamic QueryFirstOrDefault(string sql, object param = null) => Connection.QueryFirstOrDefault(sql, param);
        public dynamic QuerySingle(string sql, object param = null) => Connection.QuerySingle(sql, param);
        public dynamic QuerySingleOrDefaul(string sql, object param = null) => Connection.QuerySingleOrDefault(sql, param);
        /// <summary>
        ///  查询sql（返回一个对象的集合）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public IEnumerable<T> Query<T>(string sql, object param = null) => Connection.Query<T>(sql, param);
        public T QueryFirst<T>(string sql, object param = null) => Connection.QueryFirst<T>(sql, param);
        public T QueryFirstOrDefault<T>(string sql, object param = null) => Connection.QueryFirstOrDefault<T>(sql, param);
        public T QuerySingle<T>(string sql, object param = null) => Connection.QuerySingle<T>(sql, param);
        public T QuerySingleOrDefault<T>(string sql, object param = null) => Connection.QuerySingleOrDefault<T>(sql, param);
        public void Open()
        {
            Connection.Open();
        }
        #endregion

}

使用实例

//Dapper扩展
using Kogel.Dapper.Extension.MsSql;
using Kogel.Dapper.Extension.MsSql.Extension;
using Kogel.Dapper.Extension.MsSql.Helper;

namespace Kogel.Framework.Test.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            using (var conn = new DapperHelper())
            {
                //模型类属性不能出现可空类型,例如int?     project_Role也是实体类
                var list = conn.QuerySet<users>().Where(x => x.name.Contains("Y")).ToList();
                //查询
                var users = conn.QuerySet<users>().Where(x => x.code != "1").Get();
                ViewData["Message"] = "Hellow " + users.name;
                //模糊查询
                var users1 = conn.QuerySet<users>().Where(x => x.name.Contains("Y")).Get();
                ViewData["Message1"] = "Hellow " + users1.name;
                //修改
                users1.name = Guid.NewGuid().ToString();
                users1.createDate = DateTime.Now;
                int result = conn.CommandSet<users>().Where(x => x.id == 4).Update(users1);
                ViewData["Message2"] = result;
                //修改查询
                var users2 = conn.QuerySet<users>().Where(x => x.name.Contains("Y")).UpdateSelect(x => new users { name = "Y11" }).FirstOrDefault();
                ViewData["Message3"] = "Hellow " + users2.name;
                //新增
                int result2 = conn.CommandSet<users>().Insert(new users() { code = Guid.NewGuid().ToString(), name = "test", createWay = 1, createDate = DateTime.Now, roleId = 2 });
                ViewData["Message4"] = result2;
                //删除
                int result3 = conn.CommandSet<users>().Where(x => x.roleId == 0).Delete();
                ViewData["Message5"] = result3;
                //不连表查询返回dynamic
                var list1 = conn.QuerySet<users>().Where(x => x.code != "1").ToList(true);
                //连表查询返回dynamic
                var list2 = conn.QuerySet<users>().Where(x => x.code != "1").Join<users, project_Role>(x => x.roleId, y => y.id).ToList(true);
                //SQL连表查询
                var users3 = conn.Query<users>(@"SELECT * FROM USERS 
                                                 LEFT JOIN PROJECT_ROLE ON PROJECT_ROLE.ID=USERS.ROLEID").ToList();
                //翻页查询
                var list3 = conn.QuerySet<users>().OrderBy(x => x.createDate).PageList(1, 10);
                //翻页连表查询返回dynamic
                var list4 = conn.QuerySet<users>().Join<users, project_Role>(x => x.roleId, y => y.id).OrderBy(x => x.createDate).PageList(1, 10, true);
                //动态化查询
                var list5 = conn.QuerySet<users>().Where(new users() { id = 2, name = "Y11" }).Get();
                //连表使用主表和副表条件翻页查询
                var list6 = conn.QuerySet<users>().Join<users, project_Role>(x => x.roleId, y => y.id).Where(x => x.name == "adonis")
                    .Where<project_Role>(x => x.projectId == 2 && x.enabled == true).OrderBy(x => x.createDate).PageList(1, 10, true);
                //In查询
                var userss = conn.QuerySet<users>().Where(x => x.id.In("1,2,3")).ToList();
                //var users = conn.QuerySet<users>().Where(x => x.id >= 2).ToList();
            }
            stopwatch.Stop(); //  停止监视
            TimeSpan timeSpan = stopwatch.Elapsed; //  获取总时间
            return View();
        }
    }
}

完整Demo可以去Github上下载：

https://github.com/a935368322/Kogel.Dapper.Test

如有问题也可以加QQ群讨论：

技术群 305678651


[LINQ2Dapper]最完整Dapper To Linq扩展

原文地址：https://www.cnblogs.com/kogel/p/10805696.html

时间： 2024-11-05 18:35:08

[LINQ2Dapper]最完整Dapper To Linq扩展的相关文章

[LINQ2Dapper]最完整Dapper To Linq框架(五)---查看Linq实际执行的SQL

此例子是使用LINQ2Dapper封装,效率优于EntityFramwork,并且支持.NetFramework和.NetCore框架,只依赖于Dapper支持.net framework4.6.1及以上 支持.net core2.0及以上 1.查看查询操作的SQL语句 首先需要保留QuerySet对象,因为根据Linq解析拼接SQL保存在Query对象的SqlProvider中  var query = Connection.QuerySet<T>(); 然后执行该对象,例如 query.L

使用Linq扩展方法时容易忽略的小问题

问题重现 下面直接给出用于说明文章主题的完整代码. //************************************************************ // // Linq扩展方法示例代码 // // Author:三五月儿 // // Date:2014/10/01 // // http://blog.csdn.net/yl2isoft // //************************************************************

ABP框架源码中的Linq扩展方法

文件目录:aspnetboilerplate-dev\aspnetboilerplate-dev\src\Abp\Collections\Extensions\EnumerableExtensions.cs using System; using System.Collections.Generic; using System.Linq; namespace Abp.Collections.Extensions { /// <summary> /// Extension methods for

Linq扩展最后遗留之SelectMany,Zip,SequenceEqual源码分析

Linq扩展最后遗留之SelectMany,Zip,SequenceEqual源码分析 一: AsParallel [并行化查询] 这个函数的功效就是将计算结果多线程化.[并行计算] =>[多核] 二:AsQueryable [将lambda表达式作为数据结构存储起来,Expresstion 表达式树] 三:Join 多表关联操作,我们可以用"查询关键字"解决. 为了更加的脱俗易懂,我们建议用人性化的"查询关键字"来解决这个复杂的Join,lambda. 四:

LinQ—扩展方法

概述 本节主要讲解扩展方法,涉及LinQ的具体知识不多. 扩展方法的描述 .net framework为编程人员提供了很多的类,很多的方法,但是,不论.net framework在类中为我们提供了多么多的方法,有时候仍然不能满足我们的需求,例如:你想让字符串对象具有ToPascal方法,含义就是将字符串转化为Pascal格式,并返回,我们知道,.net framework提供的String类中并没有为我们提供相应的方法,此时,我们应该怎么做才可以达到我们的目的呢?有人说可以继承String类,这

ToDictionary()LINQ扩展方法

ToList() 使用IEnumerable<T>并将其转换为 List<T>,那么 ToDictionary()也是类似的.大多数情况ToDictionary()是一个非常方便的方法,将查询的结果(或任何 IEnumerable<T>)转换成一个Dictionary<TKey,TValue>. 关键是您需要定义T如何分别转换TKey和TValue. 如果说我们有超级大的产品列表,希望把它放在一个Dictionary<int, product>,

【手记】走近科学之为什么JObject不能调用LINQ扩展方法

Json.NET的JObject明明实现了IEnumerable<T>,具体来说是IEnumerable<KeyValuePair<string, JToken>>,按说JObject类型的对象是可以直接调用Select.Where等linq扩展方法的,但偏偏就是不行,代码如下: using System.Linq; ... var jobj = new JObject(); var xxx = jobj.Select(x=>x); //报错:JObject未包含

Linq入门——什么是linq &amp; 扩展方法

一,什么是Linq linq(language integrated Query):语言集成查询: linq包含如下: 对对象的查询,对数据库的查询,对XML的查询. 那么,没有linq前我们是怎样查询的? 先看一个例子: 现在我们要查询大于50的数,: 在没有linq之前,我们的代码时这样的: 使用了linq查询: 首先,从直观上看,代码更加简洁,其次,对于查询部分,接近SQL语句,层次清晰,容易理解: 除了简单高效以为,LINQ的出现解决了很多问题: 1,面向对象与数据访问两个领域长期分裂,

Linq扩展方法获取单个元素

在使用Linq 提供的扩展方法时,First(OrDefault), Single(OrDefault), Last(OrDefault)都具有返回单个元素的功能.MSDN对这些方法的描述只有功能说明,没有关于内部的相关实现的描述说明. 首先我们来看下MSDN上关于这些扩展方法的官方描述: First: 返回序列中的第一个元素 . FirstOrDefault: 返回序列中的第一个元素:如果未找到元素,则返回默认值. Last:返回序列的最后一个元素. LastOrDefault: 返回序列中的