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
The / division operator works differently in C# and VB. In C# it adapts to the data types used, while VB always converts the operands to floating point values: () => 1 / 2 becomes Expression.Divide(1, 2) Function() 1 / 2 becomes Expression.Divide(Expression.Convert(1, Double), Expression.Convert(2, Double)) In VB you would need to use the \ … Read more
Consider the following: static int M() { Console.Write(“M”); return 1; } static int N() { Console.Write(“N”); return 2; } static int Q(int m, int n) { return m + n; } … Func<int> f = ()=>Q(n : N(), m: M()); Expression<Func<int>> x = ()=>Q(n : N(), m: M()); Func<int> fx = x.Compile(); Console.WriteLine(f()); Console.WriteLine(fx()); You … Read more
You must assign the lambda to a different type: // Gives you a delegate: Func<int, int> f = x => x * 2; // Gives you an expression tree: Expression<Func<int, int>> g = x => x * 2; The same goes for method arguments. However, once you’ve assigned such a lambda expression to a Func<> … Read more
You can create an expression tree that represents a dynamic C# addition expression by passing the CallSiteBinder for a dynamic C# addition expression into Expression.Dynamic. You can discover the code to create the Binder by running Reflector on the original dynamic expression. Your example would go something like this: var x = Expression.Parameter(typeof(object), “x”); var … Read more
As indicated in the other answer, you have two expressions where both have a parameter named y. Those don’t automatically relate to each other. To properly compile your expression, you need to specify both source expression’s parameters: Expression<Func<string, bool>> e1 = (y => y.Length > 0); Expression<Func<string, bool>> e2 = (y => y.Length < 5); … 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
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
Do you mean: static LambdaExpression CreateExpression(Type type, string propertyName) { var param = Expression.Parameter(type, “x”); Expression body = param; foreach (var member in propertyName.Split(‘.’)) { body = Expression.PropertyOrField(body, member); } return Expression.Lambda(body, param); } For example: class Foo { public Bar myBar { get; set; } } class Bar { public string name { get; … 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