Wie erstelle ich eine Ausdrucksbaumstruktur, die IEnumerable & lt; TSource & gt; .Any (...) aufruft?

Barry ' s Antwort stellt eine funktionierende Lösung zu der Frage des original-Posters. Vielen Dank an diese beiden Personen für das stellen und beantworten.

Ich diesen thread gefunden, als ich versuchte, erarbeiten eine Lösung für ein ganz ähnliches problem: programmgesteuert erstellen Sie einen Ausdruck-Baum, enthält einen Aufruf auf den Any () - Methode. Als eine weitere Einschränkung, die allerdings die ultimative Ziel meine Lösung war, passieren solche einem dynamisch erstellten Ausdruck durch Linq-to-SQL, so dass die Arbeit der () - Auswertung tatsächlich ausgeführt in der DB selbst.

Leider die Lösung als bisher besprochen haben, ist nicht etwas, dass Linq-to-SQL verarbeiten kann.

Betrieb unter der Annahme, dass dies vielleicht ein ziemlich beliebtes Grund für den Wunsch nach Aufbau einer dynamischen Ausdruck Baum, habe ich beschlossen, zu erweitern, den thread mit meinen Ergebnissen.

Als ich versuchte zu verwenden, das Ergebnis von Barry ' s CallAny() als Ausdruck in einer Linq-to-SQL-Where () - Klausel, erhielt ich eine InvalidOperationException mit einer der folgenden Eigenschaften:

• HResult=-2146233079
• Message="Internal".NET Framework-Datenanbieter Fehler 1025"
• Source=System.Daten.Entity

Nach einem Vergleich eine hart-kodierte expression tree der dynamisch-erstellt mit CallAny(), fand ich, dass der Kern des Problems war aufgrund der Compile () - Prädikat-Ausdruck und der Versuch zum aufrufen der resultierende Delegat in der CallAny(). Ohne zu Graben tief in Linq-to-SQL-Implementierung-details, schien es mir vernünftig, dass Linq-to-SQL würde nicht wissen, was zu tun mit solch einer Struktur.

Daher, nach einigem Experimentieren, konnte ich das erreichen meiner gewünschten Ziel, indem Sie Sie leicht überarbeiten der vorgeschlagenen CallAny() implementation einer predicateExpression eher als ein Delegierter für Jedes () - Prädikat-Logik.

Meine überarbeitete Methode ist:

static Expression CallAny(Expression collection, Expression predicateExpression)
{
    Type cType = GetIEnumerableImpl(collection.Type);
    collection = Expression.Convert(collection, cType); //(see "NOTE" below)

    Type elemType = cType.GetGenericArguments()[0];
    Type predType = typeof(Func<,>).MakeGenericType(elemType, typeof(bool));

    //Enumerable.Any<T>(IEnumerable<T>, Func<T,bool>)
    MethodInfo anyMethod = (MethodInfo)
        GetGenericMethod(typeof(Enumerable), "Any", new[] { elemType }, 
            new[] { cType, predType }, BindingFlags.Static);

    return Expression.Call(
        anyMethod,
        collection,
        predicateExpression);
}

Nun werde ich zeigen, die seine Verwendung mit EF. Für Klarheit sollte ich zuerst zeigen die Spielzeug-domain-model & EF Kontext ich bin mit. Im Grunde ist mein Modell ist eine vereinfachende Blogs & Beiträge-domain ... wo ein blog hat mehrere Beiträge und jeder Beitrag hat ein Datum:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }

    public virtual List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public DateTime Date { get; set; }

    public int BlogId { get; set; }
    public virtual Blog Blog { get; set; }
}

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

Mit dieser domain eingerichtet, hier ist mein code, um letztlich die Ausübung des überarbeiteten CallAny() und Linq-to-SQL die Arbeit der Auswertung, die Alle(). Meine besonderen Beispiel wird der Fokus auf die RÜCKFÜHRUNG aller Blogs die mindestens einen Beitrag, der neuer ist als eine bestimmte cutoff-Datum.

static void Main()
{
    Database.SetInitializer<BloggingContext>(
        new DropCreateDatabaseAlways<BloggingContext>());

    using (var ctx = new BloggingContext())
    {
        //insert some data
        var blog  = new Blog(){Name = "blog"};
        blog.Posts = new List<Post>() 
            { new Post() { Title = "p1", Date = DateTime.Parse("01/01/2001") } };
        blog.Posts = new List<Post>()
            { new Post() { Title = "p2", Date = DateTime.Parse("01/01/2002") } };
        blog.Posts = new List<Post>() 
            { new Post() { Title = "p3", Date = DateTime.Parse("01/01/2003") } };
        ctx.Blogs.Add(blog);

        blog = new Blog() { Name = "blog 2" };
        blog.Posts = new List<Post>()
            { new Post() { Title = "p1", Date = DateTime.Parse("01/01/2001") } };
        ctx.Blogs.Add(blog);
        ctx.SaveChanges();


        //first, do a hard-coded Where() with Any(), to demonstrate that
        //Linq-to-SQL can handle it
        var cutoffDateTime = DateTime.Parse("12/31/2001");
        var hardCodedResult = 
            ctx.Blogs.Where((b) => b.Posts.Any((p) => p.Date > cutoffDateTime));
        var hardCodedResultCount = hardCodedResult.ToList().Count;
        Debug.Assert(hardCodedResultCount > 0);


        //now do a logically equivalent Where() with Any(), but programmatically
        //build the expression tree
        var blogsWithRecentPostsExpression = 
            BuildExpressionForBlogsWithRecentPosts(cutoffDateTime);
        var dynamicExpressionResult = 
            ctx.Blogs.Where(blogsWithRecentPostsExpression);
        var dynamicExpressionResultCount = dynamicExpressionResult.ToList().Count;
        Debug.Assert(dynamicExpressionResultCount > 0);
        Debug.Assert(dynamicExpressionResultCount == hardCodedResultCount);
    }
}

Wo BuildExpressionForBlogsWithRecentposts() ist eine Hilfsfunktion, die verwendet CallAny() wie folgt:

private Expression<Func<Blog, Boolean>> BuildExpressionForBlogsWithRecentPosts(
    DateTime cutoffDateTime)
{
    var blogParam = Expression.Parameter(typeof(Blog), "b");
    var postParam = Expression.Parameter(typeof(Post), "p");

    //(p) => p.Date > cutoffDateTime
    var left = Expression.Property(postParam, "Date");
    var right = Expression.Constant(cutoffDateTime);
    var dateGreaterThanCutoffExpression = Expression.GreaterThan(left, right);
    var lambdaForTheAnyCallPredicate = 
        Expression.Lambda<Func<Post, Boolean>>(dateGreaterThanCutoffExpression, 
            postParam);

    //(b) => b.Posts.Any((p) => p.Date > cutoffDateTime))
    var collectionProperty = Expression.Property(blogParam, "Posts");
    var resultExpression = CallAny(collectionProperty, lambdaForTheAnyCallPredicate);
    return Expression.Lambda<Func<Blog, Boolean>>(resultExpression, blogParam);
}

HINWEIS: ich fand eine andere, scheinbar unwichtige delta zwischen hard-codiert und dynamisch-integrierte Ausdrücke. Die dynamisch gebaut, hat man einen "extra" konvertieren rufen, dass es in der hart codierte version nicht zu haben scheinen (oder müssen?). Die Umwandlung eingeführt wird, in der CallAny () - Implementierung. Linq-to-SQL scheint ok zu sein, so dass ich es gelassen (obwohl es unnötig war). Ich war nicht ganz sicher, ob diese Umstellung vielleicht notwendig sein, einige robustere Nutzungen als mein Spielzeug Probe.

InformationsquelleAutor der Antwort Aaron Heusser