If I understand correctly, you want to reuse an expression tree inside another one, and still allow the compiler to do all the magic of building the expression tree for you. This is actually possible, and I have done it in many occasions. The trick is to wrap your reusable part in a method call, … Read more
In the following query var result = query.Where(item => item.Name == “Soap”) the lambda expression is item => item.Name == “Soap” You only need to construct this part, not the Where call which accepts an expression tree. The expression tree for the lambda expression looks like this: Lambda / \ Equal Parameter / \ item … Read more
It’s hard to mix compiler-generated expression trees and hand-made ones, precisely because of this sort of thing – extracting out the ParameterExpressions is tricky. So let’s start from scratch: ParameterExpression argParam = Expression.Parameter(typeof(Service), “s”); Expression nameProperty = Expression.Property(argParam, “Name”); Expression namespaceProperty = Expression.Property(argParam, “Namespace”); var val1 = Expression.Constant(“Modules”); var val2 = Expression.Constant(“Namespace”); Expression e1 = … Read more
Something like: class Foo { public string Bar { get; set; } } static void Main() { var lambda = GetExpression<Foo>(“Bar”, “abc”); Foo foo = new Foo { Bar = “aabca” }; bool test = lambda.Compile()(foo); } static Expression<Func<T, bool>> GetExpression<T>(string propertyName, string propertyValue) { var parameterExp = Expression.Parameter(typeof(T), “type”); var propertyExp = Expression.Property(parameterExp, propertyName); … Read more
I would do it this way: Write a parameter-replacer expression-visitor that manipulates the original expression as follows: Gets rid of the parameter you don’t want entirely from the lambda signature. Replaces all uses of the parameter with the desired indexer expression. Here’s a quick and dirty sample I whipped up based on my earlier answer … Read more
I was able to resolve this by adding the class generic type constraint to the extension method. I’m not sure why it works, though. public static T GetById<T>(this IQueryable<T> collection, Guid id) where T : class, IEntity { //… }
It seems you’re generating the parameter expression twice, in VisitMember() here: var converted = Expression.MakeMemberAccess( base.Visit(node.Expression), activeRecordType.GetProperty(node.Member.Name)); …since base.Visit() will end up in VisitParameter I imagine, and in GetMany() itself: var lambda = Expression.Lambda<Func<ActiveRecord.Widget, bool>>( visitor.Visit(predicate.Body), predicate.Parameters.Select(p => visitor.Visit(p)); If you’re using a ParameterExpression in the body, it has to be the same instance (not … Read more
I continued work on the library that was mentioned by Serializing and Deserializing Expression Trees in C# It looks like the project was abandoned (2008) but I did some work on it and now it works with .NET 4.0 and Silverlight. I made bug fixes to their code and also made it more DAL-independent. http://expressiontree.codeplex.com/
We did something similar (not 100% the same, but similar) in a LINQ to SQL project. Here’s the code: public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values) { var type = typeof(T); var property = type.GetProperty(ordering); var parameter = Expression.Parameter(type, “p”); var propertyAccess = Expression.MakeMemberAccess(parameter, property); var orderByExp = Expression.Lambda(propertyAccess, parameter); MethodCallExpression … Read more
This can be done, as mentioned, with the help of Reflection Emit and a helper class I’ve included below. The code below is a work in progress, so take it for what it’s worth… ‘it works on my box’. The SelectDynamic method class should be tossed in a static extension method class. As expected, you … Read more