Local function vs Lambda C# 7.0

by

This was explained by Mads Torgersen in C# Design Meeting Notes where local functions were first discussed:

You want a helper function. You are only using it from within a single function, and it likely uses variables and type parameters that are in scope in that containing function. On the other hand, unlike a lambda you don’t need it as a first class object, so you don’t care to give it a delegate type and allocate an actual delegate object. Also you may want it to be recursive or generic, or to implement it as an iterator.

To expand on it some more, the advantages are:

  1. Performance.

    When creating a lambda, a delegate has to be created, which is an unnecessary allocation in this case. Local functions are really just functions, no delegates are necessary.

    Also, local functions are more efficient with capturing local variables: lambdas usually capture variables into a class, while local functions can use a struct (passed using ref), which again avoids an allocation.

    This also means calling local functions is cheaper and they can be inlined, possibly increasing performance even further.

  2. Local functions can be recursive.

    Lambdas can be recursive too, but it requires awkward code, where you first assign null to a delegate variable and then the lambda. Local functions can naturally be recursive (including mutually recursive).

  3. Local functions can be generic.

    Lambdas cannot be generic, since they have to be assigned to a variable with a concrete type (that type can use generic variables from the outer scope, but that’s not the same thing).

  4. Local functions can be implemented as an iterator.

    Lambdas cannot use the yield return (and yield break) keyword to implement IEnumerable<T>-returning function. Local functions can.

  5. Local functions look better.

    This is not mentioned in the above quote and might be just my personal bias, but I think that normal function syntax looks better than assigning a lambda to a delegate variable. Local functions are also more succinct.

    Compare:

    int add(int x, int y) => x + y;
Func<int, int, int> add = (x, y) => x + y;

More Related Contents:

  1. How can I do an average reverse in c#? [closed]
  2. How to LINQ List and flatten it using SelectMany?
  3. What’s wrong with my function? C# [closed]
  4. Retrieving Property name from lambda expression
  5. Combining two expressions (Expression)
  6. Distinct() with lambda?
  7. How to convert a String to its equivalent LINQ Expression Tree?
  8. How do I round to the nearest 0.5?
  9. How can I get every nth item from a List?
  10. converting a .net Func to a .net Expression
  11. What is the difference between “x is null” and “x == null”?
  12. C# Store functions in a Dictionary
  13. Combining two lambda expressions in c#
  14. Lambda expression not returning expected MemberInfo
  15. Pass expression parameter as argument to another expression
  16. Expression.Lambda and query generation at runtime, simplest “Where” example
  17. _=> what does this underscore mean in Lambda expressions?
  18. Why can’t c# use inline anonymous lambdas or delegates? [duplicate]
  19. Call C++ library in C# [closed]
  20. LINQ identity function
  21. LINQ Expression to return Property value?
  22. Does C# 7.0 work for .NET 4.5?
  23. C#: Getting Names of properties in a chain from lambda expression
  24. C# lambda, local variable value not taken when you think?
  25. Max return value if empty query
  26. Group by with multiple columns using lambda
  27. Expression for Type members results in different Expressions (MemberExpression, UnaryExpression)
  28. Get the calling function name from the called function [duplicate]
  29. How do I translate an expression tree of one type to a different expression type?
  30. Convert DataTable to Generic List in C#

Leave a Comment