C# style: Lambdas, _ => or x =>?

Question

I've used lambda expressions in other languages before using them in C#, and so I got in the habit of using _ for simple lambdas in the form of Func<T, TResult>, especially for simple lambdas where the body is just an expression representing the return value (predicates, etc..). However, in C# I often see single letters being used instead of _ for these same sorts of lambda expressions, such as x,y,z,i,j,k. The letter approach seems odd to me since those letters already have another typical meaning in common usage, for loop variables. _ is often easier to read in my opinion. Is the single letter style really the established style for lambdas in C#?

Examples:

what I'm used to writing:

var ages = people.Select(_ => _.Age);

What I'm seeing being written instead:

var ages = people.Select(x => x.Age); // choice of 'x' is not consistent

Answer 1

Many C# developers use _ to indicate that the parameter isn't going to be used and a letter or other short name when the parameter is being used.

Other resources:

• Interesting discussion on using _ instead of ()

Answer 2

It's a variable name, so I'd go with the idea that the name should convey information that it needs to convey. What information does _ convey?

To that same end, what information does x convey?

I might write your example as this:

var ages = people.Select(p => p.Age);

The idea is that I feel that the p at least suggests in the context of the entire statement that it's a people record. You could take it even further:

var ages = people.Select(person => person.Age);

Now that conveys to the reader what that variable actually is. Of course, for such a small statement, an argument can be made that it's overkill. I don't think so, but it's a matter of preference. (And not just your preference, but the preference of anybody who has to support this code.)

For significantly larger, multi-line, complex lambda expressions, the name becomes even more important. The further away one is from the context of what the variable means, the more the name of the variable needs to carry that context with it.

Answer 3

How is a lambda function so different from any other method. If someone were to post code with a method such as:

public static int getAge(Person _)
{
  return _.Age;
}

or

public static int getAge(Person x)
{
  return x.Age;
}

What would you say?

In my opinion choosing the name of a parameter for a lambda should be just as meaningful as the parameter of any other method. I might make occasional exceptions for an identity function x => x because in that case the variable doesn't need to mean anything, it really can be anything, but using an underscore or a single letter for everything in my mind just makes the code that much less readable. (So many people tout the advantages of LINQ/Lambdas as being readability, which is defeated if you obfuscate all variables.)

Answer 4

Or you could use a meaningful name, e.g.

var ages = people.Select(person => person.Age);

Answer 5

In C#, _ is used for class(attribute) variables and _ is not used for local variables. So it is good to use meaningful name for local variables and class variable.

Ex:

var personList = (from person in people  where person.Age > 18  select person).ToList();

Answer 6

There is no 'established' style for naming your lambda variables. However, an underscore typically means some kind of instance member variable, which means your style might conflict with other naming standards compared to a normal variable name.

Long Story Short - Do what works for you.

Answer 7

There's a reason why you can give it a name -- because sometimes you can have multiple inputs and need to differentiate them:

Func<int,int,int> product = (num1, num2) => (num1 * num2);  // takes in two ints, and returns one int
int x = product(2, 3);