c# – EntityFramework：急切加载而不是包含？

编辑

事实证明,虽然排除可能在开发应用程序时有意义……对域模型进行了许多更改…,排除并不比我刚才考虑的“真实世界示例”包含更优雅.

a)我浏览了我的实体并计算了包含和排除的导航属性的数量.排除的属性的平均数量并不比包含的属性数量小得多.

b)如果我确实考虑了排除的不同导航属性“foos”,我将被迫考虑Foo类型的子实体的排除…如果我根本不想使用它的属性.

另一方面,使用包含,我只需要指定导航属性“foos”,而不需要为子实体指定任何其他内容.

因此,虽然排除可能会保留一个级别的某些规格,但它们需要更多规格才能进入下一级…(当排除某些中间实体而不仅仅是位于加载的对象树的叶子上的实体时).

c)此外,包含/排除可能不仅取决于实体的类型,还取决于用于访问实体的路径.然后需要指定一个排除,例如“在为一个目的加载实体时排除属性xy,并在为另一个目的加载实体时排除属性z”.

=>由于这些考虑,我将继续使用包含.

我实现了基于包含字典而不是字符串的类型保存包含：

private static readonly Inclusions<Person> _personInclusionsWithCompanyParent = new Inclusions<Person>(typeof(Company))
      {
        {e => e.Company,false},{e => e.Roles,true}        
      };

我有一个方法,从包含列表创建查询.该方法还检查字典中是否考虑了所有现有导航属性.如果我添加一个新实体并忘记指定相应的包含,则会抛出异常.

不过,这里有一个使用排除的实验解决方案而不是包括：

private const int MAX_EXPANSION_DEPTH = 10;

private DbContext Context { get; set; } //set during construction of my repository


 public virtual IQueryable<TEntity> AllExcluding(string excludeProperties = "")
    {
      var propertiesToExclude = excludeProperties.Split(new[]
                                                        {
                                                          ','
                                                        },StringSplitOptions.RemoveEmptyEntries);


      IQueryable<TEntity> initialQuery = Context.Set<TEntity>();
      var elementType = initialQuery.ElementType;

      var navigationPropertyPaths = new HashSet<string>();
      var navigationPropertyNames = GetNavigationPropertyNames(elementType);
      foreach (var propertyName in navigationPropertyNames)
      {
        if (!propertiesToExclude.Contains(propertyName))
        {
          ExtendNavigationPropertyPaths(navigationPropertyPaths,elementType,propertyName,propertiesToExclude,0);
        }
      }

      return navigationPropertyPaths.Aggregate(initialQuery,(current,includeProperty) => current.Include(includeProperty));
    }

    private void ExtendNavigationPropertyPaths(ISet<string> navigationPropertyPaths,Type parentType,string propertyName,string propertyPath,ICollection<string> propertiesToExclude,int expansionDepth)
    {
      if (expansionDepth > MAX_EXPANSION_DEPTH)
      {
        return;
      }

      var propertyInfo = parentType.GetProperty(propertyName);

      var propertyType = propertyInfo.PropertyType;

      var isEnumerable = typeof(IEnumerable).IsAssignableFrom(propertyType);
      if (isEnumerable)
      {
        propertyType = propertyType.GenericTypeArguments[0];
      }

      var subNavigationPropertyNames = GetNavigationPropertyNames(propertyType);
      var noSubNavigationPropertiesExist = !subNavigationPropertyNames.Any();
      if (noSubNavigationPropertiesExist)
      {
        navigationPropertyPaths.Add(propertyPath);
        return;
      }

      foreach (var subPropertyName in subNavigationPropertyNames)
      {
        if (propertiesToExclude.Contains(subPropertyName))
        {
          navigationPropertyPaths.Add(propertyPath);
          continue;
        }

        var subPropertyPath = propertyPath + '.' + subPropertyName;
        ExtendNavigationPropertyPaths(navigationPropertyPaths,propertyType,subPropertyName,subPropertyPath,expansionDepth + 1);
      }
    }

    private ICollection<string> GetNavigationPropertyNames(Type elementType)
    {
      var objectContext = ((IObjectContextAdapter)Context).ObjectContext;
      var entityContainer = objectContext.MetadataWorkspace.GetEntityContainer(objectContext.DefaultContainerName,DataSpace.CSpace);
      var entitySet = entityContainer.EntitySets.FirstOrDefault(item => item.ElementType.Name.Equals(elementType.Name));
      if (entitySet == null)
      {
        return new List<string>();
      }
      var entityType = entitySet.ElementType;
      return entityType.NavigationProperties.Select(np => np.Name)
                       .ToList();
    }