WTF Is a Lambda?
Tags: csharp
Published: 2019-03-07 14:01:07

---
title: "WTF Is a Lambda?"
published: true
description: When you first see a Lambda you might be left scratching your head, wondering what on earth that funky syntax is all about?!
tags: csharp
canonical_url: https://jonhilton.net/2019/01/30/wtf-is-a-lambda/
cover_image: https://jonhilton.net//img/WTF-lambda.png
---
If you're just learning C# you've probably come across something like this and wondered what the weird `x=>x` is all about...

``` csharp
things.SingleOrDefault(x=>x.Name == "Bob");
```

 To understand what's going on, let's explore a specific example.

Let's say you have a collection of People. 

Here's a class to represent a Person...

``` csharp
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
```

Then somewhere in your application, a list of people like this...

``` csharp
private List<Person> People = new List<Person>
{
    new Person { Name = "Bob", Age = 37 },
    new Person { Name = "Brian", Age = 21 },
    new Person { Name = "Amy", Age = 58 }
};
```

Three people in a list. Each object in the list is an instance of our
`Person` class.

Now say you want to find the record for "Amy" and display her age.

You could do this manually by looping through each person until you find
the relevant one...

``` csharp
public void Exists()
{
    Person result = null;

    foreach (var person in People)
    {
        if (person.Name == "Amy")
        {
            result = person;
            break;
        }
    }

    if (result != null)
        Console.WriteLine("we found Amy!, she's " + result.Age);
}
```

Result will be the instance of "Person" for Amy and we can write her age to
the console.

Alternatively, rather than typing out endless loops yourself, you can use
some methods built in to C# lists to save yourself a few keystrokes.

``` csharp
public void Exists()
{
    var amy = People.SingleOrDefault(IsAmy);
}
```
Under the covers, this will loop through the "People" list, and for each
one it will call `IsAmy` to determine whether this is the person we want.

What does `IsAmy` look like I hear you ask.

``` csharp
private bool IsAmy(Person arg)
{
    return arg.Name == "Amy";
}
```

`SingleOrDefault` expects a function, which takes a `Person` and returns a `bool`.

In here we can put whatever logic we want.

If `IsAmy` returns `true`, then we're saying this instance of `Person` is the
one we want. If we return `false` we're saying it isn't.

We can "inline" our `IsAmy` function (to save declaring it separately) like
so...

``` csharp
public void Exists()
{
    var amy = People.SingleOrDefault((Person person) => 
                                        { return person.Name == "Amy" });
}
```

This is exactly the same as the last example, except instead of declaring a
separate function we're declaring it "inline".

You can see we're still taking in a `Person` argument, then returning a
`true` or `false` (true if "Amy", false if not).

Finally, to make this more concise, we can simplify to this...

``` csharp
public void Exists()
{
    var amy = People.SingleOrDefault(person => person.Name == "Amy");
}
```

This is another way of declaring the same thing.

Here, we are still taking the `Person`, applying our condition to it and
returning the result (true or false) but with less keystrokes!

So the left side of the => is the argument (`Person`), the right side is the
expression which returns a boolean.

Essentially lambdas are really just syntactic sugar and a shorthand way of
declaring a function.

You'll see them used a lot with lists/other collections and therefore in
relation to database queries etc.