{"id":1066,"date":"2010-10-11T08:42:09","date_gmt":"2010-10-11T07:42:09","guid":{"rendered":"http:\/\/www.minddriven.de\/?p=1066"},"modified":"2010-10-11T08:42:09","modified_gmt":"2010-10-11T07:42:09","slug":"efficient-expression-values","status":"publish","type":"post","link":"https:\/\/www.minddriven.de\/index.php\/technology\/dot-net\/c-sharp\/efficient-expression-values","title":{"rendered":"C#: Efficient retrieval of Expression values"},"content":{"rendered":"

Some days ago I’ve had an interesting technical discussion with a colleague of mine regarding the possibility of implementing Guard classes with Expressions in C#<\/strong>. Such a class enables easy argument checking in form of (technical) preconditions<\/em> on method entry. Thereby the checking logic is encapsulated in the Guard class<\/a>.<\/p>\n

One method of such a Guard<\/code> class could be AssertNotNull()<\/code> which checks, if a given method argument equals null<\/code> and if true throws an ArgumentNullException<\/code>. By the use of Expressions the parameter to check can be given to AssertNotNull()<\/code> in a very elegant way:<\/p>\n

public void MyMethod(SomeType elem)\r\n{\r\n    Guard.AssertNotNull(() => elem);\r\n\r\n    \/\/ actual method logic\r\n}<\/pre>\n
Through evaluation of the Expression<\/code> the AssertNotNull()<\/code> method is able to extract both the name and value of the argument<\/strong>. Thus there’s no necessity to provide both as parameters to AssertNotNull()<\/code>. Moreover you do not need to provide the argument name as string<\/code>.<\/p>\n
Value by compilation<\/h3>\n
It’s very easy to extract the argument value through compilation and invocation<\/strong> of the Expression<\/code>. Hence this solution is often taken by developers who work with Expressions in this way. The following snippet shows this implementation:<\/p>\n
public static class Guard\r\n{\r\n    public static void AssertNotNull<T>(Expression<Func<T>> selector)\r\n    {\r\n        T value = selector.Compile().Invoke();\r\n        if (value == null)\r\n        {\r\n            string name = ((MemberExpression)selector.Body).Member.Name;\r\n            throw new ArgumentNullException(name);\r\n        }\r\n    }\r\n}<\/pre>\n
Value by evaluation<\/h3>\n
In the conversation with my colleague we caught the point that the extraction of the argument value from an Expression<\/code> is even possible without performing the costly compilation<\/strong>. This is enabled by converting the Expression<\/code> into a ConstantExpression<\/code>, from which we can catch the value by executing GetValue()<\/code> on a FieldInfo<\/code> instance:<\/p>\n
public static class Guard\r\n{\r\n    public static void AssertNotNull<T>(Expression<Func<T>> selector)\r\n    {\r\n        var memberSelector = (MemberExpression)selector.Body;\r\n        var constantSelector = (ConstantExpression)memberSelector.Expression;\r\n        object value = ((FieldInfo)memberSelector.Member)\r\n            .GetValue(constantSelector.Value);\r\n\r\n        if (value == null)\r\n        {\r\n            string name = ((MemberExpression)selector.Body).Member.Name;\r\n            throw new ArgumentNullException(name);\r\n        }\r\n    }\r\n}<\/pre>\n
This doesn’t look very spectacular on first sight. The code is more complicated and it’s necessary to provide a variable in the Expression<\/code>. Properties and data hierarchies don’t work with this solution, but this shouldn’t be a problem when checking argument values against null<\/code>. Of course with a more sophisticated solution (iterative\/recursive evaluation of the Expression<\/code> tree) you can enable such scenarios, but this is out of scope of this blog post…<\/p>\n
Looking at the execution times<\/h3>\n
So what’s the point of the second solution? It’s simple: compilation is much more time-intensive<\/strong>! In a little runtime test I’ve compared both solutions. A call of AssertNotNull()<\/code> with a valid argument (!= null<\/code>) over 10.000 iterations resulted in the following execution times:<\/p>\n
\"\"<\/p>\n
Please note the immensive time difference! The compiled solution takes more than 53 seconds<\/strong>, while the evaluation takes less than 0,35 seconds<\/strong>. This makes a time factor of more than 156<\/strong>, by which the evaluated solution is faster than the compiled approach.<\/p>\n
Conclusion<\/h3>\n
When handling with Expressions you should take the execution time into account! Once a method is executed inside of a loop and you follow defensive programming and check method parameters at every place, an argument check can become an important time factor. When possible you should favor evaluation over compilation<\/strong> of Expressions.<\/p>\n
\"kick<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Some days ago I’ve had an interesting technical discussion with a colleague of mine regarding the possibility of implementing Guard classes with Expressions in C#. Such a class enables easy argument checking in form of (technical) preconditions on method entry. Thereby the checking logic is encapsulated in the Guard class. One method of such a … C#: Efficient retrieval of Expression values<\/span> weiterlesen<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[310,279,177,281,280],"class_list":["post-1066","post","type-post","status-publish","format-standard","hentry","category-c-sharp","tag-c-sharp","tag-compile","tag-expressions","tag-getvalue","tag-invoke"],"_links":{"self":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/1066","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/comments?post=1066"}],"version-history":[{"count":8,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/1066\/revisions"}],"predecessor-version":[{"id":1076,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/1066\/revisions\/1076"}],"wp:attachment":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/media?parent=1066"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/categories?post=1066"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/tags?post=1066"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}