I understand lambdas and the `Func` and `Action` delegates. But expressions 
stump me. 

In what circumstances would you use an `Expression&lt;Func&lt;T&gt;&gt;` rather than a plain old `Func&lt;T&gt;`?

Why would you use Expression&lt;Func&lt;T&gt;&gt; rather than Func&lt;T&gt;?

Is there a better way to get the Property name when passed in via a lambda expression?
Here is what i currently have.


eg. 

    GetSortingInfo&lt;User&gt;(u =&gt; u.UserId);

It worked by casting it as a memberexpression only when the property was  a string. because not all properties are strings i had to use object but then it would return a unaryexpression for those.

    public static RouteValueDictionary GetInfo&lt;T&gt;(this HtmlHelper html, 
        Expression&lt;Func&lt;T, object&gt;&gt; action) where T : class
    {
        var expression = GetMemberInfo(action);
        string name = expression.Member.Name;
    
        return GetInfo(html, name);
    }
    
    private static MemberExpression GetMemberInfo(Expression method)
    {
        LambdaExpression lambda = method as LambdaExpression;
        if (lambda == null)
            throw new ArgumentNullException(&quot;method&quot;);
    
        MemberExpression memberExpr = null;
    
        if (lambda.Body.NodeType == ExpressionType.Convert)
        {
            memberExpr = 
                ((UnaryExpression)lambda.Body).Operand as MemberExpression;
        }
        else if (lambda.Body.NodeType == ExpressionType.MemberAccess)
        {
            memberExpr = lambda.Body as MemberExpression;
        }
    
        if (memberExpr == null)
            throw new ArgumentException(&quot;method&quot;);
    
        return memberExpr;
    }

Retrieving Property name from lambda expression

I&#39;ve been taking a look to [Roslyn CTP][1] and, while it solves a similar problem to the [Expression tree API][2], both are immutable but Roslyn does so in a quite different way: 

* `Expression` nodes have no reference to the parent node, are modified using a `ExpressionVisitor` and that&#39;s why big parts can be reused. 

* Roslyn&#39;s `SyntaxNode`, on the other side, has a reference to its parent, so all the nodes effectively become a block that&#39;s impossible to re-use. Methods like `Update`, `ReplaceNode`, etc, are provided to make modifications. 

Where does this end? `Document`? `Project`? `ISolution`? The API promotes a step-by-step change of the tree (instead of a button up), but does each step makes a full copy?

Why they did they make such a choice? Is there some interesting trick I&#39;m missing? 


  [1]: http://msdn.microsoft.com/en-us/roslyn
  [2]: http://msdn.microsoft.com/en-us/library/bb397951.aspx

Are Roslyn SyntaxNodes reused?

**Note: I am aware of the earlier question “[What is the purpose of LINQ&#39;s Expression.Quote method?](https://stackoverflow.com/questions/3138133/)”**, but if you read on you will see that it doesn’t answer my question.

I understand what the stated purpose of `Expression.Quote()` is. However, `Expression.Constant()` can be used for the same purpose (in addition to all the purposes that `Expression.Constant()` is already used for). Therefore, I don’t understand why `Expression.Quote()` is at all required. 

To demonstrate this, I have written a quick example where one would customarily use `Quote` (see the line marked with exclamation points), but I used `Constant` instead and it worked equally well:

    string[] array = { &quot;one&quot;, &quot;two&quot;, &quot;three&quot; };

    // This example constructs an expression tree equivalent to the lambda:
    // str =&gt; str.AsQueryable().Any(ch =&gt; ch == &#39;e&#39;)

    Expression&lt;Func&lt;char, bool&gt;&gt; innerLambda = ch =&gt; ch == &#39;e&#39;;

    var str = Expression.Parameter(typeof(string), &quot;str&quot;);
    var expr =
        Expression.Lambda&lt;Func&lt;string, bool&gt;&gt;(
            Expression.Call(typeof(Queryable), &quot;Any&quot;, new Type[] { typeof(char) },
                Expression.Call(typeof(Queryable), &quot;AsQueryable&quot;,
                                new Type[] { typeof(char) }, str),
                // !!!
                Expression.Constant(innerLambda)    // &lt;--- !!!
            ),
            str
        );

    // Works like a charm (prints one and three)
    foreach (var str in array.AsQueryable().Where(expr))
        Console.WriteLine(str);

The output of `expr.ToString()` is the same for both, too (whether I use `Constant` or `Quote`).

Given the above observations, it appears that `Expression.Quote()` is redundant. The C# compiler could have been made to compile nested lambda expressions into an expression tree involving `Expression.Constant()` instead of `Expression.Quote()`, and any LINQ query provider that wants to process expression trees into some other query language (such as SQL) could look out for a `ConstantExpression` with type `Expression&lt;TDelegate&gt;` instead of a `UnaryExpression` with the special `Quote` node type, and everything else would be the same.

What am I missing? Why was `Expression.Quote()` and the special `Quote` node type for `UnaryExpression` invented?



What does Expression.Quote() do that Expression.Constant() can’t already do?

I have the following generic extension method:

&lt;!-- language: c# --&gt;

    public static T GetById&lt;T&gt;(this IQueryable&lt;T&gt; collection, Guid id) 
        where T : IEntity
    {
        Expression&lt;Func&lt;T, bool&gt;&gt; predicate = e =&gt; e.Id == id;

        T entity;
            
        // Allow reporting more descriptive error messages.
        try
        {
            entity = collection.SingleOrDefault(predicate);
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException(string.Format(
                &quot;There was an error retrieving an {0} with id {1}. {2}&quot;,
                typeof(T).Name, id, ex.Message), ex);
        }

        if (entity == null)
        {
            throw new KeyNotFoundException(string.Format(
                &quot;{0} with id {1} was not found.&quot;,
                typeof(T).Name, id));
        }

        return entity;
    }

Unfortunately Entity Framework doesn&#39;t know how to handle the `predicate` since C# converted the predicate to the following:

&lt;!-- language: c# --&gt;

    e =&gt; ((IEntity)e).Id == id

Entity Framework throws the following exception:

&gt; Unable to cast the type &#39;IEntity&#39; to type &#39;SomeEntity&#39;. LINQ to
&gt; Entities only supports casting EDM primitive or enumeration types.

How can we make Entity Framework work with our `IEntity` interface?

LINQ to Entities only supports casting EDM primitive or enumeration types with IEntity interface

Is there a way to Deserialize Expressions in C#, I would like to store Expressions in a Database and load them at run time.


Serializing and Deserializing Expression Trees in C#

Consider the following simple manipulation over a collection:

    static List&lt;int&gt; x = new List&lt;int&gt;() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    var result = x.Where(i =&gt; i % 2 == 0).Where(i =&gt; i &gt; 5);

Now let&#39;s use Expressions. The following code is roughly equivalent:

    static void UsingLambda() {
        Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt; lambda = l =&gt; l.Where(i =&gt; i % 2 == 0).Where(i =&gt; i &gt; 5);
        var t0 = DateTime.Now.Ticks;
        for (int j = 1; j &lt; MAX; j++) 
            var sss = lambda(x).ToList();
            
        var tn = DateTime.Now.Ticks;
        Console.WriteLine(&quot;Using lambda: {0}&quot;, tn - t0);
    }

But I want to build the expression on-the-fly, so here&#39;s a new test:

    static void UsingCompiledExpression() {
        var f1 = (Expression&lt;Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt;&gt;)(l =&gt; l.Where(i =&gt; i % 2 == 0));
        var f2 = (Expression&lt;Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt;&gt;)(l =&gt; l.Where(i =&gt; i &gt; 5));
        var argX = Expression.Parameter(typeof(IEnumerable&lt;int&gt;), &quot;x&quot;);
        var f3 = Expression.Invoke(f2, Expression.Invoke(f1, argX));
        var f = Expression.Lambda&lt;Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt;&gt;(f3, argX);
            
        var c3 = f.Compile();

        var t0 = DateTime.Now.Ticks;
        for (int j = 1; j &lt; MAX; j++) 
            var sss = c3(x).ToList();
            
        var tn = DateTime.Now.Ticks;
        Console.WriteLine(&quot;Using lambda compiled: {0}&quot;, tn - t0);
    }

Of course it isn&#39;t exactly like the above, so to be fair, I modify the first one slightly:

    static void UsingLambdaCombined() {
        Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt; f1 = l =&gt; l.Where(i =&gt; i % 2 == 0);
        Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt; f2 = l =&gt; l.Where(i =&gt; i &gt; 5);
        Func&lt;IEnumerable&lt;int&gt;, IEnumerable&lt;int&gt;&gt; lambdaCombined = l =&gt; f2(f1(l));
        var t0 = DateTime.Now.Ticks;
        for (int j = 1; j &lt; MAX; j++) 
            var sss = lambdaCombined(x).ToList();
           
        var tn = DateTime.Now.Ticks;
        Console.WriteLine(&quot;Using lambda combined: {0}&quot;, tn - t0);
    }

Now comes the results for MAX = 100000, VS2008, debugging ON:

    Using lambda compiled: 23437500
    Using lambda:           1250000
    Using lambda combined:  1406250

And with debugging OFF:

    Using lambda compiled: 21718750
    Using lambda:            937500
    Using lambda combined:  1093750

*Surprise*. The compiled expression is roughly 17x slower than the other alternatives. Now here comes the questions:

 1. Am I comparing non-equivalent expressions?
 2. Is there a mechanism to make .NET &quot;optimize&quot; the compiled expression?
 3. How do I express the same chain call `l.Where(i =&gt; i % 2 == 0).Where(i =&gt; i &gt; 5);` programatically?

----------

Some more statistics. Visual Studio 2010, debugging ON, optimizations OFF:
 
    Using lambda:           1093974
    Using lambda compiled: 15315636
    Using lambda combined:   781410

Debugging ON, optimizations ON:

    Using lambda:            781305
    Using lambda compiled: 15469839
    Using lambda combined:   468783

Debugging OFF, optimizations ON:

    Using lambda:            625020
    Using lambda compiled: 14687970
    Using lambda combined:   468765

*New Surprise.* Switching from VS2008 (C#3) to VS2010 (C#4), makes the `UsingLambdaCombined` faster than the native lambda.
 
----------

Ok, I&#39;ve found a way to improve the lambda compiled performance by more than an order of magnitude. Here&#39;s a tip; after running the profiler, 92% of the time is spent on:

    System.Reflection.Emit.DynamicMethod.CreateDelegate(class System.Type, object)

Hmmmm... Why is it creating a new delegate in every iteration? I&#39;m not sure, but the solution follows in a separate post.

Compiled C# Lambda Expressions Performance

    public static IQueryable&lt;TResult&gt; ApplySortFilter&lt;T, TResult&gt;(this IQueryable&lt;T&gt; query, string columnName)
      where T : EntityObject
    {
      var param = Expression.Parameter(typeof(T), &quot;o&quot;);
      var body = Expression.PropertyOrField(param,columnName);

      var sortExpression = Expression.Lambda(body, param);
      return query.OrderBy(sortExpression);
    }

Because the type for OrderBy is not inferred from sortExpression I need to specify it something like this at run time:

    var sortExpression = Expression.Lambda&lt;T, TSortColumn&gt;(body, param);
Or

    return query.OrderBy&lt;T, TSortColumn&gt;(sortExpression);

I don&#39;t think this is possible however as TSortColumn can only be determined during runtime.

Is there a way around this?

How do I apply OrderBy on an IQueryable using a string column name within a generic extension method?

I am the dummy in this scenario.

I&#39;ve tried to read on Google what these are but I just don&#39;t get it.  Can someone give me a simple explanation of what they are and why they&#39;re useful?

edit: I&#39;m talking about the LINQ feature in .Net.

Expression trees for dummies?

I am just getting started with expression trees so I hope this makes sense. I am trying to create an expression tree to represent:

    t =&gt; t.SomeProperty.Contains(&quot;stringValue&quot;);

So far I have got:

    
        private static Expression.Lambda&lt;Func&lt;string, bool&gt;&gt; GetContainsExpression&lt;T&gt;(string propertyName, string propertyValue)
        {
            var parameterExp = Expression.Parameter(typeof(T), &quot;type&quot;);
            var propertyExp = Expression.Property(parameter, propertyName);
            var containsMethodExp = Expression.*SomeMemberReferenceFunction*(&quot;Contains&quot;, propertyExp) //this is where I got lost, obviously :)
            ...
            return Expression.Lambda&lt;Func&lt;string, bool&gt;&gt;(containsMethodExp, parameterExp); //then something like this
        }

I just don&#39;t know how to reference the String.Contains() method.

Help appreciated. 

How do I create an expression tree to represent &#39;String.Contains(&quot;term&quot;)&#39; in C#?

If i have a product.

    var p = new Product { Price = 30 };

and i have the following linq query.

    var q = repo.Products().Where(x=&gt;x.Price == p.Price).ToList()

In an IQueryable provider, I get a MemberExpression back for the p.Price which contains a Constant Expression, however I can&#39;t seem to get the value &quot;30&quot; back from it.

**Update**
I have tried this but it doesn&#39;t seem to work.

    var memberExpression = (MemberExpression)GetRootConstantExpression(m);
    var fi = (PropertyInfo)memberExpression.Member;
    var val = fi.GetValue(((ConstantExpression)memberExpression.Expression).Value, null);


Cheers.


Access the value of a member expression

Expression trees are a nice feature, but what are its practical uses? Can they be used for some sort of code generation or metaprogramming or some such?

Practical use of expression trees

I just came across the concept of expression trees which I have heard multiple times. I just want to understand what is meant by an expression tree and its purpose. 

I would love it if someone could also direct me to simple explanations and samples of use.

What are Expression Trees, how do you use them, and why would you use them?

I&#39;m wondering what exactly is the difference between wrapping a delegate inside `Expression&lt;&gt;` and not ?

I&#39;m seeing `Expression&lt;Foo&gt;` being used a lot with LinQ, but so far I&#39;ve not found any article that explains the difference between this, and just using a delegate.

E.g.

    Func&lt;int, bool&gt; Is42 = (value) =&gt; value == 42;

vs.

    Expression&lt;Func&lt;int, bool&gt;&gt; Is42 = (value) =&gt; value == 42;



What&#39;s the purpose of the Expression class?

When I first typed this question, I did so in order to find the duplicate questions, feeling sure that someone must have already asked this question. My plan was to follow those dupe links instead of posting this question. But this question has not been asked before as far as I can see ... it did not turn up in the &quot;Related Questions&quot; list.

**What are some of the best resources you&#39;ve found (articles, books, blog posts, etc.) for gaining an in-depth understanding of Expression Trees in C#?**  I keep getting surprised by their capabilities, and now I&#39;m at the point where I&#39;m saying, &quot;OK, enough surprise. I want to stop right now and get a PhD in these things.&quot; I&#39;m looking for material that systematically, methodically covers the capabilities and then walks through detailed examples of what you can do with them.

Note: I&#39;m not talking about lambda expressions. I&#39;m talking about Expression&lt; T &gt; and all the things that go with it and arise from it.

Thanks.

What is the best resource for learning C# expression trees in depth?

    IQueryable&lt;Organization&gt; query = context.Organizations;

    Func&lt;Reservation, bool&gt; predicate = r =&gt; !r.IsDeleted;

    query.Select(o =&gt; new { 
        Reservations = o.Reservations.Where(predicate)
    }).ToList();

this query throws &quot;Internal .NET Framework Data Provider error 1025&quot; exception but the query below does not.

    query.Select(o =&gt; new { 
        Reservations = o.Reservations.Where( r =&gt; !r.IsDeleted)
    }).ToList();

I need to use the first one because I need to check a few if statements for constructing the right predicate. I know that I can not use if statements in this circumstance that is why I pass a delegate as parameter.

How can I make the first query work?

Internal .NET Framework Data Provider error 1025

I try to write a simple example using Expressions, but have a strange bug: I can&#39;t use `PropertyExpression` at compile time. When I write it I get an error and it doesn&#39;t compile 
![enter image description here][1]
But in runtime at breakpoint I can write 

    var runtimeBody = (System.Linq.Expressions.PropertyExpression)body2;

and it works, and casts as expected. Framework 4.5.1 is selected as target. 


  [1]: http://i.stack.imgur.com/AqvG8.png

PropertyExpression is missing

## Intro ##

In the application I &#39;m currently working on, there are two kinds of each business object: the &quot;ActiveRecord&quot; kind and the &quot;DataContract&quot; kind. So for example, there would be:

    namespace ActiveRecord {
        class Widget {
            public int Id { get; set; }
        }
    }

    namespace DataContract {
        class Widget {
            public int Id { get; set; }
        }
    }

The database access layer takes care of translating between families: you can tell it to update a `DataContract.Widget` and it will magically create an `ActiveRecord.Widget` with the same property values and save that instead.

The problem surfaced when attempting to refactor this database access layer.

## The Problem ##

I want to add methods like the following to the database access layer:

    // Widget is DataContract.Widget

    interface IDbAccessLayer {
        IEnumerable&lt;Widget&gt; GetMany(Expression&lt;Func&lt;Widget, bool&gt;&gt; predicate);
    }

The above is a simple general-use &quot;get&quot; method with custom predicate. The only point of interest is that I am passing in an expression tree instead of a lambda because inside `IDbAccessLayer` I am querying an `IQueryable&lt;ActiveRecord.Widget&gt;`; to do that efficiently (think LINQ to SQL) I need to pass in an expression tree so this method asks for just that.

The snag: the parameter needs to be magically transformed from an `Expression&lt;Func&lt;DataContract.Widget, bool&gt;&gt;` to an `Expression&lt;Func&lt;ActiveRecord.Widget, bool&gt;&gt;`.

## Attempted Solution ##

What I &#39;d like to do inside `GetMany` is:

    IEnumerable&lt;DataContract.Widget&gt; GetMany(
        Expression&lt;Func&lt;DataContract.Widget, bool&gt;&gt; predicate)
    {
        var lambda = Expression.Lambda&lt;Func&lt;ActiveRecord.Widget, bool&gt;&gt;(
            predicate.Body,
            predicate.Parameters);
    
        // use lambda to query ActiveRecord.Widget and return some value
    }

This won&#39;t work because in a typical scenario, for example if:

    predicate == w =&gt; w.Id == 0;

...the expression tree contains a `MemberAccessExpression` instance which has a property of type `MemberInfo` that describes `DataContract.Widget.Id`.
There are also `ParameterExpression` instances both in the expression tree and in its parameter collection (`predicate.Parameters`) that describe `DataContract.Widget`; all of this will result in errors since the queryable body does not contain that type of widget but rather `ActiveRecord.Widget`.

After searching a bit, I found [`System.Linq.Expressions.ExpressionVisitor`][1] (its source can be found [here][2] in the context of a how-to), which offers a convenient way to modify an expression tree. In .NET 4, this class is included out of the box.

Armed with this, I implemented a visitor. This simple visitor only takes care of changing the types in member access and parameter expressions, but that&#39;s enough functionality to work with the predicate `w =&gt; w.Id == 0`.

    internal class Visitor : ExpressionVisitor
    {
        private readonly Func&lt;Type, Type&gt; typeConverter;

        public Visitor(Func&lt;Type, Type&gt; typeConverter)
        {
            this.typeConverter = typeConverter;
        }

        protected override Expression VisitMember(MemberExpression node)
        {
            var dataContractType = node.Member.ReflectedType;
            var activeRecordType = this.typeConverter(dataContractType);
            
            var converted = Expression.MakeMemberAccess(
                base.Visit(node.Expression),
                activeRecordType.GetProperty(node.Member.Name));

            return converted;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            var dataContractType = node.Type;
            var activeRecordType = this.typeConverter(dataContractType);

            return Expression.Parameter(activeRecordType, node.Name);
        }
    }

With this visitor, `GetMany` becomes:

    IEnumerable&lt;DataContract.Widget&gt; GetMany(
        Expression&lt;Func&lt;DataContract.Widget, bool&gt;&gt; predicate)
    {
        var visitor = new Visitor(...);
        var lambda = Expression.Lambda&lt;Func&lt;ActiveRecord.Widget, bool&gt;&gt;(
            visitor.Visit(predicate.Body),
            predicate.Parameters.Select(p =&gt; visitor.Visit(p));
    
        var widgets = ActiveRecord.Widget.Repository().Where(lambda);

        // This is just for reference, see below
        Expression&lt;Func&lt;ActiveRecord.Widget, bool&gt;&gt; referenceLambda = 
            w =&gt; w.Id == 0;

        // Here we &#39;d convert the widgets to instances of DataContract.Widget and
        // return them -- this has nothing to do with the question though.
    }

## Results ##

The good news is that `lambda` is constructed just fine. The bad news is that it isn&#39;t working; it&#39;s blowing up on me when I try to use it, and the exception messages are really not helpful at all.

I have examined the lambda my code produces and a hardcoded lambda with the same expression; they look exactly the same. I spent hours in the debugger trying to find some difference, but I can&#39;t.

When the predicate is `w =&gt; w.Id == 0`, `lambda` looks exactly like `referenceLambda`. But the latter works with e.g. `IQueryable&lt;T&gt;.Where`, while the former does not; I have tried this in the immediate window of the debugger.

I should also mention that when the predicate is `w =&gt; true`, everything works fine. Therefore I am assuming that I &#39;m not doing enough work in the visitor, but I can&#39;t find any more leads to follow.

## Final Solution ##

After taking into account the correct answers to the problem (two of them below; one short, one with code) the problem was solved; I put the code along with a few important notes in a [separate answer][3] to keep this long question from becoming even longer.

Thanks to everyone for your answers and comments!


  [1]: http://msdn.microsoft.com/en-us/library/system.linq.expressions.expressionvisitor%28v=VS.100%29.aspx
  [2]: http://msdn.microsoft.com/en-us/library/bb882521%28VS.90%29.aspx
  [3]: https://stackoverflow.com/a/10467736/50079

Mutating the expression tree of a predicate to target another type

I&#39;m trying to figure out how to put all the pieces together, and would appreciate a concrete source code sample for a simple case to start with.

Consider the following C# code:

    Func&lt;int, int, int&gt; f = (x, y) =&gt; x + y;

I can produce an equivalent function at runtime using expression trees as follows:


    var x = Expression.Parameter(typeof(int), &quot;x&quot;);
    var y = Expression.Parameter(typeof(int), &quot;y&quot;);
    Func&lt;int, int, int&gt; f =
        Expression.Lambda&lt;Func&lt;int, int, int&gt;&gt;(
            Expression.Add(x, y),
            new[] { x, y }
        ).Compile();

Now given the following lambda:

    Func&lt;dynamic, dynamic, dynamic&gt; f = (x, y) =&gt; x + y;

how would I generate the equivalent using expression trees (and, presumably, `Expression.Dynamic`)?

C# 4 &quot;dynamic&quot; in expression trees

I was trying to generate a simple Lambda Expression at runtime with no luck... something like this:

    var result = queryableData.Where(item =&gt; item.Name == &quot;Soap&quot;)

Here is my example class and a fixture queryable:

    public class Item
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    IQueryable&lt;Item&gt; queryableData = ...;


Then I generate a lambda expression at runtime **correct code follows**:

    //&quot;item&quot; in &quot;item =&gt;...&quot;
    var item = Expression
        .Parameter(typeof(Item), &quot;item&quot;);
    
    //property of my item, this is &quot;item.Name&quot;
    var prop = Expression
        .Property(item, &quot;Name&quot;);

    //then &quot;Soap&quot; in &#39;... =&gt; item.Name==&quot;Soap&quot;&#39;
    var value = Expression.Constant(&quot;Soap&quot;);

    //equality expression &quot;==&quot; in my primer
    var equals = Expression.Equal(prop, value);

    //then lambda
    var lambda = Expression.Lambda&lt;Func&lt;Item, bool&gt;&gt;(equals, item);

    //and here are the results    
    var results = queryableData.Where(lambda);

Big thanks to **dtb** for advice!

Expression.Lambda and query generation at runtime, simplest &quot;Where&quot; example

I am trying to create a lambda expression for a nested property at run-time from the name of the propert. Basically I am trying to create the lambda expression specified by:

    var expression = CreateExpression&lt;Foo, object&gt;(foo =&gt; foo.myBar.name);

    private static Expression CreateExpression&lt;TEntity, TReturn&gt;(Expression&lt;Func&lt;TEntity, TReturn&gt;&gt; expression)
    {
        return (expression as Expression);
    }

With the classes:

    class Foo
    {
        public Bar myBar { get; set; }
    }
    class Bar
    {
        public string name { get; set; }
    }

However all I am given is the type of `Foo` and the string `&quot;myBar.name&quot;`

If it were a normal property such as just needing the value `&quot;myBar&quot;` then I could use the following:


    private static LambdaExpression GetPropertyAccessLambda(Type type, string propertyName)
    {
        ParameterExpression odataItParameter = Expression.Parameter(type, &quot;$it&quot;);
        MemberExpression propertyAccess = Expression.Property(odataItParameter, propertyName);
        return Expression.Lambda(propertyAccess, odataItParameter);
    }

However this code does not work for nested properties and I&#39;m not sure how to create the LambdaExpression to do the work of `foo.myBar.name`.

I think it&#39;s going to be something like this:

    GetExpression(Expression.Call(GetExpression(Foo, &quot;myBar&quot;), &quot;name&quot;))

But I can&#39;t seem to work out how to get it all working, or if there&#39;s a better way to do this at run-time.

All Expression Trees Solutions on Gang of Coders

Total of 21 Expression Trees Solutions

Why would you use Expression<Func<T>> rather than Func<T>?