I’ve created an article that builds on the ideas presented in this blog entry: http://www.codeproject.com/KB/recipes/LinqExpressionAccessors.aspx

I solved the issues of not being able to *set* a private member’s value, and also cases where you need to set a value type’s (struct) private member. Since you have to pass the value-type instance as a parameter (which then becomes a copy itself), you have to create a lambda which takes the ‘this’ by-ref. Since you can’t do that out of the box with the Func delegate, I created a specialized delegate for such accessor cases.

Thanks!

I would like to know how to call an Expression on a ParameterExpression. I generated a GroupBy Expression thru this code,

>>
public IQueryable GenerateGroupByExpression(string groupByName) {
ParameterExpression paramExpression = Expression.Parameter(SourceType, SourceType.Name);
MemberExpression memExp = Expression.PropertyOrField(paramExpression, groupByName);
LambdaExpression lambda = Expression.Lambda(memExp, paramExpression);
//.GroupBy()
var groupedSource = this.Source.Provider.CreateQuery(Expression.Call(
typeof(Queryable),
“GroupBy”,
new Type[] {
SourceType,
SourceType.GetProperty(groupByName).PropertyType
},
Source.Expression,
lambda
)
);
//.Select()
ParameterExpression groupparamExpression = Expression.Parameter(groupedSource.ElementType, “g”);
List bindings = new List();
bindings.Add(Expression.Bind(typeof(GroupContext).GetMember(“Key”)[0], Expression.PropertyOrField(groupparamExpression, “Key”)));
bindings.Add(Expression.Bind(typeof(GroupContext).GetMember(“Count”)[0], Expression.Call(typeof(Queryable),
“Count”,
new Type[] { groupedSource.ElementType },
new Expression[] { groupedSource.Expression })));
bindings.Add(Expression.Bind(typeof(GroupContext).GetMember(“Details”)[0], groupparamExpression));
Expression e = Expression.MemberInit(Expression.New(typeof(GroupContext)), bindings.ToArray());
//g=>prop.Propertyname
LambdaExpression selectLambda = Expression.Lambda(e, groupparamExpression);
return groupedSource.Provider.CreateQuery(Expression.Call(
typeof(Queryable),
“Select”,
new Type[] { groupedSource.ElementType, typeof(GroupContext) },
new Expression[] { groupedSource.Expression, selectLambda }
));
}

>>

I have a GroupContext class with Key, Count and Details as parameters in it. Let me know your thoughts on this Dynamic query.

-Fahad

I think I might have been a bit too fast on that conclusion.

Calling set properties is possible since you can make method calls and setters are simply a void method in IL.

But apparently its not possible to assign field values through expressions.

So my bad on that one. :-/
I did know that you cant use assignments in expressions in normal code, so I should have figured out that its not possible when building expressions either…
*equips donkey ears*

Also: if the main objective is speed (rather than “private”), then another viable alternative [property based] is HyperDescriptor; fundamentally the same concept, but uses Reflection.Emit [it predates 3.5]; but has the advantage that it can “set”, and doesn’t need any special coding (in fact, the caller doesn’t even know you’ve switched to a faster implementation, as long as they are using PropertyDescriptor to start with):

http://www.codeproject.com/KB/cs/HyperPropertyDescriptor.aspx

Well I guess you could simply use reflection to find the field names, and then use those names to create your fieldAccessors and store the fieldaccessors in a dictionary.

that way, you would only need to fetch the field names once per type and then you can use the fieldAccessors every time you need to read/write data.

(ok I didnt provide a sample on how to write data, but thats doable in the same way, you just need to alter the lambda generator slightly)

So if you intend to read a single field once, then reflection will be better.

But for any scenario where you are likely to access the same field on different objects, then the lambda approach is much better.
In such case you will most likely have to cache the field accessor in a dictionary or some other lookup structure.