6.4 Scratchpad Learning Activity

this.students.Where(p => p.Salary >= 20000m);

Where is an extension method under the System.LINQ namespace. You can F12 on it to see it. If you hover over Where, it will show that it is an extension method.

The Where extension method only returns a type of IEnumerable. Assigning it to a List type, for instance, would cause an error.

this Person person

This parameter is what "attaches" this method to a class and makes it an extension method. Now only objects of type Person can use this method.

Return to the MainWindow. Note that there are no compiler errors. The way we have IsRich called right now is the correct way to call an extension method.

Define a local variable of type decimal named sum and assign it to the call to the Sum extension method on the students IEnumerable, passing in a Func lamba for Salary.

decimal sum = students.Sum(p => p.Salary);

This is a fine way to do things, but we can change two lines to one by chaining extension methods.

students = this.students.Where(p => PersonExtensions.IsRich(p));

This syntax should look more familiar to you. This code calls the static method and passes in the Person object. While this code works, it is just a longer version of p => p.IsRich() so we use the extension method syntax instead.

IEnumerable<Person> result = this.students.Where(p => p.IsRich()).Select(p => p);

We've seen this before, but have added the Select extension method that brings back

result = from p in this.students where p.IsRich() select p;

The keywords should look relatively familiar if you have taken data courses. LINQ syntax uses the same keywords, but in different order.

IEnumerable<Person> linqResult =
from p in this.students
where p.IsRich()
select p;

This is the same syntax as the step prior, but written in the format you will generally come across when reading/writing code. Many times there are multiple statements that can get complicated so putting them on separate lines is preferred.

IEnumerable<Person> result =
from p in this.students
where p.IsRich()
select p;

This code "assumes" that the type coming back from this query is an IEnumerable<Person>. But what if it isn't??

Hover over the result2 variable. The type has changed from IEnumerable<Person> to just Person because the compiler now knows that the type returned is going to be a Person object.

var anon = new { Name = "Steve", Number = 12345, Guy = new Person { LastName = "Fredrickson" } };

This code uses the var keyword and object intializer syntax to create an object with no "real" type. Note that we don't have a class that has the field Name or Number or Guy.

anon.Guy.Salary = 10000;

Even though the anon type is anonymous, since we defined a specific type property in the initializer we can modify that object.

This query brings back Person objects. While that's okay we don't necessarily care about all properties and want our own custom object. More than that, selecting p (or whatever variable) is the C# equivalent of the SQL Select *; it will bring back all property data, which we may not need.

Hover over result3. Now that we have used the object initializer and the compiler has no idea what type it is, it becomes an anonymous type.