[Discussion] Really interesting project

[dadhi]

Hi @mgernand @seesharper,

Really interesting project as it tries to cover most of the expressions.

I am doing something like this myself for DryIoc project but with limited number of expressions, so decided to looked here to find if I can steal something :-)

Couple of questions (maybe obvious ones):

• How is the library compared to Expression.Compile(preferInterpretation: true)
• There is the statement about it being slow. Did you measure it and consider the ways to speed-up?

Btw. Maybe it makes sense to enable Discussions section in the repo to avoid polluting the issues. Fill free to move my issue there if/when enabled.

[mgernand]

Hi @dadhi,

the library was first created in 2014 to kind of support something like Expression.Compile() in Xamarin.iOS projects. Back then the preferInterpretation did not exist in Portable Library stuff.. It would be nice to compare the performance ExpressionReflect and Expression.Compile(preferInterpretation: true).

The statement about it beeing slow refers to the heavy use of reflection. Your interest in this library made myself curious how it performs compared to other approches. I will create a little benchmark to see whats going on.

Thank you for reaching out.

[mgernand]

As expected the Reflect is by far the slowest approach. This benchmark was a simple execution of a getter property.

Method	Mean	Error	StdDev	Rank	Gen 0	Allocated
GetPropertyValue_Compile	1.111 ns	0.0513 ns	0.0591 ns	1	-	-
GetPropertyValue_Compile_PreferInterpretation	75.320 ns	1.5276 ns	2.2864 ns	2	0.0362	152 B
GetPropertyValue_ExpressionReflect	281.360 ns	4.8041 ns	4.2587 ns	3	0.1297	544 B

There is obviously much room for performance improvements. :-D

[dadhi]

Yep. Thanks for checking. I think to get the general idea about target performance you may compare a bare reflection call to get the property. The difference between it and the Reflect is the cost of the library abstraction, which need to be cut to get this perf.

Besides, in principle there are ways to improve the perf beyond the reflection, e.g. often user may know the parts of the expression, so it possible to recognize those parts while traversing the expression and call those known methods and properties directly. It may be configured in the Reflect via rules set by user.

There are may be some caching or sub-result memoization approaches as well.

I mean, the interpretation is indeed slower than compiled invocation but is not necessary too slow. Especially taken into account the cast of the compilation itself when starting up.