Hi. Today we're going to think about LINQ, which is something that is integral to the Lambda story. Lambdas are small chunks of code that, that are reduced down to the smallest amount possible to actually cleanly define something.

And so, we've got a bit of a voyage of discovery in this session because things might get a little bit deep. If you remember from the previous session, we were looking at methods that were extension methods added to collections, allowing you to filter and sort things.

And in the code that we're looking at here, we've got that self same code as we, kind of, left it previously. There's our numbers collection, we call that the extension where method, and we've passed to it the name of a function.

So, the important observation here is that you-, when you pass parameters, they don't just have to be bits of data, they can be the names of methods. So, we're calling the isItemBiggerThan10 and if you remember down here, all that does is compare the integer passed into it to see if it is bigger than ten, and returns therefore true or false.

Therefore, this collection here will only contain the values that satisfy that condition, and will therefore only contain numbers bigger than ten. And to prove that, we for-each around that resultant set, printing out every value that we find. We've seen that code before, we need to press on into the land of Lambda, and we'll do that in a couple of steps.

The first really interesting observation is you don't have to have a named method that you call. You can have what's called an anonymous method.

You can actually do the show right here rather than calling a method elsewhere, and that's what's happening in this next piece of code. You can see that we've got the same, kind of, starting premise, where we've got our collection of numbers with our where clause, but then rather than calling a separate method, we've got a chunk of code that looks a little bit cryptic. We've declared something as being a delegate.

Don't get too phased by this, a delegate is effectively a pointer to a function, rather than a pointer to a piece of data. Functions live in memory, the same way as data lives in memory, but our functions take parameters. And so, when we declare a delegate, we have to specify the parameters it's going to receive and what kinds of parameter those are.

So, in this case, we know we're dealing with an integer, which we're calling N. Then, in these curly brackets, we are doing our standard comparison, is N bigger than ten, and returning our Boolean value, true or false.

So, it's doing exactly the same thing as it did before, but we're not calling a named function. The function is anonymous and it's, kind of, in, in line with the, the Where clause. We tack a to list onto the end because, if you remember from before, we had to do that because we've gotta convert the result set to a list, so that we can iterate around it. And that's what's going on here.

If I run this code to that break point, we can see the output, and we should see that things tie up as I've said. And you can see the output is the same as the previous output, so it's doing exactly the same thing, but we've got an anonymous function.

Now, Lambdas are basically anonymous functions, but we throw away any unnecessary detail. Lambdas are mathematically things that are super concise, there's no repetition, there's no duplication, there's no unnecessary information in there. And so, we've reduced this code here down to this, alright?

And when we think about it, we're getting the same thing. We know that this is a collection of integers, so we don't need to declare the word int up here, we can just declare the name we're gonna give the variable.

We're gonna call it N. It's bound to be an integer because this is a collection of integers. We don't need the word delegate because we've got an-, we've got something in round brackets which is an inline function. We've got this little symbol here, and it looks like equals greater than, but actually it's meant to look like an arrowhead. And I use the notation goes to when I see this symbol, or this pair of symbols.

So, N goes to this function on the right-hand side. Now, when we're using Lambdas, we are restricted to a single line of code, so we can't do multiple lines of code in this kind of notation, but we could fall back on the previous notation should we need multiple lines of code.

But we've reduced this further. We don't need a returns statement because we know the Where clause needs something returned back to it, a true to indicate whether it's happy with the data or not. We don't need a semicolon because what do you need semicolons for? They're pointless.

So, we reduce this to its barest, barest minimum, which is basically take each value in the collection, which has to be an integer, and compare it with ten. Return true if it's bigger than ten, return false if it's equal to or less than ten, and convert that whole chunk to a list.

So, this looks a bit weird when you first see it but, actually, it's very readable and, and actually far more readable than, than this, I think, on the grounds that we've got rid of all the baggage that clutters things up, and we have a very clean piece of code. If I was to run down to another break point, we can see the output will be the same as the previous two runs. And there we have it, exactly the same output again, so exactly the same behaviour.

There's another notation that you can use, which isn't strictly Lambda. I mean, this is Lambda. This is what's called LINQ using query notation, as opposed to LINQ using what, what is known as method notation up here.

And Microsoft have done this because they want to be able to write queries that are very similar to SQL queries for relational databases. You might recognise some of these words from an SQL query, if you've ever done any SQL. The key word 'select', the word 'from', the word 'where', very SQL.

And so, what we've got in this chunk of code is effectively an SQL select statement turned on its head. Rather than starting with the word 'select', we end with the word 'select'. And we've got a, a-, a 'from' clause at the top to indicate that we are iterating around a collection one item at a time, and we've got a comparison in the middle where we are comparing i with ten, to make sure that, you know, this particular item in, in a collection is bigger than ten.

So, these things read and, and work in exactly the same way as Lambda expressions, they're just notated slightly differently. So, we always start a, a-, in query notation with the word from, we declare our variable, we can call it anything we like, we've called it i in this example. We use the word in, and then we specify the collection that we are interrogating, and the collection we're interrogating here is, is the one called numbers.

We are doing our restriction here, with the where i is bigger than ten, and then the final line always has to be a select statement, and the select statement in its simplest guise says bring back everything that relates to that particular value that you've just retrieved. So, bring back an entire integer. That sounds a bit weird but, again, in later sessions we'll see, kind of, why that is significant.

So, what we've got here is a piece of code that does exactly the same thing as the previous chunks of code, but it's using just a slightly different notation.

And just to turn things on their head, the final piece of code here is exactly the same as lines 39 to 42, but we've moved from, effectively, a query notation to a method notation. We're using a Lambda, because another extension method of collection types is the for-each method, and the for-each method needs to be passed-, well, can work with an anonymous function, pass the variable N, taking it onto a single line of code, in this case Console.WriteLine.

And so, we can see that it's gonna be pumping out to the console each value in the two digit numbers collection. And if I carry on running that, we should see the final output of the application. Okay. So, we can see that, down the bottom, it's printed out exactly the same set of numbers as previously.

So, all four variations of this code do exactly the same thing. Some are doing things with the conventional old style approach, but towards the bottom we're introducing the concept of Lambdas.

Practical example of creating and using Lambda Expressions

About