EFCore中的导航属性是什么-创新互联

本篇文章给大家分享的是有关EFCore中的导航属性是什么，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。

在什邡等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供做网站、成都网站建设 网站设计制作按需设计网站,公司网站建设,企业网站建设,成都品牌网站建设,营销型网站建设,外贸网站建设,什邡网站建设费用合理。

   1 单独使用Include

在介绍这个方法之前，我来先贴出实体之间的关联关系，假设这里有三个相互关联的实体VehicleWarranty、WarrantyWarningLevel、VehicleWarrantyRepairHistory这三个实体后面两个都是第一个的子级并且并且VehicleWarranty、WarrantyWarningLevel之间的关系是1对1的关系，VehicleWarranty和VehicleWarrantyRepairHistory之间是1：N的关系，即1对多的关系，我们这里贴出具体的Model，从而方便后面分析具体的代码。

    /// 

    /// 车辆三包信息（DCSService）
    /// 
    public class VehicleWarranty : Entity {
        public VehicleWarranty() {
            Details = new List();
        }
 
        //车辆售后档案
        public Guid VehicleSoldId { get; set; }
 
        //VIN
        [Required]
        [MaxLength(EntityDefault.FieldLength_50)]
        public string Vin { get; set; }
 
        //产品分类
        public Guid? ProductCategoryId { get; set; }
 
        //产品分类编号
        [MaxLength(EntityDefault.FieldLength_50)]
        public string ProductCategoryCode { get; set; }
 
        //产品分类名称
        [MaxLength(EntityDefault.FieldLength_100)]
        public string ProductCategoryName { get; set; }
 
        //车牌号
        [MaxLength(EntityDefault.FieldLength_50)]
        public string LicensePlate { get; set; }
 
        //发动机号
        [MaxLength(EntityDefault.FieldLength_50)]
        public string EngineCode { get; set; }
 
        //变速箱号
        [MaxLength(EntityDefault.FieldLength_50)]
        public string TransmissionSn { get; set; }
 
        //开发票日期
        public DateTime InvoiceDate { get; set; }
 
        //行驶里程
        public int Mileage { get; set; }
 
        //是否三包期内
        public bool? IsInWarranty { get; set; }
 
        //预警等级
        public Guid? WarningLevelId { get; set; }
 
        public WarrantyWarningLevel WarningLevel { get; set; }
 
        //等级编号
        [MaxLength(EntityDefault.FieldLength_50)]
        public string LevelCode { get; set; }
 
        //等级名称
        [MaxLength(EntityDefault.FieldLength_100)]
        public string LevelName { get; set; }
 
        //预警内容
        [MaxLength(EntityDefault.FieldLength_800)]
        public string WarningComment { get; set; }
 
        //累计维修天数
        public int TotoalRepairDays { get; set; }
 
        //售出后60天/3000KM内严重故障次数
        public int? FNum { get; set; }
 
        //严重安全性能故障累计次数
        public int? GNum { get; set; }
 
        //发动机总成累计更换次数
        public int? HNum { get; set; }
 
        //变速箱总成累计更换次数
        public int? INum { get; set; }
 
        //发动机主要零件较大更换次数
        public int? JNum { get; set; }
 
        //变速箱主要零件较大更换次数
        public int? KNum { get; set; }
 
        //同一主要零件较大更换次数
        public int? LNum { get; set; }
 
        //同一产品质量问题较大累计次数（部件+故障+方位）
        public int? MNum { get; set; }
 
        //同一产品质量问题较大累计次数
        public int? NNum { get; set; }
 
        public List Details { get; set; }
    }
 
/// 

    /// 三包预警等级（DCS）
    /// 
    public class WarrantyWarningLevel : Entity {
        //等级编号
        [Required]
        [MaxLength(EntityDefault.FieldLength_50)]
        public string Code { get; set; }
 
        //等级名称
        [Required]
        [MaxLength(EntityDefault.FieldLength_100)]
        public string Name { get; set; }
 
        //颜色
        [Required]
        [MaxLength(EntityDefault.FieldLength_50)]
        public string Color { get; set; }
 
        //备注
        [MaxLength(EntityDefault.FieldLength_200)]
        public string Remark { get; set; }
    }
 
 
    /// 

    /// 车辆三包信息维修履历（DCSService）
    /// 
    public class VehicleWarrantyRepairHistory : Entity {
        //车辆三包信息
        [Required]
        public Guid VehicleWarrantyId { get; set; }
 
        public VehicleWarranty VehicleWarranty { get; set; }
 
        //VIN
        [Required]
        [MaxLength(EntityDefault.FieldLength_50)]
        public string Vin { get; set; }
 
        //维修合同
        public Guid RepairContractId { get; set; }
 
        //维修合同编号
        [Required]
        [MaxLength(EntityDefault.FieldLength_50)]
        public string RepairContractCode { get; set; }
 
        //处理时间
        public DateTime? DealTime { get; set; }
 
        //经销商
        public Guid DealerId { get; set; }
 
        //经销商编号
        [Required]
        [MaxLength(EntityDefault.FieldLength_50)]
        public string DealerCode { get; set; }
 
        //经销商名称
        [Required]
        [MaxLength(EntityDefault.FieldLength_100)]
        public string DealerName { get; set; }
 
        //履历来源
        public VehicleWarrantyRepairHistorySource Source { get; set; }
 
        //累计维修天数
        public int? TotoalRepairDays { get; set; }
 
        //售出后60天/3000KM内严重故障次数
        public int? FNum { get; set; }
 
        //严重安全性能故障累计次数
        public int? GNum { get; set; }
 
        //发动机总成累计更换次数
        public int? HNum { get; set; }
 
        //变速箱总成累计更换次数
        public int? INum { get; set; }
 
        //发动机主要零件较大更换次数
        public int? JNum { get; set; }
 
        //变速箱主要零件较大更换次数
        public int? KNum { get; set; }
 
        //同一主要零件较大更换次数
        public int? LNum { get; set; }
 
        //同一产品质量问题较大累计次数（部件+故障+方位）
        public int? MNum { get; set; }
 
        //同一产品质量问题较大累计次数
        public int? NNum { get; set; }
    }

这里我们贴出第一个简单的查询示例，通过Include方法来一下子查询出关联的三包预警等级这个实体，在我们的例子中我们返回的结果是带分页的，而且会根据前端传递的Dto来进行过滤，这里我们来看这段代码怎么实体。

/// 

        /// 查询车辆三包信息
        /// 
        /// 查询输入
        /// 分页请求
        /// 带分页的三包预警车辆信息
        public async Task> GetVehicleWarrantiesAsync(GetVehicleWarrantiesInput input, PageRequest pageRequest) {           
            var queryResults = _vehicleWarrantyRepository.GetAll()
                .Include(v => v.WarningLevel)
                .Where(v => _vehicleSoldRepository.GetAll().Any(vs => vs.Status == VehicleStatus.实销完成 && v.Vin == vs.Vin));
            var totalCount = await queryResults.CountAsync();
            var pagedResults = await queryResults.ProjectTo(_autoMapper.ConfigurationProvider).PageAndOrderBy(pageRequest).ToListAsync();
            return new Page(pageRequest, totalCount, pagedResults);
        }

在这里我们看到了通过一个Include就能够查询出关联的实体，为什么能够实现，那是因为在VehicleWarranty实体中存在WarrantyWarningLevel实体的外键，并且这里还增加了外键关联的实体，这样才能够正确使用InClude方法，并且这个InClude方法只能够以实体作为参数，不能以外键作为参数，到了这里我想提出一个问题，这里最终生成的SQL（SqlServer数据库）是left join 还是inner join呢？在看完后面的分析之前需要思考一下。

select top (20)
  [v].[EngineCode],
  [v].[GNum],
  [v].[Id],
  [v.WarningLevel].[Color] as [LevelColor],
  [v].[LevelName],
  [v].[LicensePlate],
  [v].[ProductCategoryName],
  [v].[TotoalRepairDays],
  [v].[Vin]
from [VehicleWarranty] as [v]
  left join [WarrantyWarningLevel] as [v.WarningLevel] on [v].[WarningLevelId] = [v.WarningLevel].[Id]
where EXISTS(
    select 1
    from [VehicleSold] as [vs]
    where ([vs].[Status] = 7) and ([v].[Vin] = [vs].[Vin]))
order by [v].[Vin]

这里我们看到生成的SQL语句是left join ,那么这里为什么不是inner join呢？这里先给你看具体的答案吧？这里你看懂了吗？问题就处在我这里建立的外键是可为空的 public Guid? WarningLevelId { get; set; }、如果是不可为空的外键那么生成的SQL就是inner join这个你可以亲自尝试。另外有一个需要提醒的就是，如果你像上面的实体中建立了VehicleWarranty、WarrantyWarningLeve之间的关系的话，迁移到数据库会默认生成外键约束，这个在使用的时候需要特别注意，但是如果你只是添加了外键而没有添加对应的外键同名的实体是不会生成外键约束关系的，这个暂时不理解里面的实现机制。

2 主清单使用Include

刚才介绍的是1对1的关联关系，那么像VehicleWarranty、VehicleWarrantyRepairHistory之间有明显的主清单关系，即一个VehicleWarranty对应多个VehicleWarrantyRepairHistory的时候使用InClude方法会生成什么样的SQL语句呢？这里我也贴出代码，然后再来分析生成的SQL语句。

/// 

        /// 查询特定的三包预警车辆信息
        /// 
        /// 特定Id
        /// 特定的三包预警车辆信息
        public async Task GetVehicleWarrantyWithDetailsAsync(Guid id) {
            var query = await _vehicleWarrantyRepository.GetAll()
                .Include(v => v.WarningLevel)
                .Include(v => v.Details)
                .SingleOrDefaultAsync(v => v.Id == id);
            if (null == query) {
                throw new ValidationException("找不到当前特定的三包预警车辆信息");
            }
 
            var retResult = ObjectMapper.Map(query);
            return retResult;
        }

这里使用了两个InClude方法，那么EFCore会怎么生成这个SQL呢？通过查询最终的SQL我们发现EFCore在处理这类问题的时候是分开进行查询，然后再合并到查询的实体中去的，所以在这个查询的过程中生成的SQL如下：

select top (2)
  [v].[Id],
  [v].[EngineCode],
  [v].[FNum],
  [v].[GNum],
  [v].[HNum],
  [v].[INum],
  [v].[InvoiceDate],
  [v].[IsInWarranty],
  [v].[JNum],
  [v].[KNum],
  [v].[LNum],
  [v].[LevelCode],
  [v].[LevelName],
  [v].[LicensePlate],
  [v].[MNum],
  [v].[Mileage],
  [v].[NNum],
  [v].[ProductCategoryCode],
  [v].[ProductCategoryId],
  [v].[ProductCategoryName],
  [v].[TotoalRepairDays],
  [v].[TransmissionSn],
  [v].[VehicleSoldId],
  [v].[Vin],
  [v].[WarningComment],
  [v].[WarningLevelId],
  [v.WarningLevel].[Id],
  [v.WarningLevel].[Code],
  [v.WarningLevel].[Color],
  [v.WarningLevel].[Name],
  [v.WarningLevel].[Remark]
from [VehicleWarranty] as [v]
  left join [WarrantyWarningLevel] as [v.WarningLevel] on [v].[WarningLevelId] = [v.WarningLevel].[Id]
where [v].[Id] = @__id_0
order by [v].[Id]
 
select
  [v.Details].[Id],
  [v.Details].[DealTime],
  [v.Details].[DealerCode],
  [v.Details].[DealerId],
  [v.Details].[DealerName],
  [v.Details].[FNum],
  [v.Details].[GNum],
  [v.Details].[HNum],
  [v.Details].[INum],
  [v.Details].[JNum],
  [v.Details].[KNum],
  [v.Details].[LNum],
  [v.Details].[MNum],
  [v.Details].[NNum],
  [v.Details].[RepairContractCode],
  [v.Details].[RepairContractId],
  [v.Details].[Source],
  [v.Details].[TotoalRepairDays],
  [v.Details].[VehicleWarrantyId],
  [v.Details].[Vin]
from [VehicleWarrantyRepairHistory] as [v.Details]
  inner join (
               select distinct [t].*
               from (
                      select top (1) [v0].[Id]
                      from [VehicleWarranty] as [v0]
                        left join [WarrantyWarningLevel] as [v.WarningLevel0]
                          on [v0].[WarningLevelId] = [v.WarningLevel0].[Id]
                      where [v0].[Id] = @__id_0
                      order by [v0].[Id]
                    ) as [t]
             ) as [t0] on [v.Details].[VehicleWarrantyId] = [t0].[Id]
order by [t0].[Id]

这个在查询的过程中会分作几个SQL查询并且会将前面查询的结果作为后面查询的部分条件来进行了，待整个查询完毕后再在内存中将这些结果组合到一个query对象中。

3 ThenInclude用法

上面的介绍完了之后，你应该能够明白这个Include的具体含义和用法了，接着上面的例子，如果WarrantyWarningLevel里面还有通过外键Id去关联别的实体，这个时候ThenInclude就派上了用场了，理论上只要彼此之间建立了这种外键关系就可以一直ThenInClude下去，但是一般情况下不会用到这么复杂的情况，当然这里面每一个Include也都是作为一个单独的查询来进行的，这个也可以找具体的例子进行试验，这里也贴出一个具体的例子吧。

public async Task GetById(Guid id) {
            var repairContract = await _repairContractRepository.GetAll()
                .Include(d => d.RepairContractWorkItems)
                    .ThenInclude(w => w.Materials)
                .FirstOrDefaultAsync(r => r.Id == id);
 
            if (repairContract == null)
                throw new ValidationException(_localizer["当前维修合同不存在"]);
            var vehicleSold = _vehicleSoldRepository.Get(repairContract.VehicleId);
            var isTrafficSubsidy = _repairContractManager.IsTrafficSubsidy(repairContract.Id);
            var (nextMaintenanceMileage, nextMaintenanceTime) = _repairContractManager.GetNextMaintainInfo(repairContract, vehicleSold);
            var result = new GetRepairContractDetailForSettlementOutput() {
                Id = repairContract.Id,
                Code = repairContract.Code,
                CustomerName = repairContract.CustomerName,
                CellPhoneNumber = repairContract.CellPhoneNumber,
                Vin = repairContract.Vin,
                LicensePlate = repairContract.LicensePlate,
                NextMaintenanceTime = nextMaintenanceTime,
                NextMaintenanceMileage = nextMaintenanceMileage,
                LaborFee = repairContract.LaborFee,
                LaborFeeAfter = repairContract.LaborFeeAfter,
                MaterialFee = repairContract.MaterialFee,
                MaterialFeeAfter = repairContract.MaterialFeeAfter,
                OutFee = repairContract.OutFee,
                OtherFee = repairContract.OtherFee,
                TotalFeeAfter = repairContract.TotalFeeAfter,
                ShowIsTrafficSubsidy = isTrafficSubsidy,
                LastMaintenanceTime = vehicleSold.LastMaintenanceTime,
                LastMaintenanceMileage = vehicleSold.LastMaintenanceMileage,
                WorkItems = _mapper.Map>(repairContract.RepairContractWorkItems)
            };
            return result;
        }

最后还要介绍一种极特殊的情况，由于ThenInclude方法只能一层层向下进行，如果我想对同一个实体里面的两个关联实体做ThenInclude操作这个怎么处理，这里就直接给出代码吧。

/// 

        ///维修合同完成的事件
        /// 
        /// 
        public void Finished(Guid repairContractId) {
            var repairContract = _repairContractRepository.GetAll()
                .Include(c => c.RepairContractWorkItems).ThenInclude(wi => wi.Materials)
                .Include(c => c.RepairContractWorkItems).ThenInclude(wi => wi.Fault)
                .SingleOrDefault(c => c.Id == repairContractId);
            var repairContractAdjusts = _repairContractAdjustRepository.GetAll()
                .Include(a => a.WorkItems).ThenInclude(w => w.Materials)
                .Where(a => a.RepairContractId == repairContractId).ToList();
 
            var @event = new AddRepairContractEvent {
                Key = repairContract?.Code,
                RepairContract = repairContract,
                RepairContractAdjusts = repairContractAdjusts
            };
            _producer.Produce(@event);
        }

这里需要Include同一个实体两次，然后分别调用ThenInclude方法，这个属于比较特殊的情况，在使用的时候需要注意。

温馨提示：

这里读者在看代码的时候可能不太理解类似这种 _repairContractRepository的具体由来，这里贴出一份完整的代码。

internal class AddRepairContractEventManager : DomainService, IAddRepairContractEventManager {
        private readonly KafkaProducer _producer;
        private readonly IRepository _repairContractRepository;
        private readonly IRepository _repairContractAdjustRepository;
 
        public AddRepairContractEventManager(KafkaProducer producer,
                                          IRepository repairContractRepository,
                                          IRepository repairContractAdjustRepository) {
            _producer = producer;
            _repairContractRepository = repairContractRepository;
            _repairContractAdjustRepository = repairContractAdjustRepository;
        }
 
        /// 

        ///维修合同完成的事件
        /// 
        /// 
        public void Finished(Guid repairContractId) {
            var repairContract = _repairContractRepository.GetAll()
                .Include(c => c.RepairContractWorkItems).ThenInclude(wi => wi.Materials)
                .Include(c => c.RepairContractWorkItems).ThenInclude(wi => wi.Fault)
                .SingleOrDefault(c => c.Id == repairContractId);
            var repairContractAdjusts = _repairContractAdjustRepository.GetAll()
                .Include(a => a.WorkItems).ThenInclude(w => w.Materials)
                .Where(a => a.RepairContractId == repairContractId).ToList();
 
            var @event = new AddRepairContractEvent {
                Key = repairContract?.Code,
                RepairContract = repairContract,
                RepairContractAdjusts = repairContractAdjusts
            };
            _producer.Produce(@event);
        }
    }

4 IncludeFilter用法

在有些场景中我们可能需要带出清单的时候并且过滤清单，这个功能算是对Include方法的一个提升，可以将两个操作合并到一起来进行，这个在使用的时候需要注意 这个并不是Asp.Net Core自带的功能，这个需要通过引入包 Z.EntityFramework.Plus.EFCore.dll的包来实现的，如果你们的系统中使用的是ABP作为项目主框架，那么你只需要引用 Abp.EntityFrameworkCore.EFPlus这个包就可以了，因为这个包中就包含和Z.EntityFramework相关的子包，这个在使用的时候需要注意。

 　　下面我们来看一看我们的代码中是怎么使用的。

private (Company company, IEnumerable partSaleOrderTypes) GetCompanyDetailForFactory(Guid id) {
            var currentPartSaleOrderTypes = GetCurrentPartSaleOrderTypes();
            var currentPartSaleOrderTypeIds = currentPartSaleOrderTypes.Select(t => t.Id);
            var company = _companyRepository.GetAll()
                .IncludeFilter(c => c.CustomerPartInformations.Where(i => i.BranchId == SdtSession.TenantId.GetValueOrDefault()))
                .IncludeFilter(c => c.CustomerOrderWarehouses.Where(w => currentPartSaleOrderTypeIds.Contains(w.PartSaleOrderTypeId)))
                .IncludeFilter(c => c.CustomerMarkupRates.Where(w => currentPartSaleOrderTypeIds.Contains(w.PartSaleOrderTypeId)))
                .IncludeFilter(c => c.OrderShippingSequences.Where(w => currentPartSaleOrderTypeIds.Contains(w.PartSaleOrderTypeId)))
                .IncludeFilter(c => c.OrderingCalendars.Where(w => currentPartSaleOrderTypeIds.Contains(w.PartSaleOrderTypeId)))
                .FirstOrDefault(d => d.Id == id && d.Status == BaseDataStatus.生效);
            if (company == null) {
                throw new EntityNotFoundException(SharedLocalizer["未能找到对应的企业"]);
            }
            return (company, currentPartSaleOrderTypes);
        }

这个提供了一种新的清单过滤方式，不仅提高了效率而且使代码更加优化简练。

5 特殊情况

这里还介绍一种不通过Include方法来获取清单中的方式，就像下面这种写法，Company对象和OrderingCalendars之间建立了一对多的导航属性，我们在使用 company.OrderingCalendars之前先将内部的清查查询出来（不需要定义变量接收，使用_即可），这样也是能通过导航属性自动映射到company的OrderingCalendars中去的，这个在使用的时候需要特别注意，查询的时候要提前ToList，将数据查询到内存里面

_ = _orderingCalendarRepository.GetAll().Where(t => t.OrderingCompanyId == company.Id).ToList();           
           var tempCalendars = company.OrderingCalendars.OrderBy(d => d.PartSaleOrderType.Level).Select(d => new {
               d.PartSaleOrderType.BrandId,
               d.PartSaleOrderType.BrandCode,
               d.PartSaleOrderType.BrandName,
               d.PartSaleOrderTypeId,
               d.PartSaleOrderTypeCode,
               d.PartSaleOrderTypeName,
               d.Year,
               d.Month,
               d.Day
           });

以上就是EFCore中的导航属性是什么，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注创新互联行业资讯频道。

新闻标题：EFCore中的导航属性是什么-创新互联
转载来于：http://mswzjz.cn/article/joepc.html