How to make expression treat value type as a reference type?

问题

I wanted to store a collection of expressions accessing object's properties. For example:

class Entity
{
    public int Id { get; set; }
    public Entity Parent { get; set; }
    public string Name { get; set; }
    public DateTime Date { get; set; }        
    public decimal Value { get; set; }
    public bool Active { get; set; }
}

static void Main(string[] args)
{
    var list = new List<Expression<Func<Entity, object>>>();
    list.Add(e => e.Id);
    list.Add(e => e.Name);
    list.Add(e => e.Parent);
    list.Add(e => e.Date);
    list.Add(e => e.Value);
    list.Add(e => e.Active);

    StringBuilder b = new StringBuilder();
    list.ForEach(f => b.AppendLine(f.ToString()));

    Console.WriteLine(b.ToString());
    Console.ReadLine();
}

This code outputs:

e => Convert(e.Id)
e => e.Name
e => e.Parent
e => Convert(e.Date)
e => Convert(e.Value)
e => Convert(e.Active)

It does add Convert to value types.

As far as in the end I wanted to use those expressions with LINQ to SQL, I need not to have that Convert in expressions, for them to be successfully translated to SQL.

How can I achieve this?

P.S.: expressions from this collection are later used as arguments to OrderBy and ThenBy methods.

回答1:

If you create a function generic in the proeprty type you can avoid the Convert:

private static LambdaExpression GetExpression<TProp>
                                    (Expression<Func<Entity, TProp>> expr)
{
    return expr;
}

then you can change the type of list:

var list = new List<LambdaExpression>();
list.Add(GetExpression(e => e.Id));
list.Add(GetExpression(e => e.Name));

This will require you to create your OrderBy and ThenBy expressions using reflection e.g.

LambdaExpression idExpr = list[0];
Type keyType = idExpr.ReturnType;

var orderByMethod = typeof(Queryable).GetMethods()
    .Single(m => m.Name == "OrderBy" && m.GetParameters().Length == 2)
    .MakeGenericMethod(typeof(Entity), keyType);

var ordered = (IQueryable<Entity>)
                  orderByMethod.Invoke(null, new object[] { source, idExpr });

回答2:

I patched up a EF code first attempt at using your code like this

public class Entity
{
    public int Id { get; set; }
    public Entity Parent { get; set; }
    public string Name { get; set; }
    public DateTime Date { get; set; }
    public decimal Value { get; set; }
    public bool Active { get; set; }
}
public class EntityContext : DbContext
{
    public EntityContext()
        : base(new SqlCeConnection("Data Source=Database.sdf;Persist Security Info=False;"),
            contextOwnsConnection: true)
    {
        // Using a SQL Compact database as backend
    }
    public DbSet<Entity> Entities { get; set; }
}

and attempted some linq on the context

static void Main(string[] args)
{
    var list = new List<Expression<Func<Entity, object>>>();
    list.Add(e => e.Date);
    list.Add(e => e.Name);
    using (var c = new EntityContext())
    {
        //each time a new record is added
        var data = new Entity
        {
            Name = string.Format("Data{0}", c.Entities.Count()),
            Date = DateTime.Now
        };
        c.Entities.Add(data);
        c.SaveChanges();

        // sort by date
        foreach (var e in c.Entities.OrderBy(list.First().Compile()))
            Console.WriteLine(string.Format("{0} - {1}", e.Name, e.Date));

        // sort by name .. in reverse
        foreach (var e in c.Entities.OrderByDescending(list.Last().Compile()))
            Console.WriteLine(string.Format("{0} - {1}", e.Name, e.Date));

    }
    Console.ReadLine();
}

There were no issues running the code.

UPDATE The same holds true for LINQ to SQL: I built a table in a local SQL Server with the same structure as the class, and tried to OrderBy it : no problem.

My answer is "You don't need to worry about that".

回答3:

Thank's to the answer by Alex I found out for myself that, when ordering the data I can use two different methods, depending on the specified argument:

Queryable.OrderBy Method with Expression<Func<TSource, TKey>>
Enumerable.OrderBy Method with Func<TSource, TKey>

When Queryable.OrderBy is used, LINQ compiles the OrderBy clause into the SQL statement, executed over the database. So when I try to give it a Expression<Func<TEntity, object>> that looks like e => Convert(e.Field), LINQ throws an InvalidOperationException, saying Cannot order by type 'System.Object'.

When Enumerable.OrderBy is used, LINQ does not compile the OrderBy clause into the SQL query, but executes the current query and applies sorting on the enumerable of entities, returned by the query, in the program's memory. Here no problem with ordering by Func<TEntity, object>.

So I found two alternatives here:

Query the database without sorting and order the returned result set
Provide better expressions to LINQ, that it could compile the SQL query, and then apply sorting in the database layer; here the answer by Lee suggests one way..

In my exact case sorting is the last operation to execute, and I don't see much harm, if I order the result set in the programm's memory...I'm not going to expect huge amounts of data to be returned...

Though in a more common case, probably it's still better to do all possible operations in the database layer...

P.S.: SO: Order a linq query - a close discussion...

来源：https://stackoverflow.com/questions/20140696/how-to-make-expression-treat-value-type-as-a-reference-type

标签

generics

linq-to-sql

expression