Comments on: Linq Expressions – From and to delegates

By: mbarbac

mbarbac — Tue, 20 Apr 2010 19:35:04 +0000

@Keith:
Thanks.
And agree! The CLR/DLR should provide a full-powered conversion utility. But since it happens, at least we have the solution I present in the article that is usefull for LINQ-like scenarios, and maybe others.

By: Keith J. Farmer

Keith J. Farmer — Tue, 20 Apr 2010 07:04:39 +0000

@mbarbac –

Indeed, note my comments from 3 Feb…

And boy is it a pain in the butt. I’d rather they just allow us to create Expression (which was my motivation). I can come up with reasons why they can’t, but I don’t have to like the situation.

Congratulations on actually writing an article about it. :)

By: mbarbac

mbarbac — Mon, 19 Apr 2010 19:39:38 +0000

Yes, it can be done. There is a way to convert a delegate into an expression tree, by means of using the power of C# 4.0 dynamic capabilities to intercept in real-time the dispatch of the calls, and tracking them.
I posted an article at this regards at: http://www.codeproject.com/KB/dotnet/delegates_into_expression.aspx
Cheers, M

By: Keith J. Farmer

Keith J. Farmer — Thu, 01 Apr 2010 18:37:17 +0000

@Roger:

“Writing a decompiler is a bit too drastic to most of us.”

Drastic, perhaps, but that’s precisely what happenned immediately after PDC05, if you were hanging out on the LINQ Forums. (I forget whether you were or not.) :)

Personally, I would rather just have everything as an expression tree that were invocable. Not difficult. Can be done in a couple lines of code. Would be nice if it (like many things) were OOB.

By: Roger Alsing

Roger Alsing — Thu, 01 Apr 2010 11:57:11 +0000

@Onur Gamus

From the site you linked:
“”" There’s no builtin feature to do that, it’s not a straightforward process. You basically have to decompile the compiled method. “”"”

Writing a decompiler is a bit too drastic to most of us.
Just as splitting atoms is ;-)

By: Onur Gumus

Onur Gumus — Thu, 01 Apr 2010 09:01:58 +0000

“This is not really possible, you can never cast or convert an existing delegate into an expression tree.” Yeah and atoms weren’t splittable ya remember ? Then check this :

http://evain.net/blog/articles/2009/04/22/converting-delegates-to-expression-trees

By: Keith Farmer

Keith Farmer — Wed, 03 Feb 2010 21:17:34 +0000

Of course, you could use pass dynamic objects through a delegate and record what calls are made, and try to make some sense out of that. It works (I’ve done so). But it’s ugly.

By: Brad Stitt

Brad Stitt — Wed, 03 Feb 2010 20:00:33 +0000

I use this for error logging which uses the logic previously posted. this creates a string representation of the method with parameter values.

example usage: ToString(() => somemethod(someparameter));

string ToString(Expression action)
{
MethodCallExpression call = action.Body as MethodCallExpression;
if (call == null) throw new ArgumentException();

StringBuilder message = new StringBuilder(call.Method.Name + “(“);

foreach (MemberExpression member in call.Arguments)
{
object paramvalue = (member.Expression as ConstantExpression).Value;
FieldInfo field = paramvalue.GetType().GetField(member.Member.Name);

object actualvalue = field.GetValue(paramvalue);
if (actualvalue is string)
{
actualvalue = “\”" + actualvalue + “\”";
}

message.Append(“(” + field.FieldType.ToString() + “) ” + field.Name + ” = ” + actualvalue.ToString() + “, “);
}

message.Remove(message.Length – 2, 2);
message.Append(“)”);

return message.ToString();
}

By: Brad Stitt

Brad Stitt — Wed, 03 Feb 2010 19:54:40 +0000

Func methoddelegate = this.testmethod;
Expression action = () => methoddelegate(“1″, 2, new TestClass());
MethodCallExpression method = action.Body as MethodCallExpression;

reposted to fix invalid characters

By: Brad Stitt

Brad Stitt — Wed, 03 Feb 2010 19:52:29 +0000

Here is a quick thought:
Func methoddelegate = this.testmethod;
Expression action = () => methoddelegate(“1″, 2, new TestClass());
MethodCallExpression method = action.Body as MethodCallExpression;

based on what I know you can’t get an expression tree from a delegate because it isn’t an actual method call, it is just a definition. A similar situation would be to try and get the expression tree of an object, ex: Thread.