What is the recommended way of writing anonymous functions in C#?

Question

var seq = Enumerable.Range(1, 10).Reverse();
var sort1 = seq.OrderBy(i => i);
var sort2 = seq.OrderBy(delegate(int i) { return i; });

i think sort2 is more explicit but sort 1 is shorter. besides that, i don't really know the difference. what is the recommended way of doing this?

Answer 1

I much prefer the lambda syntax (sort1) where possible. I only use the more verbose syntaxes where they are required. I consider the extra stuff non-productive code that just gets in the way of understanding what I'm writing.

Edit: Unless of course I'm working on a .NET 2.0 app, where you can't use the lambda syntax. Then, I'm just glad I at least have anonymous methods.

Answer 2

Lambda expressions are (IMO) better than anonymous methods in every case except where you don't care about the parameters, in which case there's a nice shortcut:

// Lambda expression has to specify parameter types
EventHandler x = (sender, args) => Console.WriteLine("Hi");

// Anonymous method can ignore them
EventHandler x = delegate { Console.WriteLine("Hi"); };

Lambda expressions have two other "problems" IMO:

• Obviously they're not available if you're not using C# 3. (Although you can target .NET 2.0 from VS2008 and still use them.)

• The syntax for a parameterless lambda expresssion is somewhat clunky:

  () => stuff
  

Answer 3

As far as I know both approaches will generate the exact same IL code (at least in this example), so it's really a matter of taste. I often think lambda tastes nicer.

Answer 4

I find this depends on the scenario as the important aspect is making sure the intent of your code is well documented for future maintainers. Therefore, sometimes a lambda works best, but other times an anonymous method is a better option. The problem with lambdas where more than argument is needed, is that the syntax starts to look cluttered, so it can sometimes be useful to use the anonymous method delegate syntax to provide a more recognisable structure.

In the example you have given, the lambda is the better option as it is clear and concise; however, when declaring say an inline event handler, an anonymous method might provide a better solution (with regards to maintainability).

Answer 5

sort1 - Lambdas I think is the prefered way to write Anonymous methods

Answer 6

There are few (and I can only think of one off the top) where I like the delegate syntax over the lambda expression ...

public event Action Evt = delegate {};
public event Action Evt = () => { };

... for example. The rest of the time, delegate just gets in the way. Per Jon's comment ...

public event EventHandler Evt = delegate {};
public event EventHandler Evt = (s,ea) => { };

Answer 7

I prefer lambda-expressions since they offer the the most concise syntax and resemble the lambdas in functional programming languages where this construct originally comes from. When the expression contains more than one statement or unfunctional constructs, I'll use delegate. Parameterless, multi-lined or explicitly typed lambda expressions may look somewhat weird and hence lose their major advantage (being more readable).

g = (x => 2 * f(x) + 1); // Nice functional one-liner

// but

action = delegate (int arg) {
    SendSystemMessage(arg);
    Console.WriteLine("Got value: {0}", arg);
};