在 API 上我需要动态包含，但 EF Core 不支持基于字符串的包含。

因此，我创建了一个映射器，它将字符串映射到添加到列表中的 lambda 表达式，如下所示:

List<List<Expression>> expressions = new List<List<Expression>>();

考虑以下特定类型:

public class EFContext 
{
    public DbSet<P1> P1s { get; set; }
    public DbSet<P1> P2s { get; set; }
    public DbSet<P1> P3s { get; set; }
}

public class P1 
{
    public P2 P2 { get; set; }
    public P3 P3 { get; set; }
}

public class P2 
{
    public P3 P3 { get; set; }
}

public class P3 { }

Include 和 ThenInclude 通常使用如下:

EFContext efcontext = new EFContext();
IQueryable<P1> result = efcontext.P1s
        .Include(p1 => p1.P2)
        .ThenInclude(p2 => p2.P3)
        .Include(p1 => p1.P3);

它们也可以通过以下方式使用:

Expression<Func<P1, P2>> p1p2 = p1 => p1.P2;
Expression<Func<P1, P3>> p1p3 = p1 => p1.P3;
Expression<Func<P2, P3>> p2p3 = p2 => p2.P3;

List<List<Expression>> expressions = new List<List<Expression>> 
    {
        new List<Expression> { p1p2, p1p3 },
        new List<Expression> { p2p3 }
    };

EFContext efcontext = new EFContext();

IIncludableQueryable<P1, P2> q1 = EntityFrameworkQueryableExtensions
            .Include(efcontext.P1s, p1p2);
    
IIncludableQueryable<P1, P3> q2 = EntityFrameworkQueryableExtensions
            .ThenInclude(q1, p2p3);

IIncludableQueryable<P1, P3> q3 = EntityFrameworkQueryableExtensions
            .Include(q2, p1p3);

result = q3.AsQueryable();

问题是我的方法接收到一个表达式列表，而我在 T 中只有基本类型:

public static class IncludeExtensions<T> 
{
    public static IQueryable<T> IncludeAll(this IQueryable<T> collection, List<List<Expression>> expressions) 
    {
        MethodInfo include = typeof(EntityFrameworkQueryableExtensions)
            .GetTypeInfo()
            .GetDeclaredMethods(nameof(EntityFrameworkQueryableExtensions.Include))
            .Single(mi => mi.GetParameters()
                .Any(pi => pi.Name == "navigationPropertyPath"));

        MethodInfo includeAfterCollection = typeof(EntityFrameworkQueryableExtensions)
            .GetTypeInfo()
            .GetDeclaredMethods(nameof(EntityFrameworkQueryableExtensions.ThenInclude))
            .Single(mi => 
                !mi.GetParameters()[0].ParameterType.GenericTypeArguments[1].IsGenericParameter);

        MethodInfo includeAfterReference = typeof(EntityFrameworkQueryableExtensions)
            .GetTypeInfo()
            .GetDeclaredMethods(nameof(EntityFrameworkQueryableExtensions.ThenInclude))
            .Single(mi => mi.GetParameters()[0].ParameterType.GenericTypeArguments[1].IsGenericParameter);

        foreach (List<Expression> path in expressions) 
        {
            bool start = true;

            foreach (Expression expression in path) 
            {
                if (start) 
                {
                    MethodInfo method = include.MakeGenericMethod(typeof(T), ((LambdaExpression)expression).ReturnType);

                    IIncludableQueryable<T,?> result = method.Invoke(null, new Object[] { collection, expression });

                    start = false;
                } 
                else 
                {
                    MethodInfo method = includeAfterReference.MakeGenericMethod(typeof(T), typeof(?), ((LambdaExpression)expression).ReturnType);

                    IIncludableQueryable <T,?> result = method.Invoke(null, new Object[] { collection, expression });
                }           
            }
        }
        
        return collection; // (to be replaced by final as Queryable)
    }
}

主要问题是解决每个 Include 和 ThenInclude 步骤的正确类型，以及要使用哪个 ThenInclude。

对于当前的 EF7 Core，这甚至可能吗？有人找到动态 Include 的解决方案了吗？

Include和 ThenIncludeAfterReference和 ThenIncludeAfterCollection方法是 EntityFrameworkQueryableExtensions 的一部分在 EntityFramework Github's 中上课存储库。

最佳答案

更新:

从 v1.1.0 开始，基于字符串的包含现在是 EF Core 的一部分，因此问题和以下解决方案已过时。

原答案:

周末有趣的运动。

解决方案:

我最终得到了以下扩展方法:

public static class IncludeExtensions
{
    private static readonly MethodInfo IncludeMethodInfo = typeof(EntityFrameworkQueryableExtensions).GetTypeInfo()
        .GetDeclaredMethods(nameof(EntityFrameworkQueryableExtensions.Include)).Single(mi => mi.GetParameters().Any(pi => pi.Name == "navigationPropertyPath"));

    private static readonly MethodInfo IncludeAfterCollectionMethodInfo = typeof(EntityFrameworkQueryableExtensions).GetTypeInfo()
        .GetDeclaredMethods(nameof(EntityFrameworkQueryableExtensions.ThenInclude)).Single(mi => !mi.GetParameters()[0].ParameterType.GenericTypeArguments[1].IsGenericParameter);

    private static readonly MethodInfo IncludeAfterReferenceMethodInfo = typeof(EntityFrameworkQueryableExtensions).GetTypeInfo()
        .GetDeclaredMethods(nameof(EntityFrameworkQueryableExtensions.ThenInclude)).Single(mi => mi.GetParameters()[0].ParameterType.GenericTypeArguments[1].IsGenericParameter);

    public static IQueryable<TEntity> Include<TEntity>(this IQueryable<TEntity> source, params string[] propertyPaths)
        where TEntity : class
    {
        var entityType = typeof(TEntity);
        object query = source;
        foreach (var propertyPath in propertyPaths)
        {
            Type prevPropertyType = null;
            foreach (var propertyName in propertyPath.Split('.'))
            {
                Type parameterType;
                MethodInfo method;
                if (prevPropertyType == null)
                {
                    parameterType = entityType;
                    method = IncludeMethodInfo;
                }
                else
                {
                    parameterType = prevPropertyType;
                    method = IncludeAfterReferenceMethodInfo;
                    if (parameterType.IsConstructedGenericType && parameterType.GenericTypeArguments.Length == 1)
                    {
                        var elementType = parameterType.GenericTypeArguments[0];
                        var collectionType = typeof(ICollection<>).MakeGenericType(elementType);
                        if (collectionType.IsAssignableFrom(parameterType))
                        {
                            parameterType = elementType;
                            method = IncludeAfterCollectionMethodInfo;
                        }
                    }
                }
                var parameter = Expression.Parameter(parameterType, "e");
                var property = Expression.PropertyOrField(parameter, propertyName);
                if (prevPropertyType == null)
                    method = method.MakeGenericMethod(entityType, property.Type);
                else
                    method = method.MakeGenericMethod(entityType, parameter.Type, property.Type);
                query = method.Invoke(null, new object[] { query, Expression.Lambda(property, parameter) });
                prevPropertyType = property.Type;
            }
        }
        return (IQueryable<TEntity>)query;
    }
}

测试:

模型:

public class P
{
    public int Id { get; set; }
    public string Info { get; set; }
}

public class P1 : P
{
    public P2 P2 { get; set; }
    public P3 P3 { get; set; }
}

public class P2 : P
{
    public P4 P4 { get; set; }
    public ICollection<P1> P1s { get; set; }
}

public class P3 : P
{
    public ICollection<P1> P1s { get; set; }
}

public class P4 : P
{
    public ICollection<P2> P2s { get; set; }
}

public class MyDbContext : DbContext
{
    public DbSet<P1> P1s { get; set; }
    public DbSet<P2> P2s { get; set; }
    public DbSet<P3> P3s { get; set; }
    public DbSet<P4> P4s { get; set; }

    // ...

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<P1>().HasOne(e => e.P2).WithMany(e => e.P1s).HasForeignKey("P2Id").IsRequired();
        modelBuilder.Entity<P1>().HasOne(e => e.P3).WithMany(e => e.P1s).HasForeignKey("P3Id").IsRequired();
        modelBuilder.Entity<P2>().HasOne(e => e.P4).WithMany(e => e.P2s).HasForeignKey("P4Id").IsRequired();
        base.OnModelCreating(modelBuilder);
    }
}

用法:

var db = new MyDbContext();

// Sample query using Include/ThenInclude
var queryA = db.P3s
    .Include(e => e.P1s)
        .ThenInclude(e => e.P2)
            .ThenInclude(e => e.P4)
    .Include(e => e.P1s)
        .ThenInclude(e => e.P3);

// The same query using string Includes
var queryB = db.P3s
    .Include("P1s.P2.P4", "P1s.P3");

工作原理:

给定类型 TEntity 和 Prop1.Prop2...PropN 形式的字符串属性路径，我们拆分路径并执行以下操作:

对于第一个属性，我们只是通过反射调用 EntityFrameworkQueryableExtensions.Include 方法:

public static IIncludableQueryable<TEntity, TProperty>
Include<TEntity, TProperty>
(
    this IQueryable<TEntity> source,
    Expression<Func<TEntity, TProperty>> navigationPropertyPath
)

并存储结果。我们知道 TEntity 和 TProperty 是属性的类型。

对于下一个属性，它有点复杂。我们需要调用以下 ThenInclude 重载之一:

public static IIncludableQueryable<TEntity, TProperty>
ThenInclude<TEntity, TPreviousProperty, TProperty>
(
    this IIncludableQueryable<TEntity, ICollection<TPreviousProperty>> source,
    Expression<Func<TPreviousProperty, TProperty>> navigationPropertyPath
)

和

public static IIncludableQueryable<TEntity, TProperty>
ThenInclude<TEntity, TPreviousProperty, TProperty>
(
    this IIncludableQueryable<TEntity, TPreviousProperty> source,
    Expression<Func<TPreviousProperty, TProperty>> navigationPropertyPath
)

source 是当前的结果。 TEntity 对于所有调用都是一样的。但是什么是 TPreviousProperty 以及我们如何决定调用哪个方法。

好吧，首先我们使用一个变量来记住上一次调用中的 TProperty 是什么。然后我们检查它是否是集合属性类型，如果是，我们使用从集合类型的泛型参数中提取的 TPreviousProperty 类型调用第一个重载，否则简单地使用该类型调用第二个重载。

仅此而已。没什么特别的，只是通过反射模拟显式 Include/ThenInclude 调用链。

关于c# - 是否可以在 Entity Framework Core 中创建基于字符串的 Include 替代方案？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38312437/