Speed of Lambda

Jean Paul

The text of this article is not in this database — only its details are. The old site it was published on is gone, but the Internet Archive kept a copy: Speed of Lambda

C#Lambda ExpressionsSpeed Difference Lambda expressions

12 Comments

Join the conversation! Your thoughts help the community grow.

Tahir Akram7y ago
Where is the source of test application?
Jean Paul14y ago
Thank You Lajapathy!
Lajapathy Arun14y ago
Thanks friend :)
Jean Paul14y ago
Thank You Tim!
Tim Yang14y ago
Study.Very useful.
Stefan Noack16y agoedited
At least for the first case. Reflector reveals the following implementation of Enumerable.Sum in .NET Framework: public static decimal Sum(this IEnumerable<decimal> source) { if (source == null) { throw Error.ArgumentNull("source"); } decimal num = 0M; foreach (decimal num2 in source) { num += num2; } return num; } I suspect that you ran debug code where nop instructions are inserted between your code lines for the debugger to create breakpoints. I guess there would be no differences if you'd make a realease build with optimizations enabled. The second example is, however, correct. But the used "custom" implementation is of course the least efficient way to solve the problem. Implementing something as fast as the linq expression would take some more code, though. So linq here is really superior. also in the first case i'd prefer linq even if it was slower.
- Jean Paul16y ago
  Hello Stefan, I appreciate your attempt to check the code with Reflector. Although reflector is showing the same kind of code for iterating and finding the sum, the underlying instance of classes in both the cases will be different. I mean the List and LambdaSum implementation class which is passes as IEnumerable interafce to the Sum extension method in Enumerable. So the List would be slower comparing with Lambda class, but as they both support IEnumerable - the Sum method would look the same. Regards, Jean Paul
- Stefan Noack16y ago
  Hello Jean, I am sorry to say that what you say is plain wrong. It looks like you have not understood the concept of Extension methods. When you call "list.Sum()" in your code, the list is just passed as a parameter to a static function that contains just a plain 'for each' loop summing the elements up. There is no such thing as a LambdaSum (Lamda expressions are not even involved here, the extension methods on IEnumerable are part of LINQ, which in more complex scenatios, allows the use of lambda expressions, which are just inline functions--those are not used for Sum in your example, though). Also, i cannot think of any faster method to sum up arbitrary numbers. You can't get better than the performance of one (in numbers: 1) arithmetic operation per element, can you? To check my hypothesis I ran your code in a _release_ configuration with >>optimizations enabled<< and what would you expect? As soon as you take the debugger away from the custom implementation it is exactly as fast as the built-in (who would have thought? it's the same code after all!) The difference you saw was because the debugger does not prepare to halt in system library functions--therefore these seemed to operate faster. With optimizations enabled, the custom loop is even a tiny bit faster because you save one method call, but the difference is neglectible. You really should try this. Go to the project property pages, select the "Build" tab, change the configuration to "Release" and make sure "Optimize code" is enabled. That's what they do for system libraries, too. Best Regards, Stefan
Mahesh Chand16y ago
I am impressed with the results. I did not think the difference will be this big. Thank you for sharing this. Great job! Best, Mahesh
james.curran16y ago
I apologize if this is a duplicate (the website seems to drop pending comments when you log in) You should try using a HashSet in GetDistinctSum_WithoutLambda. It really designed for doing that. In fact, you could get much better time, by combining the two loops: private decimal GetDistinctSum_WithoutLambda() { var distinctList = new HashSet<decimal>(); decimal sum = 0; foreach (decimal number in list2) if (!distinctList.Contains(number)) { distinctList.Add(number); sum += number; } return sum; } That shoudl bring you closer to the LINQ functions, since that's largely the way they do it.
- Jean Paul16y ago
  Yes.. That's true. Using HashSet instead of List we can achieve same results like Lambda. Thank You for sharing.
- Andrey Dubina7y ago
  Private decimal GetDistinctSum_WithoutLambda(){ var distinctList = new HashSet<decimal>(); decimal sum = 0; foreach (decimal number in list2) if (distinctList.Add(number)) { sum += number; } return sum; }