Linq access property by variable

Question

Let\'s say I have a class like:

public class Foo
{
    public string Title {get;set;}
}

Now, let\'s assume I have a public List

Answer 1

you cant use linq dynamic query from microsoft here is sample code

 var query =  db.Customers.Where("City == @0 and Orders.Count >= @1", "London", 10).
            OrderBy("CompanyName").
            Select("New(CompanyName as Name, Phone)"); 

Answer 2

I know this is an old thread but here is another way to do it. This has the advantage of being significantly faster if you need to do it in a loop. I have converted the result out of "func" to be object to make it a bit more general purpose.

        var p = Expression.Parameter(typeof(string));
        var prop = Expression.Property(p, "Length");
        var con = Expression.Convert(prop, typeof(object));
        var exp = Expression.Lambda(con, p);
        var func = (Func<string, object>)exp.Compile();

        var obj = "ABC";
        int len = (int)func(obj);

In the original question the code was being used inside linq so speed could be good. It would be possible to use "func" direct in the where clause also if it was built correctly, eg

        class ABC
        {
            public string Name { get; set; }
        }

        var p = Expression.Parameter(typeof(ABC));
        var prop = Expression.Property(p, "Name");
        var body = Expression.Equal(prop, Expression.Constant("Bob"));
        var exp = Expression.Lambda(body, p);
        var func = (Func<ABC, bool>)exp.Compile();

        ABC[] items = "Fred,Bob,Mary,Jane,Bob".Split(',').Select(s => new ABC() { Name = s }).ToArray();
        ABC[] bobs = items.Where(func).ToArray();

Answer 3

This is not the type of situation that LINQ is used for. LINQ is a fluent interface for manipulating collections. Accessing members via a textual representation is done with reflection.

object GetProperty(Foo f, string propertyName) {
  var type = typeof(Foo);
  var propInfo = type.GetProperty(propertyName);
  return propInfo.GetValue(f, null);
}

Answer 4

You can write an extension method

public static class MyExtensions
{
    public static object GetProperty<T>(this T obj, string name) where T : class
    {
        Type t = typeof(T);
        return t.GetProperty(name).GetValue(obj, null);
    }
}

and use it like this

var x = myList.Where(f => f.GetProperty("Title") == myValue);

Answer 5

If you need to compose your queries dynamically on the fly, you can use the LINQ Dynamic Query library, a sample from Microsoft:

This sample shows a technique for composing LINQ statements on the fly, dynamically, at run time.

Reference the library in your code:

using System.Linq.Dynamic;

Your query would look like this:

// You can use a string as the argument for the Where method
// meaning you can compose this string dynamically
string myProperty = "Title";
var x = myList.Where(myProperty + " = " + myValue);

It's also possible to use placeholder in the query string, which improves readability (somewhat):

var x = myList.Where("@0 = @1", myProperty, myValue);

See also this post from Scott Guthrie: Dynamic LINQ Part 1: Using the LINQ Dynamic Query Library (I don't think there ever was a part 2...)

Note: you have to compile the sample code from Microsoft and reference the built assembly, or you could include the code in your own project.