[MUSIC]

Before we get into using methods syntax with LINQ.

I wanna over a set of features in C# that fit the style of functional programming.

Functional programming languages focus on computations

as opposed to executing a series of commands.

C# is an object oriented language.

However, many of the object oriented languages out there have adopted elements

of functional programming and give us the ability to program in a functional style.

LINQ queries are inherently functional because as we write our queries,

we are expressing what we want, and not how we want it.

If all this sounds a bit confusing don't worry,

I'll show you some examples that should help clear it up.

We'll only touch lightly on functional programming for LINQ but

we'll cover it in more detail in a future course.

There are some guidelines that functional programming languages follow, and

it can be helpful to keep them in mind when writing code.

The big one is that there are no side effects.

When you run a function,

it should not modify anything outside of the function scope.

For instance, if we have a function that evaluates a collection that exists

outside the function, it shouldn't add or remove anything from that collection.

Another concept is that functions are first class citizens.

This means that functions are treated like any other type and

can be passed around as objects.

We'll be going over delegates and other function types in C# that let us do that.

We also wanna make sure that a function has the smallest scope and performs

the least amount of work possible, which is usually computational in nature.

We should be able to treat it like a piece of data.

The function takes input and gives us the result of the computation.

We could replace the function call with its expected result and

everything would run the same.

This is a good practice, in general.

But it is definitely showcased when applying functional programming concepts.

And last but not least is the use of expressions.

For instance, instead of creating a variable without a value and

then running some kind of logic to assign its value.

You use an expression to assign a value as you create it.

This concept goes very well with LINQ.

Applying these concepts in your code has huge benefits.

Your code becomes more readable, easier to maintain and easier to test.

However don't feel like you have to use functional programming just for

the sake of it.

You can take these concepts and

apply them in your applications if it's the right fit.

The goal is to help you be a better programmer.

You don't have to relearn how to program in a functional way but you can

take from these concepts and write code that's cleaner and easier to maintain.