高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > C/C++/C#

EFCore扩展Select方法(自动映射自定义实体)

C/C++/C# 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

EFCore扩展Select方法(自动映射自定义实体)

EFCore扩展Select方法(自动映射自定义实体) 

通常用操作数据库的时候查询返回的字段是跟 我们的定义的实体是不一致的，所以往往针对UI或者接口层创建大量的Model, 而且需要手动对应字段，非常繁琐。 本文将通过表达式树解决这些重复的过程。 

 

先贴上实现代码

  Queryable 类中 的扩展方法  Select(this IQueryable source, expression> selector)  需要参数 expression> selector 只要构造相应的表达式树即可实现自定义映射

    using System.Collections;    using System.ComponentModel.DataAnnotations.Schema;    using System.Linq.expressions;    using System.Reflection;    using static System.Linq.expressions.expression;    public static class QueryableExtentions
    {        public static IQueryable Select(this IQueryable query)
        {            return Queryable.Select(query, GetLamda(query.GetType().GetGenericArguments()[0]));
        }        public static IQueryable Select(this IQueryable query)
        {            return Queryable.Select(query, GetLamda());
        }        public static expression> GetLamda(Type type = null)
        {            var sourceType = typeof(TSource);            var targetType = typeof(TTarget);            var parameter = Parameter(sourceType);
            expression propertyParameter;            if (type != null)
            {
                propertyParameter = Convert(parameter, type);
                sourceType = type;
            }            else
                propertyParameter = parameter;            return Lambda>(Getexpression(propertyParameter, sourceType, targetType), parameter);
        }        public static MemberInitexpression Getexpression(expression parameter, Type sourceType, Type targetType)
        {            var memberBindings = new List();            foreach (var targetItem in targetType.GetProperties().Where(x => x.CanWrite))
            {                var fromEntityAttr = targetItem.GetCustomAttribute();                if (fromEntityAttr != null)
                {                    var property = GetFromEntityexpression(parameter, sourceType, fromEntityAttr);                    if (property != null)
                        memberBindings.Add(Bind(targetItem, property));                    continue;
                }                var sourceItem = sourceType.GetProperty(targetItem.Name);                if (sourceItem == null)//当没有对应的属性时，查找 实体名+属性                {                    var complexSourceItemProperty = GetCombinationexpression(parameter, sourceType, targetItem);                    if (complexSourceItemProperty != null)
                        memberBindings.Add(Bind(targetItem, complexSourceItemProperty));                    continue;
                }                //判断实体的读写权限
                if (sourceItem == null || !sourceItem.CanRead)                    continue;                //标注NotMapped特性的属性忽略转换
                if (sourceItem.GetCustomAttribute() != null)                    continue;                var sourceProperty = Property(parameter, sourceItem);                //当非值类型且类型不相同时
                if (!sourceItem.PropertyType.IsValueType && sourceItem.PropertyType != targetItem.PropertyType && targetItem.PropertyType != targetType)
                {                    //判断都是(非泛型、非数组)class
                    if (sourceItem.PropertyType.IsClass && targetItem.PropertyType.IsClass                        && !sourceItem.PropertyType.IsArray && !targetItem.PropertyType.IsArray                        && !sourceItem.PropertyType.IsGenericType && !targetItem.PropertyType.IsGenericType)
                    {                        var expression = Getexpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
                        memberBindings.Add(Bind(targetItem, expression));
                    }                    continue;
                }                if (targetItem.PropertyType != sourceItem.PropertyType)                    continue;

                memberBindings.Add(Bind(targetItem, sourceProperty));
            }            return MemberInit(New(targetType), memberBindings);
        }        /// 
        /// 根据FromEntityAttribute 的值获取属性对应的路径        /// 
        /// 
        /// 
        /// 
        /// 
        private static expression GetFromEntityexpression(expression sourceProperty, Type sourceType, FromEntityAttribute fromEntityAttribute)
        {            var findType = sourceType;            var resultProperty = sourceProperty;            var tableNames = fromEntityAttribute.EntityNames;            if (tableNames == null)
            {                var columnProperty = findType.GetProperty(fromEntityAttribute.EntityColuum);                if (columnProperty == null)                    return null;                else
                    return Property(resultProperty, columnProperty);
            }            for (int i = tableNames.Length - 1; i >= 0; i--)
            {                var tableProperty = findType.GetProperty(tableNames[i]);                if (tableProperty == null)                    return null;

                findType = tableProperty.PropertyType;
                resultProperty = Property(resultProperty, tableProperty);
            }            var property = findType.GetProperty(fromEntityAttribute.EntityColuum);            if (property == null)                return null;            else
                return Property(resultProperty, property);
        }        /// 
        /// 根据组合字段获取其属性路径        /// 
        /// 
        /// 
        /// 
        /// 
        private static expression GetCombinationexpression(expression sourceProperty, Type sourceType, PropertyInfo targetItem)
        {            foreach (var item in sourceType.GetProperties().Where(x => x.CanRead))
            {                if (targetItem.Name.StartsWith(item.Name))
                {                    if (item != null && item.CanRead && item.PropertyType.IsClass && !item.PropertyType.IsGenericType)
                    {                        var rightName = targetItem.Name.Substring(item.Name.Length);                        var complexSourceItem = item.PropertyType.GetProperty(rightName);                        if (complexSourceItem != null && complexSourceItem.CanRead)                            return Property(Property(sourceProperty, item), complexSourceItem);
                    }
                }
            }            return null;
        }
    }    /// 
    /// 用于标注字段 来自哪个表的的哪一列(仅限于有关联的表中)    /// 
    public class FromEntityAttribute : Attribute
    {        /// 
        /// 类名(表名)        /// 
        public string[] EntityNames { get; }        /// 
        /// 字段(列名)        /// 
        public string EntityColuum { get; }        /// 
        /// 列名 + 该列的表名 + 该列的表的上一级表名        /// 
        /// 
        /// 
        public FromEntityAttribute(string entityColuum, params string[] entityNames)
        {
            EntityNames = entityNames;
            EntityColuum = entityColuum;
        }
    }
 
调用方法如下，先构造测试类
    public partial class User
    {        public int Id { get; set; }
        [Required]
        [StringLength(50)]        public string Name { get; set; }        public int RoleId { get; set; }

        [ForeignKey(nameof(RoleId))]        public virtual Role Role { get; set; }
    }    
    public partial class Role
    {        public int Id { get; set; }        public string Name { get; set; }        public int DepartmentId { get; set; }

        [ForeignKey(nameof(DepartmentId))]        public virtual Department Department  { get; set; } 
    }    public partial class Department
    {        public int Id { get; set; }
        [Required]
        [StringLength(50)]        public string Name { get; set; }
    }
如上所以构造了，用户表，角色表，和部门表。  查询某个用户 的角色名和部门名 则需要关联 角色表和部门表
    public partial class UserModel
    {        public string Name { get; set; }        public string RoleName { get; set; }        //[FromEntity("Name","Role")]        //public string RoleName1 { get; set; }
        [FromEntity("Name", "Department", "Role")]        public string DepartmentName { get; set; }        //public virtual RoleModel Role { get; set; }        //[FromEntity("Department", "Role")]        //public virtual Department Department { get; set; }
    }
查询代码如下
static void Main(string[] args)
        {            using (var context = new TestContext())
            {                var list = context.User.Select().ToList();
            }
            Console.WriteLine($"------------结束--------------------");
            Console.ReadLine();
        }
生成的sql语句 如下图
 
实体中的 DepartmentName 由于通过用户表关联角色表，再通过角色表关联 部门表得到故 需要通过特性标注
当然结果实体也可以多级关联
    public partial class UserModel
    {        public string Name { get; set; }        public string RoleName { get; set; }

        [FromEntity("Name","Role")]        public string RoleName1 { get; set; }

        [FromEntity("Name", "Department", "Role")]        public string DepartmentName { get; set; }        public virtual RoleModel Role { get; set; }

        [FromEntity("Department", "Role")]        public virtual Department Department { get; set; }
    }    public partial class RoleModel
    {        public string Name { get; set; }        public string DepartmentName { get; set; }        public virtual DepartmentModel Department  { get; set; } 
    }    public partial class DepartmentModel
    {        public string Name { get; set; }
    }
生成的查询语句如下图
 
总结 此方案用在接口，精确查询字段，需要强类型视图的地方相对比较方便
EFCore扩展Select方法(自动映射自定义实体) 
通常用操作数据库的时候查询返回的字段是跟 我们的定义的实体是不一致的，所以往往针对UI或者接口层创建大量的Model, 而且需要手动对应字段，非常繁琐。 本文将通过表达式树解决这些重复的过程。 
 
先贴上实现代码
  Queryable 类中 的扩展方法  Select(this IQueryable source, expression> selector)  需要参数 expression> selector 只要构造相应的表达式树即可实现自定义映射
    using System.Collections;    using System.ComponentModel.DataAnnotations.Schema;    using System.Linq.expressions;    using System.Reflection;    using static System.Linq.expressions.expression;    public static class QueryableExtentions
    {        public static IQueryable Select(this IQueryable query)
        {            return Queryable.Select(query, GetLamda(query.GetType().GetGenericArguments()[0]));
        }        public static IQueryable Select(this IQueryable query)
        {            return Queryable.Select(query, GetLamda());
        }        public static expression> GetLamda(Type type = null)
        {            var sourceType = typeof(TSource);            var targetType = typeof(TTarget);            var parameter = Parameter(sourceType);
            expression propertyParameter;            if (type != null)
            {
                propertyParameter = Convert(parameter, type);
                sourceType = type;
            }            else
                propertyParameter = parameter;            return Lambda>(Getexpression(propertyParameter, sourceType, targetType), parameter);
        }        public static MemberInitexpression Getexpression(expression parameter, Type sourceType, Type targetType)
        {            var memberBindings = new List();            foreach (var targetItem in targetType.GetProperties().Where(x => x.CanWrite))
            {                var fromEntityAttr = targetItem.GetCustomAttribute();                if (fromEntityAttr != null)
                {                    var property = GetFromEntityexpression(parameter, sourceType, fromEntityAttr);                    if (property != null)
                        memberBindings.Add(Bind(targetItem, property));                    continue;
                }                var sourceItem = sourceType.GetProperty(targetItem.Name);                if (sourceItem == null)//当没有对应的属性时，查找 实体名+属性                {                    var complexSourceItemProperty = GetCombinationexpression(parameter, sourceType, targetItem);                    if (complexSourceItemProperty != null)
                        memberBindings.Add(Bind(targetItem, complexSourceItemProperty));                    continue;
                }                //判断实体的读写权限
                if (sourceItem == null || !sourceItem.CanRead)                    continue;                //标注NotMapped特性的属性忽略转换
                if (sourceItem.GetCustomAttribute() != null)                    continue;                var sourceProperty = Property(parameter, sourceItem);                //当非值类型且类型不相同时
                if (!sourceItem.PropertyType.IsValueType && sourceItem.PropertyType != targetItem.PropertyType && targetItem.PropertyType != targetType)
                {                    //判断都是(非泛型、非数组)class
                    if (sourceItem.PropertyType.IsClass && targetItem.PropertyType.IsClass                        && !sourceItem.PropertyType.IsArray && !targetItem.PropertyType.IsArray                        && !sourceItem.PropertyType.IsGenericType && !targetItem.PropertyType.IsGenericType)
                    {                        var expression = Getexpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
                        memberBindings.Add(Bind(targetItem, expression));
                    }                    continue;
                }                if (targetItem.PropertyType != sourceItem.PropertyType)                    continue;

                memberBindings.Add(Bind(targetItem, sourceProperty));
            }            return MemberInit(New(targetType), memberBindings);
        }        /// 
        /// 根据FromEntityAttribute 的值获取属性对应的路径        /// 
        /// 
        /// 
        /// 
        /// 
        private static expression GetFromEntityexpression(expression sourceProperty, Type sourceType, FromEntityAttribute fromEntityAttribute)
        {            var findType = sourceType;            var resultProperty = sourceProperty;            var tableNames = fromEntityAttribute.EntityNames;            if (tableNames == null)
            {                var columnProperty = findType.GetProperty(fromEntityAttribute.EntityColuum);                if (columnProperty == null)                    return null;                else
                    return Property(resultProperty, columnProperty);
            }            for (int i = tableNames.Length - 1; i >= 0; i--)
            {                var tableProperty = findType.GetProperty(tableNames[i]);                if (tableProperty == null)                    return null;

                findType = tableProperty.PropertyType;
                resultProperty = Property(resultProperty, tableProperty);
            }            var property = findType.GetProperty(fromEntityAttribute.EntityColuum);            if (property == null)                return null;            else
                return Property(resultProperty, property);
        }        /// 
        /// 根据组合字段获取其属性路径        /// 
        /// 
        /// 
        /// 
        /// 
        private static expression GetCombinationexpression(expression sourceProperty, Type sourceType, PropertyInfo targetItem)
        {            foreach (var item in sourceType.GetProperties().Where(x => x.CanRead))
            {                if (targetItem.Name.StartsWith(item.Name))
                {                    if (item != null && item.CanRead && item.PropertyType.IsClass && !item.PropertyType.IsGenericType)
                    {                        var rightName = targetItem.Name.Substring(item.Name.Length);                        var complexSourceItem = item.PropertyType.GetProperty(rightName);                        if (complexSourceItem != null && complexSourceItem.CanRead)                            return Property(Property(sourceProperty, item), complexSourceItem);
                    }
                }
            }            return null;
        }
    }    /// 
    /// 用于标注字段 来自哪个表的的哪一列(仅限于有关联的表中)    /// 
    public class FromEntityAttribute : Attribute
    {        /// 
        /// 类名(表名)        /// 
        public string[] EntityNames { get; }        /// 
        /// 字段(列名)        /// 
        public string EntityColuum { get; }        /// 
        /// 列名 + 该列的表名 + 该列的表的上一级表名        /// 
        /// 
        /// 
        public FromEntityAttribute(string entityColuum, params string[] entityNames)
        {
            EntityNames = entityNames;
            EntityColuum = entityColuum;
        }
    }
 
调用方法如下，先构造测试类
    public partial class User
    {        public int Id { get; set; }
        [Required]
        [StringLength(50)]        public string Name { get; set; }        public int RoleId { get; set; }

        [ForeignKey(nameof(RoleId))]        public virtual Role Role { get; set; }
    }    
    public partial class Role
    {        public int Id { get; set; }        public string Name { get; set; }        public int DepartmentId { get; set; }

        [ForeignKey(nameof(DepartmentId))]        public virtual Department Department  { get; set; } 
    }    public partial class Department
    {        public int Id { get; set; }
        [Required]
        [StringLength(50)]        public string Name { get; set; }
    }
如上所以构造了，用户表，角色表，和部门表。  查询某个用户 的角色名和部门名 则需要关联 角色表和部门表
    public partial class UserModel
    {        public string Name { get; set; }        public string RoleName { get; set; }        //[FromEntity("Name","Role")]        //public string RoleName1 { get; set; }
        [FromEntity("Name", "Department", "Role")]        public string DepartmentName { get; set; }        //public virtual RoleModel Role { get; set; }        //[FromEntity("Department", "Role")]        //public virtual Department Department { get; set; }
    }
查询代码如下
static void Main(string[] args)
        {            using (var context = new TestContext())
            {                var list = context.User.Select().ToList();
            }
            Console.WriteLine($"------------结束--------------------");
            Console.ReadLine();
        }
生成的sql语句 如下图
 
实体中的 DepartmentName 由于通过用户表关联角色表，再通过角色表关联 部门表得到故 需要通过特性标注
当然结果实体也可以多级关联
    public partial class UserModel
    {        public string Name { get; set; }        public string RoleName { get; set; }

        [FromEntity("Name","Role")]        public string RoleName1 { get; set; }

        [FromEntity("Name", "Department", "Role")]        public string DepartmentName { get; set; }        public virtual RoleModel Role { get; set; }

        [FromEntity("Department", "Role")]        public virtual Department Department { get; set; }
    }    public partial class RoleModel
    {        public string Name { get; set; }        public string DepartmentName { get; set; }        public virtual DepartmentModel Department  { get; set; } 
    }    public partial class DepartmentModel
    {        public string Name { get; set; }
    }
生成的查询语句如下图
 
总结 此方案用在接口，精确查询字段，需要强类型视图的地方相对比较方便
原文出处：https://www.cnblogs.com/castyuan/p/10186619.html  







转载请注明：文章转载自 www.mshxw.com















C/C++/C#相关栏目本月热门文章












热门相关搜索






路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名















学习工具


代数计算器


三角函数


解析几何


立体几何






知识解答


教育知识


百科知识


生活知识


常识知识






写作必备


作文大全


作文素材


句子大全



实用范文






关于我们


关于我们


联系我们


网站地图






 交流群

名师互学网交流群




名师互学网客服

名师互学网客服












名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 








我们一直用心在做

关于我们
文章归档
网站地图
联系我们

版权所有 (c)2021-2022 MSHXW.COM


ICP备案号：晋ICP备2021003244-6号