Write complex data queries using the LINQ features in C#

LINQ

So far you've seen query syntax and two flavors of method syntax.
```cs
// Query syntax
var longLoudheroes = from h in heroes
  where h.Length > 6
  select h.ToUpper();

// Method syntax - separate statements
var longHeroes = heroes.Where(h => h.Length > 6);
var longLoudHeroes = longHeroes.Select(h => h.ToUpper());

// Method syntax - chained expressions
var longLoudHeroes2 = heroes
  .Where(h => h.Length > 6)
  .Select(h => h.ToUpper());
```
 
As you get into more advanced LINQ queries and learn new operators, you'll get a feel for what works best in each situation. For now, we generally follow these rules:
1. For single operator queries, use method syntax.
2. For everything else, use query syntax.
 


When To Use Each Syntax

A basic LINQ query, in _query syntax_, has three parts:
```cs
string[] heroes = { "D. Va", "Lucio", "Mercy", "Soldier 76", "Pharah", "Reinhardt" };

var shortHeroes = from h in heroes
  where h.Length < 8
  select h;
```

* The `from` operator declares a variable to iterate through the sequence. In this case, `h` is used to iterate through `heroes`.
* The `where` operator picks elements from the sequence if they satisfy the given condition. The condition is normally written like the conditional expressions you would find in an `if` statement. In this case, the condition is `h.Length < 8`. 
* The `select` operator determines what is returned for each element in the sequence. In this case, it's just the element itself.
 
The `from` and `select` operators are required, `where` is optional. In this next example, `select` is used to make a new string starting with "Hero: " for each element:
```cs
var heroTitles = from hero in heroes
  select $"HERO: {hero.ToUpper()}";
```

Each element in `heroTitles` would look like `"HERO: D. VA"`, `"HERO: LUCIO"`, etc.


Basic Query Syntax

In _method syntax_, each query operator is written as a regular method call. 

In the last exercise we selected every element with a length under 8. Here it is in method syntax:
```cs
string[] heroes = { "D. Va", "Lucio", "Mercy", "Soldier 76", "Pharah", "Reinhardt" };
var shortHeroes = heroes.Where(h => h.Length < 8);
```

The `where` operator is written as the method `Where()`, which takes a lambda expression as an argument. Remember that lambda expressions are a quick way to write a method. In this case, the method returns `true` if `h` is less than 8 characters long.

`Where()` calls this lambda expression for every element in `heroes`. If it returns `true`, then the element is added to the resulting collection.

For example, the `shortHeroes` sequence from above would be:
```
[ D. Va, Lucio, Mercy, Pharah ]
```


Basic Method Syntax: Where

Great job &mdash; we just covered a lot of LINQ! Here's a recap:
* _LINQ_ is a set of language and framework features for writing structured, type-safe queries over local object collections and remote data sources.
* Use LINQ by referencing the `System.Linq` namespace in your file.
* When a LINQ query returns a sequence of elements its type is `IEnumerable<T>`. That means it works with `foreach` loops and its length is accessible with `Count()`.
* Store a query's result in a variable of type `var`. `var` is an implicit type, meaning it gets all of the benefits of type-checking without our specifying the actual type.
* LINQ queries can be written in _method syntax_ or _query syntax_. 
* We prefer method syntax for single operations and query syntax for most everything else.
* The `Where` operator is used to select certain elements from a sequence.
* The `Select` operator determines what is returned for each element in the sequence.
* The `from` operator declares a range variable that is used to traverse the sequence. 
* LINQ can be used on arrays and lists, among other datatypes.
 
If you're curious or want more practice, here are some additional resources:
* Learn more by reading [Microsoft's guide to LINQ](https://docs.microsoft.com/en-us/dotnet/csharp/linq/).
* Find a [list of keywords for query syntax here](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/query-keywords).
* Find a [list of common methods for method syntax here](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/standard-query-operators-overview).
* Find a [complete list of methods for `IEnumerable<T>` here](https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable).


Review

Before we jump into the syntax and methods, let's import the features into our code. To use LINQ in a file, add this line to the top:
```cs
using System.Linq;
```


Often times we use LINQ with generic collections (like lists), so you may see both namespaces imported into a file:
```cs
using System.Collections.Generic;
using System.Linq;
```


Importing LINQ

To transform each element in a sequence &mdash; like writing them in uppercase &mdash; we can use the `select` operator. In method syntax it's written as the method `Select()`, which takes a lambda expression:
```cs
string[] heroes = { "D. Va", "Lucio", "Mercy", "Soldier 76", "Pharah", "Reinhardt" };
var loudHeroes = heroes.Select(h => h.ToUpper());
```
 
We can combine `Select()` with `Where()` in two ways:
1. Use separate statements:
```cs
var longHeroes = heroes.Where(h => h.Length > 6);
var longLoudHeroes = longHeroes.Select(h => h.ToUpper());
```
2. Chain the expressions:
```cs
var longLoudHeroes = heroes
  .Where(h => h.Length > 6)
  .Select(h => h.ToUpper());
```

As with most of LINQ, the choice is up to you!


In the first option, we use two variable names and two statements. You can tell there are two separate statements by counting the semi-colons.

In the second option, we use one variable name and one statement.

If we must use method-syntax, we prefer the second option (chaining) because it is easier to read and write. You can imagine each line like a step in a conveyor belt, filtering and transforming the sequence as it goes. 


Basic Method Syntax: Select


Every LINQ query returns either a single value or an object of type `IEnumerable<T>`. For now, all you need to know about that second type is that:
* It works with `foreach` loops, just like arrays and lists 
* You can check its length with `Count()`

Since the single value type and/or the parameter type `T` is not always known, it's common to store a query's returned value in a variable of type `var`. 

`var` is just an implicitly typed variable &mdash; we let the C# compiler determine the actual type for us. Here's one example:
```cs
string[] names = { "Tiana", "Dwayne", "Helena" };
var shortNames = names.Where(n => n.Length < 4);
```
 
In this case `shortNames` is actually of type `IEnumerable<string>`, but we don't need to worry ourselves about that as long as we have `var`!


Imagine you're building a new game in C#, with dozens of characters to manage in your database. How would you access them all? What if you need to apply a filter? What if you needed to format each character name?

You might think of storing characters in a list and running through each element with a `foreach` loop. You'd have to write nested `if` statements, re-format each element, and store each result in a new list. 

The result isn't pretty. 

Suppose that we want to find all the names in a list which are longer than 6 letters and return them in all uppercase letters. You can see what it would look like in **Program.cs** in the code editor. 

And remember that this only works in a running C# file. What if the database was stored in a separate server somewhere and it was implemented with SQL instead of C#?

The solution is _LINQ_. It works for complex selections and transformations, and it works on local and remote data sources. Each selection/transformation is called a _query_, and LINQ gives us new syntax and methods to write them.

Imagine LINQ like an add-on to C# and .NET. Once you import the LINQ features, you can write new syntax, like:
```cs
string[] names = { "Tiana", "Dwayne", "Helena" };
var filteredNames = from n in names
  where n.Contains("a")
  select n;
```


And you can use new methods on collections, like `Where()`:
```cs
var shortNames = names.Where(n => n.Length < 4);
```


In this lesson you'll learn :
* How to import the LINQ features to C#
* How to run LINQ queries on datasets
* How to identify method and query syntax
* Basic operators, such as `Select`, `Where`, and `from`


Introduction to LINQ

You've mostly seen LINQ used with arrays, but it can be used for lists as well! The syntax is the same:




```cs
List<string> heroesList = new List<string> { "D. Va", "Lucio", "Soldier 76" };

var longLoudheroes = from h in heroesList
  where h.Length > 6
  select h.ToUpper();

// longLoudHeroes is [ "SOLDIER 76" ]
```
 
Technically, LINQ can be used with any type that supports `foreach` loops, but we won't cover all of those here.


LINQ with Other Collections

In LINQ, you can write queries in two ways: in _query syntax_ and _method syntax_.

Query syntax looks like a multi-line sentence. If you've used SQL, you might see some similarities:
```cs
var longLoudHeroes = from h in heroes
  where h.Length > 6
  select h.ToUpper();
```
 
Method syntax looks like plain old C#. We make method calls on the collection we are querying:
```cs
var longHeroes = heroes.Where(h => h.Length > 6);
var longLoudHeroes = longHeroes.Select(h => h.ToUpper());
```
In LINQ, we see `where`/`Where()` and `select`/`Select()` show up as both keywords 
and method calls. To cover both cases, they're generally called _operators_.

Every developer has a personal preference between syntaxes, but you should be able to read both. In this lesson we'll start with query syntax then move on to method.
