修改

Question

背景

我在Entity Framework中创建了对象图，其中任何给定的对象A都有一个跟踪其变化的表Ac。这些对象也可以相互连接，例如A为1-many到B.这是一个示例图：

            A -> Ac
           /  \
    Bc <- B    \
         /      \  
  Cc <- C        D -> Dc

我希望能够通过使用更改表来提取这些记录并应用它们，从而在某个时间点加载对象和特定的连接对象。理想情况下，我希望能够使用或模仿实体框架中的.Include函数。

问题

拉出IQueryable中已包含的对象并不像我猜想的那么容易。查看具有T IQueryable<T> - ed子对象的Include()，我可以看到这些关系存储在Span属性中的某种Arguments对象中 - 但是这些都是内部类，并且尝试检索此信息有很多步骤。

这是我到目前为止所做的：

    public static void LoadVersion<T>( this IQueryable<T> query, DateTime targetDateTime )
    {
        //grab the value of the "Arguments" property on query.Expression
        //this has to be done through reflection because "Arguments" is not accessible otherwise
        PropertyInfo argumentsPropertyInfo = query.Expression.GetType().GetProperties().FirstOrDefault( x => x.Name == "Arguments" );
        dynamic argumentsPropertyValue = argumentsPropertyInfo.GetValue( query.Expression );

        for (int i = 0; i < argumentsPropertyValue.Count; i++)
        {
            //This gets me a System.Data.Entity.Core.Objects.Span, but that class is internal  
            //In the watch, I can see span -> SpanList[0].Navigations[0] gives me the name of the class in the .Include()
            //      This is the value I need
            dynamic span = argumentsPropertyValue[i].Value;

            //So if I try to pull it out using the same reflection trick as before, I get
            //      a dynamic {System.Reflection.PropertyInfo[0]} (not a list, as you would normally expect), 
            //      and accessing those values & methods makes the debugger exit without an exception
            dynamic spanPropertyInfo = argumentsPropertyValue[i].Value.GetType().GetProperties();

            //this makes the debugger exit without an exception
            dynamic spanPropertyValue = spanPropertyInfo[0].GetValue(span);

            //this also makes the debugger exit without an exception (with the above line commented out, of course)
            dynamic spanPropertyValue2 = spanPropertyInfo.GetValue( span );                
        }
    }

根据我查找查询中包含的内容有多困难，我不禁认为我这样做完全是错误的。深入研究一些Entity Framework 6.1.3源代码并未对此有所了解。

修改

我一直在玩Alex Derck提供的代码，但我意识到我仍然需要一些工作来使我的工作按照我想要的方式进行。

以下是我实施的VisitMethodCall版本：

protected override Expression VisitMethodCall( MethodCallExpression node )
{
    if (node.Method.Name != "Include" && node.Method.Name != "IncludeSpan") return base.VisitMethodCall(node);

    try
    {
        string includedObjectName = (string) node.Arguments.First().GetPrivatePropertyValue( "Value" );

        if (includedObjectName != null)
        {
            _includes.Add(includedObjectName);
        }
    }
    catch (Exception e ){ }
    return base.VisitMethodCall( node );
}

我能够使用includes构造一个查询，并使用IncludeVisitor获取我包含的对象的名称，但使用这些对象的主要目的是能够找到相关的表并将它们添加到include中。 / p>

所以当我有相同的东西时：

var query = ctx.Persons.Include(p => p.Parents).Include(p => p.Children);
// includes[0] = "Parents"
// includes[1] = "Children"
var includes = IncludeVisitor.GetIncludes(query.Expression);

我成功抓住includes，然后我可以找到相关的表格（父母 - ＆gt; ParentsChanges，儿童 - ＆gt; ChildrenChanges），但我不是100％肯定如何将这些添加回来包括。

这里的主要问题是它是一个嵌套语句： context.A.Include(x => x.B).Include(x => x.C).Include(x => x.B.Select(y => y.D))

我可以成功遍历整个图形并获取A，B，C和D的名称，但我需要能够将这个的语句添加回包含：

[...].Include(x => x.B.Select(y => y.D.Select(z => z.DChanges)))

我可以找到 DChanges，但我不知道如何构建包括备份，因为我不知道DChanges与原始项目（A）之间有多少步骤。

Answer 1

在实体框架的source code中查看一下后，我发现包含不是Expression的一部分，而是IQueryable的一部分。如果你考虑一下，很明显它应该是这样的。表达式本身不能实际执行代码，它们由提供者（也是IQueryable的一部分）进行翻译，并非所有提供者都应该知道如何翻译Include方法。在源代码中，您可以看到IQueryable.Include方法调用以下小方法：

public ObjectQuery<T> Include(string path)
{
    Check.NotEmpty(path, "path");
    return new ObjectQuery<T>(QueryState.Include(this, path));
}

查询（转换为ObjectQuery）只是返回，只有它的内部QueryState被更改，表达式根本没有发生。在调试器中，您可以看到在查看IQueryable时将包含的EntitySet，但我无法将它们放入列表中（{I}当我尝试访问时始终为null它通过反思）。

我认为在看到这个之后，您尝试做的事情是不可能的，所以我会在dbContext中保留一个静态字符串列表并实现自定义_cachedPlan扩展方法：

Include

您还可以“覆盖”来自public partial class TestDB { public static ICollection<Expression> Includes { get; set; } = new List<Expression>(); public TestDB() : base() { Includes = new List<Expression>(); } ... } public static class EntityExtensions { public static IQueryable<T> CustomInclude<T, TProperty>(this IQueryable<T> query, Expression<Func<T,TProperty>> include) where T : class { TestDB.Includes.Add(include); return query.Include(include); } }的常规Include方法。我说'覆盖'，因为从技术上讲，它不可能覆盖扩展方法，但您可以自己创建一个名为System.Data.Entity的扩展方法，并使用相同的参数，如果不包含Include在你使用它的地方，你自己的方法与System.Data.Entity的方法之间没有歧义：

System.Data.Entity

Answer 2

我在这里写下你问题的另一个答案（但不是你需要的解决方案）。

您可以使用与实体代理相同的方式检索添加到实体框架6的对象，包括已检索实体的列表。

如果属性在访问时应该延迟加载（因此尚未加载而不在包含列表中），则要检索的属性是Relationship.IsLoaded。您可以在YourEntityWithProxy._entityWrapper.Relationships。

中找到关系列表

_entityWrapper和其他属性是私有的，因此您需要使用反射来读取它们。

Answer 3

在Alex的帮助下，我得到了我想要的东西。

首先，为了获得包含的名称，我使用了Alex发布的答案的早期版本之一的小变体：

internal static class IncludeVisitorExtensions
{
    public static object GetPrivatePropertyValue( this object obj, string propName )
    {
        PropertyInfo propertyInfo = obj.GetType().GetProperty( propName, BindingFlags.Public
                                        | BindingFlags.NonPublic | BindingFlags.Instance );
        return propertyInfo.GetValue( obj, null );
    }

    public static object GetPrivateFieldValue( this object obj, string fieldName )
    {
        FieldInfo fieldInfo = obj.GetType().GetField( fieldName, BindingFlags.Public
                                     | BindingFlags.NonPublic | BindingFlags.Instance );
        return fieldInfo?.GetValue( obj );
    }
}

internal class IncludeVisitor : ExpressionVisitor
{
    private static readonly IncludeVisitor Visitor;
    private static List<string> _includes;

    private IncludeVisitor() { }

    static IncludeVisitor()
    {
        Visitor = new IncludeVisitor();
    }

    public static ICollection<string> GetIncludes( Expression expr )
    {
        _includes = new List<string>();
        Visitor.Visit( expr );
        return _includes;
    }

    protected override Expression VisitMethodCall( MethodCallExpression node )
    {
        if (node.Method.Name != "Include" && node.Method.Name != "IncludeSpan")
            return base.VisitMethodCall( node );

        //"Include" == .Where() is present in the query
        //"IncludeSpan" == no .Where() in the query

        try
        {
            if (node.Method.Name == "Include")
            {
                string includedObjectName = (string) node.Arguments.First().GetPrivatePropertyValue("Value");

                if (includedObjectName != null)
                {
                    _includes.Add(includedObjectName);
                }
            }
            else if (node.Method.Name == "IncludeSpan")
            {
                var spanList =
                    node.Arguments.First().GetPrivatePropertyValue("Value").GetPrivatePropertyValue("SpanList");

                var navigations = ((IEnumerable<object>) spanList).Select(s => s.GetPrivateFieldValue("Navigations"));

                foreach (var nav in navigations)
                    _includes.Add(string.Join(".", (IEnumerable<string>) nav));
            }
        }
        catch (Exception e) { }
        return base.VisitMethodCall( node );
    }
}

我在测试代码时发现的一个小细节是，基于.Where()中是否存在IQueryable<>，表达式中包含的表格的差异。值得庆幸的是，这可以根据方法名称进行检查，虽然代码有点难看，但它确实围绕着截然不同的结构跳舞，以返回正确的表名。

现在我将表格的名称作为字符串复数化。这是因为名称来自DbContext，因此我可以反映属性并获取表格的 Type ：

List<PropertyInfo> contextProperties = typeof( TContext ).GetProperties().ToList();
PropertyInfo prop = contextProperties.First( x => x.Name == s );

使用Type，我可以通过Navigation Properties准确找到我需要的表格，然后我可以构建一个string发送到我的新.Include：

ICollection<string> includes = IncludeVisitor.GetIncludes( query.Expression ); 

foreach (string include in includes)
{
    //sometimes the returned include string will be two tables joined with a '.'; these need to be split and each one checked independently
    List<string> split = include.Split( '.' ).ToList();

    foreach (string s in split)
    {
        //using .First here because we expect the property to exist
        PropertyInfo prop = contextProperties.First( x => x.Name == s );                    

        //the property will be of type DbSet<ObjectType>, so grab the first generic argument (in this case, the object type)
        Type dbSetPropertyType = prop.PropertyType.GetGenericArguments().First();

        //Get the type we're looking to add in the .Include
        var targetTable = GetTargetTableBasedOnTypeViaNavigation(dbSetPropertyType);                 

        //get the name of the property based on the type of the table we just looked up
        PropertyInfo contextProperty = contextProperties.SingleOrDefault(x => x.PropertyType.IsGenericType && x.PropertyType.GetGenericArguments().First().Name == targetTable.Name );

        string includeString = "";                    

        //build the string and add it to the query
        includeString += include + "." + contextPropertyForChangeTracker.Name;
        query = query.Include(includeString);        
    }
}

这适用于我的初始测试数据集，但我不确定它能处理更复杂的图表。

获取添加到实体框架6的对象列表包含列表

修改

3 个答案: