.NET Generics follows a good design philosophy. This API is open for extension, but closed for modification. Think about the .NET string API. You can't change the source code for any member method. However, if you want you can always put a new method that can behave as if it was built-in.

The technology that allows us to do this legal stretching (if you will) is known as the Extension method. Here are a few very important details about Extension methods:

We just created an Extension method called IsMatching() for the string class. The first argument of the method is the calling object. pattern is the regular expression against which we want to validate the input string. We want to compare the strings ignoring the culture.

So, while calling IsMatching(), we shall just have to pass the pattern and not the string.

As this IsMatching() method is described as an Extension method in StringEx; and StringEx is referenced in this StringExTest project, IsMatching() will be available for invocation on any string object in the StringExTest project.

Any Extension method appears with a downward arrow, as shown in the following screenshot. Also the compiler shows the intelligence support (if it is selected) mentioning that this is an Extension method:

Notice that while calling the Extension method, we do not need to pass the string argument. testInput is the string object on which we call this Extension method.

The keyword this in the parameter list did the trick.

It is possible to define the Extension method for any type of .NET class. So all you have to do is add a static class and add the static Extension methods to the class. You can find an API for string processing written using the Extension method at http://www.codeplex.com/StringDefs. I created this for different kinds of string processing needs. This will give you an idea about how Extension methods can be written for several purposes.

For using LINQ to Objects, we shall need System.Linq namespace. The standard query operators of LINQ are based on the Extension methods that extend any type that implements IEnumerable<T>.

Assume that you have a class called Student and you want to initialize student objects using different variables at different times. Sometimes, you will only have name and age, while at other times you might also have the course they are enrolled in as part of the input. These situations call for a set of parameterized constructors in the Student class.

Otherwise, we can have a blank constructor and public properties for the Student class attributes. In this situation, the code to assign a student object might look similar to the following:

Student sam = new Student();
sam.FirstName = "Sam";
sam.LastName = "Hood";

Student dorothy = new Student();
dorothy.Gender = "F";
dorothy.LastName = "Hudson";

This type of object initialization spans over multiple code lines and, at times, is difficult to read and keep up. Thus, C# 3.0 came up with a feature called object initializers that allows programmers to construct and assign an object in a single line. Any public field or property can be assigned in the initialization statement by assigning that property name to a value. Multiple assignments can be made by the comma-separated assignment list. The C# compiler calls the default constructor behind the scene and assigns each public field or property as if they were previously declared and assigned one after another. So, the previous two initializations will be changed to the following:

Although this technical advancement might, at first, look like syntactical sugar, while writing LINQ queries, we shall find ourselves using this feature quite often to construct object instances as part of the result set by setting property values on the fly.

Taking the object initializers a step ahead, the ability to add elements to the collections at the time of creating them is added. This is called a collection initializer. The only constraint is that the collection has to implement the IEnumerable interface and provide an appropriate Add() method implementation that will be used to add the elements.

The good thing is that collection initializers can use object initialization technique to create objects on the fly while adding them to the collection. Here are some examples:

List<string> names = new List<string>() { "Anders", "David", "James", "Jeff", "Joe", "Erik" };

List<int> numbers = new List<int>() {56, 12, 134, 113, 41, 1, 0};

List<Student> myStudents = new List<Student>()
{
  new Student(){Name = "Sam", Course = "C#"},
  new Student(){Name = "Dorothy", Course  = "VB.NET"}
};

C# 3.5 introduced a new way to declare variables using the var keyword. This type of a new variable is inferred from the initialization expression. These types of variables are strongly typed.

Here are a few examples:

var shirtSize = "L";
var shoeSize = 10;
var age = 29;
var coursesTaken = new List<string>() { "C#", "C++", "Java", "Ruby" };

Console.WriteLine(shirtSize + " " + shirtSize.GetType().Name);
Console.WriteLine(shoeSize + " " + shoeSize.GetType().Name);
Console.WriteLine(age + " " + age.GetType().Name);
Console.WriteLine(coursesTaken + " " + coursesTaken.GetType().Name);

And here is the output for the preceding snippet:

L String
10 Int32
29 Int32
System.Collections.Generic.List`1[System.String] List`1

Although declaring a variable in this way may seem to have little value, it is a necessary feature for declaring some types that can't be declared in any other way; for example, anonymous types.

Anonymous types are compile-time generated types where the public properties are inferred from the object initialization expression at compile time. These types serve the purpose of temporary storage. This saves us from building specific classes for any operation.

Anonymous types are declared using the var keyword as an implicit variable and their type is inferred from the expression used to initialize.

Anonymous types are declared by omitting the type after the new keyword. Here are a few examples:

var item = new { Name = "Sam", Age = 30 };
var car = new { Make = "Honda", Price = 30000 };

These types are used in queries where collections are built using a subset of properties from an existing type also known as projections . We shall see how these help in LINQ in a short while.

Lambda expressions are built on an anonymous method. These are basically delegates in a very brief syntax. Most of the time these expressions are passed as an argument to the LINQ Extension methods. This type of expression can be compound and can span multiple lines while used in LINQ Extension methods also known as LINQ Standard Query Operators or LSQO in short.

Lambda expressions use the operator => to separate parameters from expressions.

Before the Lambda expression came into existence, we had to write query using delegates as follows:

Students.Find(delegate(Student s) {return s.Course == "C#";});

Using the Lambda expression, the query will be as follows:

Students.Find(s => s.Course == "C#");

The highlighted part in the second code line is the Lambda expression. One way to visualize this is to think about mathematical sets. Assume => stands for rule of membership. So the preceding line is basically trying to find all the students where course is C# and s denotes a temporary variable of the data source being queried; in this case the Students collection.

This is a very important concept for understanding and using LINQ.

Functors are basically space holders for Lambda expressions. It is a parameterized type in C#. There are 17 overloaded constructors to declare different types of Functors. These are created by the Func<> keyword as follows:

Notice the tooltip. It is expecting a method name that accepts no parameter but returns a Boolean value. So boolMethod can hold any method that matches that signature.

So if we have a method as shown in the following snippet:

private static bool IsTime()
{
  return DateTime.Today.Day == 8 && DateTime.Today.Month == 7;
}

the Functor can be created using the method name as an argument to the constructor, as follows:

Func<bool> boolMethod = new Func<bool>(Program.IsTime);

The last parameter to a Functor is the output and the rest all are input. So the following Functor constructor expects a method that accepts an integer and returns a bool:

These types of Functors that take some argument and return a Boolean variable (in most cases due to some operation on the input argument) are also known as Predicates.

You can also use Lambda expression syntax to declare Functors as follows:

//Declaring the Functor that takes an integer and checks if it is odd
//When the Functor takes only one input it is not needed to wrap the
//input by parenthesis. Highlighted part is the Lambda expression
//So you see, Lambda expressions can be used directly where the //argument type is of Func<>
Func<int, bool> isEven = x => x % 2 == 0;

//Invoking the Functor
bool result = isEven.Invoke(8);

Most of the LSQO accept Functors as selector functions. A selector function is a function that operates on each of the element in a collection. The outcome of these operations decide which values will be projected in the resulted collection. This will be more clear as we discuss all the LSQO in a while.

Predicates are essentially Func<int, bool>. You can use Lambda expressions to initialize them like Functors as follows:

Predicate<int> isEven = new Predicate<int>(c => c % 2 == 0);

Here is how you can call this Functor:

int[] nums = Enumerable.Range(1, 10).ToArray();
foreach (int i in nums)
  if(isEven(i))
  Console.WriteLine(i.ToString() + " " +  " is even " );

The Lambda expression is hidden. It is advisable to use Func<> for LINQ-related operations as it matches the signatures of the LSQO. Predicates was introduced with System.Collections.Generic in .NET Framework 2.0 and Func<> was introduced in .NET 3.5.

Although they behave similarly, there are a couple of key differences between a Predicate and a Functor:

This is a built-in delegate, introduced in .NET Framework 4.0. There are several overloaded versions to handle different styles of delegates.

Here is an example:

Action<string> sayHello = new Action<string> (c=>Console.WriteLine("Hello " + c));

List<string> names = new List<string>() { "Sam", "Dave", "Jeff", "Erik"};
names.ForEach(sayHello);

ForEach() is a method in the List<T> class that takes an argument of the type Action<T>. The preceding snippet prints the following output:

Hello Sam
Hello Dave
Hello Jeff
Hello Erik

In this section, we will discuss the following Restriction operators:

Where()

This query operator allows the user to filter their data source for some condition passed as a predicate. With .NET 3.5+ this can be a Lambda expression.

There are two overloads of this operator:

This one takes a predicate that accepts an element of type T and returns a bool applying some logic on the element passed. So, if we are operating this operator on an array of strings, then this version of Where() would expect a Func<string, bool>.

Both overloaded versions return an IEnumerable<T> instance so that we can pass the result obtained as input to another LSQO.

The first version of Where() takes a Func<T, bool> (T is the type of source collection). In this case, T is a string. So in this case, it will expect a Func<string, bool>. As described earlier, Functors can be expressed as Lambda expressions. This leads to much shorter code.

The highlighted part in the query is the Lambda expression that takes the form of a Func<string, bool>. c represents an element in the source being queried (in this case, names). Where() loops through the entire source and outputs those to the returned IEnumerable<T> instance. As we want to store the result in a List of strings, I have used the ToList() Extension method to convert the results from IEnumerable<string> to List<string>.

filteredNames will have "Sam" and "Pamela", as shown in the following screenshot:

Here are some examples that might interest you!

The Lambda expression c => "aeiou".Contains(c) matches only that character that is a vowel from the source. As the string is a character array, the Where() in this case is operating on IEnumerable<char>.

In the end, ToList() converts the IEnumerable<char> back to a List.

Process.GetProcesses() returns an array of System.Diagnostics.Process and thus, it is an IEnumerable<Process> so Where() can operate on this. LSQO is being written as an Extension method of the IEnumerable<T> interface which can operate on any collection that implements this interface. System.Array() implements IEnumerable(), which is also inherited by IEnumerable<T>. This is because of the Liskov Substitution Principle.

Note, implicit variable declaration is used to store the result of the query. However, later on, a strongly typed variable is used in the loop to iterate over the result. This is proof that var actually enforces strong typing implicitly.

In the Lambda expression (c,index) => c.Length <= index + 1, c denotes any variable in the array names, while index denotes the index of that particular element in the array names. So, for example, if the current element being scanned is "Dave" then the index will be 2 (the array index starts from zero).

c.Length means the length of the current element. So c.Length <= index + 1 will return true if the length of the current element being scanned is less than or equal to the expression index plus unity.

Now, if we scan from the first element, the results will be as follows:

As only "Erik" matches the Lambda expression, it gets added to the returned IEnumerable<string>.

You can do pretty much anything depending on the index of the element.

We have a List of Student objects and we wanted to find all the students that have opted for C#. Assuming Course is a public property of the Student object, s.Course gives the course of the current student on the collection, while we keep moving along the collection.

s => s.Course.Equals("C#") is the expression that evaluates to true when the course of the current student is C# and that Student object gets added to the List of IEnumerable<Student>, which is returned after the operation is complete.

We used the var keyword to use implicit typing while receiving this IEnumerable<Student> instance. Later in this chapter, you will learn some conversion operators, so that we can project the result on a concrete collection.

The following screenshot shows how we can visualize Where():

In this section, we will discuss the following Projection operators:

Select()

This operator allows you to project the elements in the result collection in a customized manner. Like Where() this also comes in two overloaded versions. The first version takes a Lambda expression that describes how the projection has to be made. The other version allows us to consider the index of the element:

The Lambda expression c => "Hello!" + c is basically creating a projection of the elements of nameList1 List and the result will be an instance of IEnumerable<string> with all the elements of nameList1 and a "Hello!" in front of them.

ToList() is a conversion operator, which we shall learn later in this chapter. This converts the generated IEnumerable<string> to a List<string>. I used this conversion because I wanted to use the ForEach() method of the List<T> class that accepts an action.

Now that we have the List of processed strings, we need to tell the computer how we want it to be printed. The last Lambda expression c => Console.WriteLine(c) does just that. This means taking a string from the List and printing it to the console, one per line.

This query makes use of the anonymous type. The Lambda expression: nameList1.Select((c,index) => new {Name = c, Prize = index % 3 == 0}) uses the index of the current element. Instead of projecting the current string or some concatenated string, this time we want to project an anonymous type. The properties of this type get populated by the current element and its index.

The name of this anonymous object is assigned as the current element by the code Name = c, while whether this person has won a prize or not depends on the index of the current element.

Prize = index % 3 == 0 means if the index of the current element is a multiple of 3 then the attribute Prize for the anonymous object gets set to true, otherwise it gets set to false.

So the query Select((c,index)=> new {Name = c, Prize = index % 3 == 0}); returns an instance of IEnumerable<string> that has the names of the lucky winners.

So once we have it, we iterate over the instance to print the results.

Can you predict what will be the result of the following query?

nameList1.Select((c,index)=>  new {Name = c, Prize = index % 3 == 0})
  .Select(c=>c.Prize==true?"Hello! " + c.Name + " You are the Lucky 3rd Caller":"no")
  .ToList()
  .Where(c=>c.StartsWith("Hello!"))
  .ToList()
  .ForEach(c=>Console.WriteLine(c));

Hint: In order to understand it, you can break the query into parts and put them in LINQPad and execute them step-by-step.

In this example, we use the first version of the SelectMany() method that has the following signature:

Note that it accepts a Functor that accepts a string and returns an instance of IEnumerable<T>.

In this case, the Lambda expression c => c.Value means that each key returns the list of values associated with that key.

The second overloaded version allows us to use the index of the current element in the source collection in the Lambda expression.

Later in this chapter, you will see some other applications of this operator.

In this section, we will discuss the following Partitioning operators:

Take()

Suppose we are only interested in the first few values of a collection and we don't want to consider the rest for now. In this situation, in the absence of LINQ, we had to create a blank collection and iterate over the original one to populate the other empty collection.

With the introduction of LSQO, Take() all that is going to be history. Take() takes an integer parameter and returns IEnumerable<T> (where the source collection is of type T) containing as many elements as you want starting from the first element in the source collection.

The method signature is as shown in the following screenshot:

Numbers is an int array, int in C# is an alias for System.Int32 type in CTS. Thus, the query numbers.Take(4); returns an IEnumerable<System.Int32> that has first four elements.

One good thing about Take() is that it doesn't throw an exception if the argument number is out of range (say negative, or more than the number of elements in the collection).

If a negative index is passed, Take() returns the entire collection. The following is a visual representation of this operator:

TakeWhile()

Suppose you have to pick elements from a collection as long as those elements meet a certain criterion. We have already learned about Take() that lets you pick from the start of the collection. In order to allow conditional picking, TakeWhile() was introduced. This operator takes a Lambda expression that describes the condition.

There are two overloaded versions of the method. The first one takes a Functor, as shown in the following screenshot:

If you are thinking, why "Sid" didn't make it to the List of the matching names, you are not alone. I thought so too initially. However, you must understand that TakeWhile() operates on the collection as it is, without any modification or sorting. So it processes the elements as they appear in the List.

TakeWhile() picks elements from the start of the collection as long as the given condition expressed as the argument Lambda expression is true.

"Sam" and "Samuel" are two names that match the condition and the next name "Dave" does not match the expression and thus scanning stops there. Did you get the While of TakeWhile() now? This essentially means Take as long as the condition is satisfied.

So, if the expression was c => c.StartsWith("D"), it would have returned an empty IEnumerable<string> as shown in the following screenshot:

The following is a visual representation of the TakeWhile() operator:

Like Where(), TakeWhile() queries can also be indexed using the second version of the method.

Say we want to check whether every second name starts with "S" or not:

var sNames = names.TakeWhile((c,index) => index%2==0 && c.StartsWith("S"));

Like Take(), TakeWhile() doesn't throw any exception when the number is out of bounds. Notice that TakeWhile() doesn't take an explicit number of items to pick. It just stops scanning as soon as the condition is dissatisfied.

Skip()

This operator allows you to skip the first n number of items from the source collection while processing. This is the exact opposite of Take(), conceptually.

The previous screenshot shows an example of the Skip() operator.

Skip() creates an IEnumerable<T> instance that will have only the chosen few elements. In this case, we wanted to skip the first three elements. If you want to conditionally skip elements, then you would need SkipWhile(). That's next!

However, if you want to filter the entire collection, your best bet is Where(). This works without sorting.

Similar to Take(), it doesn't throw any exception when the number passed is out of bounds of the source collection. It returns an empty IEnumerable<T> when the source collection is of type T. Interestingly, if a negative argument is passed to Skip(), it doesn't skip anything and returns the entire source collection.

SkipWhile()

This is a conditional skip from the source collection. The elements from the source collection do not get added to the projected output as long as the given condition holds good:

Say we have a List of integers and we don't want to get anything that is less than 10. Following is the code:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,20 };
int[] nums = numbers.ToArray();
var skippedList = nums.SkipWhile(c=>c<10);//Leaving everything less
//than ten
foreach (var v in skippedList)
  Console.WriteLine(v);

This code snippet will output as follows:

Like TakeWhile(), SkipWhile() also has an indexed version that lets us use the index of the element in the query.

In this section, we will discuss the following Ordering operators:

sentence.Split(' ') generates a string[], and Reverse() returns an IEnumerable<string> with a reversed order of the words. Now I can convert this back to a List<string> to use the ForEach() method as it was used earlier.

In this case, we are cleaning all the whitespaces. Then the cleaned string is tokenized by a comma (,) and this gives us a List of strings.

This is where SelectMany() steps in, to create an IEnumerable<char> from all the characters of the strings, of the string array generated out of Split(',') call.

So, the original now has the list of all the characters of all the words in the sentence.

Using original.Reverse();, we create an IEnumerable<char> that has all the characters in reverse order.

The next line compares these two character sequences using the operator: SequenceEqual(). If both the character streams are the same, the verdict will be set to "This is a Palindrome".

There are several long palindromic sentences. You can find a long list at http://www.cs.arizona.edu/icon/oddsends/palinsen.htm.

The following query uses a funny looking Lambda expression, which can be quite confusing at the first glance:

c => c

Which essentially means sort by the string itself.

Now, if you want to sort the elements by their length, here is how to make the change:

string[] names = { "Sam", "Pamela", "Dave", "Anders", "Erik" };
names.Dump("Before Sorting");
names = names.OrderBy(c => c.Length).ToArray();
names.Dump("Sorted by Length");

And the results will be as follows:

We have a List of points in 2D and we wanted to sort them by their X co-ordinates. We created an anonymous type out of these points and projected them to an IEnumerable<> by Select().

Next, OrderBy() comes and sorts this List by their X co-ordinates. This sorting intent has been described by the Lambda expression c => c.X.

At the end, we converted the result to a List of the anonymous type. Notice that the header of the table in the output, shown in the preceding screenshot, doesn't have any data type, as the result is of anonymous type.

Suppose, we have a List of some user-defined Student objects as follows:

Student[] someStudents = 
{
  new Student(){Age = 20, Course = "C#", Name = "Sam" },
  new Student(){Age = 19, Course = "Ruby", Name = "Bobby" },
  new Student(){Age = 18, Course = "F#", Name = "Shakira" } 
};
//Sorting the students by their age.

Can you sort these students by their age using the LINQ OrderBy() operator?

In this section, we will discuss the following Grouping operators:

GroupBy() returns an instance of IEnumerable<IGrouping<Tkey, TValue>>.

Assume this is a dictionary of dictionaries. TKey is the key of the entries and TValue is the value of the entries. So, in this case, each key will be associated with an IGrouping<string, string>.

The first part of the output (that is the table) is generated by the Dump() command. Here you can see how the data structure is organized within.

The second part is generated manually by iterating the group. Each group entry has a read-only property called Key, and this looping construct used is typically how you can extract data from a group (IGrouping<TKey, TValue>).

We have successfully created the index. Now you might ask the question, how do we get items for the particular Key, such as dictionaries?

Here is how to do it. Suppose I want to find out all the entries for the Key "Sa" from the preceding group. The syntax will be as follows:

groups.Where(c=>c.Key=="Sa").ToList().Dump();

Add the preceding line after the previous query in LINQPad and you should get the following output:

In this example, we have used an overloaded version of the method. It takes two Lambda expressions. The first one is the key selector, which will determine the keys of the elements added in the group. The second one is called the result selector, which is a function to create a result value from each group.

Let's see, what it means:

//Key selector lambda expression
c => c.Substring(0, 2)

This means we need to take only the first two characters of the string as the key of the group:

//Result selector lambda expression
(c, values) => values.Count()>2?values.Skip(2):values

This means if the strings matching the key are more than two, then skip the first two elements and put the rest as the result.

Now, note that there are three license plate numbers starting with "MA". That's why the first two are skipped from the result. However, plates starting with "MO" were only two in number, thus, they appear as it is in the result.

Try removing the second Lambda and you should get the following output:

In this section, we will discuss the following Set operators:

Intersect()

This is a Set operator. This returns the intersection (or the common elements) of two collections. There are two overloaded versions of this method. The first one takes a collection of type IComparable, so explicit IEqualityComparer is not needed.

Say we have two string lists and we want to find out what the common elements in them, are here is how we can do that using Intersect() on List<T>.

Intersect() returns an IEnumerable<T>, including only the elements that appear in both the collections. Intersect() has two overloaded versions. One works with the primitive data type and the other requires an explicit IEqualityComparer to know how to compare the elements of the collection.

The order in which the results appear in the result collection, depends on the sequence of calling.

Note that the sequence of appearance of the objects, in the intersected List, is that of the first collection or the collection on which this operator is invoked.

So, if you change the invoking object to the second collection, we shall get a different order:

This happened because "Erik" appears before "David" in the invoking collection.

However, if you must enforce alphabetical order, use OrderBy(c=>c) on the result obtained.

See this action in the following diagram:

The other version, however, needs to know how to compare objects in the collection. So, an IEqualityComparer needs to be passed explicitly.

Union()

This operator provides what a set union is for any collection that implements IEnumerable<T>. This, unlike Concat(), removes the duplicates.

Union(), like Intersect(), has two overloaded versions. The first one deals with the collections of type that implements IComparable.

The other one needs an explicit IEqualityComparer for comparing objects in the collection.

The following diagram shows how Union() works:

Union() returns a list of all the strings in both the collections, removing duplicates. Like Itersect(), it also has an overloaded version that needs an IEqualityComparer instance to compare elements of the collection.

As "Erik" and "David" appear in both the lists, they are added only once.

The name "Derik" is present only in nameList2 and not in nameList1, so it is returned. However, the sequence matters! Suppose, we want to find out what is in collection A and not in collection B, then the call will be made to Except() such as A.Except(B) and vice-versa.

So, we change the invoking collection to nameList1 as follows:

var exclusiveNames = nameList1.Except(nameList2);

The output will be as shown in the following screenshot:

Like its cousins Intersect() and Union(), Except() also comes with a different version, where you can pass an EqualityComparer<T> instance that will tell it how to compare the elements of the source collection.

Distinct()

This removes any duplicate from the given source collection. This method has two versions. If the type of the collection has implementation of IComparable then the method doesn't need any explicit IEqualityComparer to compare objects in the source collection.

Assume that you are writing software for a radio station, where songs are played on demand. Lot of people send the same song ID as a request. The radio jokey wants to make sure he/she plays the song only once. In such a queue, removing duplicates is needed. Distinct() does this quite gracefully.

In this section, we will discuss the following Conversion operators:

ToArray()

This method converts the IEnumerable<T> to Array<T>. This is used if you want to project your data as an array of the result set. This calls for immediate execution of the query:

The main objective is to generate a strongly typed array, instead of using the var keyword (which is also strongly typed). If the source collection is empty, it doesn't complain and returns an empty array.

Here is an example:

firstNames.Where(name=>name.StartsWith("Sa")) returns an IEnumerable<string>, and ToArray() converts it to a string[].

Thus, the result header shows the type of the returned result as a string[].

ToList()

This one is similar to ToArray(). However, this one returns a List<T>

This proves that ToList<T>() essentially converts the results to a List<T>. This operator can come in particularly handy when we need to use the ForEach() method of List<T> for running some action on each element of the collection. However I don't recommend heavy usage of these conversion operators as these affect query performance.

The Lambda expression c => c,c=>boys contains(c)?"boy":"girl" means that if c is in the List of boys names (boys) then return boy as the value for this key else return girl in the resultant Dictionary.

The first Dump() command nameMap.Keys.Dump("All Members"); prints all the names.

The second Dump() command nameMap.Keys.Where(c => nameMap[c] == "boy").Dump("Boys"); first does a filtering over the Dictionary to find the boys names and then only prints them.

The third command nameMap.Keys.Where(c => nameMap[c] == "girl").Dump("Girls"); does the same thing for girls.

ToLookup()

This returns a one-to-many lookup table from the given source collection as per the provided keySelector() method. There are four different overloaded versions of this method. It also lets us select the elements of the source collection that we want to use in the conversion.

The following is an example that uses the first version, which just takes a Lambda expression as the keySelector():

ToLookup() creates what you can imagine as a one-to-many Dictionary.

The Lambda expression c => c.Length describes the key to be used for the Lookup table.

So, in this case, the key for the table is the length of the words.

In this section, we will discuss the following Element operators:

There are two overloaded versions of the method. The first one doesn't take an input and returns the first element of the collection. The second version takes a predicate in the form of a Lambda expression and returns the first matching element.

So, in this case, the first element is returned when First() is used, on the other hand the second call returns the first name of length 5 matching the Lambda expression.

Please note that there is no sorting involved. So don't expect the first element after sorting. First() picks elements as they are laid out.

If there is no element in the source collection, it throws InvalidOperationException like Single(). That's why there is FirstOrDefault like SingleOrDefault.

As there is no element in the array names, FirstOrDefault() puts the default value for the string (which is null) in the variable defaultName.

In the IsPalindromic() method, the original sentence is split into words and then these words are stored in a collection. Next, this collection of words is reversed and stored into another List.

Then these two collections are checked for equality. Like other standard operators SequenceEqual() has another overloaded version that takes an EqualityComparer, which tells it how to compare items of the collection that don't already implement IComparable<>.

Internally, the elements are stored differently for different data structures. Thus, for Stack<> the last element stored at lastStackTag comes as <html> instead of <body>, as you would expect for a List<>. All the list-based containers, however, store the element in the same way.

ElementAtOrDefault()

It's the same as ElementAt(). However, this one won't complain if there isn't an element in the location at index i, unlike ElementAt() that will throw an exception if it doesn't find an element at the index mentioned.

So, if there is no element in the source collection at the given index, this method returns the default value of that data type.

The following is an example:

The value of ElementAt() and ElementAtOrDefault() is not very evident on the collections that primitively support zero-based indexing; such as list and array.

However, it can be pretty useful for other containers such as stack, which doesn't offer a peek at elements. ElementAtOrDefault() saves you from extensive usage of exception handling techniques.

DefaultIfEmpty() allows you to push only one default value in the source collection. In this case, 80.0 was pushed and ToList() converted the result to a List<double>.

In this section, we will discuss the following Generation operators:

Range() returns an IEnumerable<int>. So, we can pass the result obtained from Range() as the input to other query operators.

Range() returned an IEnumerable<int> instance and that was passed to Where() as an input. Thus, Where() operates to find the numbers divisible by 11 and returns only those as the final IEnumerable<Int32> instance.

The Repeat() method works on a string type in the current query and the string to be repeated is passed as "World is not enough" and it has to be repeated five times.

Then ToList() converted it to a List<string> and then ForEach() is used to print the result.

In this section, we will discuss the following Quantifier operators:

Single()

This is used to find out if there is only one element in the source collection that matches a given condition. There are two overloaded versions of this method.

The first one doesn't take any parameter and only checks whether there is more than one element present in the source. If there is more than one element, the invocation of this method throws InvalidOperationException and complains that the sequence contains more than one element. However, if the sequence contains only one element then this version returns that element:

Here is an example that uses the second version of Single() taking a Lambda expression as the predicate:

This will have "Danny" stored in onlyOne as that's the only name in the sequence names that starts with "Dan". However, the following snippet will throw an exception as there is more than one element in the source collection:

try
{
  string w = names.Single();//This line will throw //InvalidOperationException
}
catch (Exception ex)
{
  throw;
}

Both x and z will be true, in this case, as the source collection (names in this case) has some elements and a couple of them have a length of 5.

Unlike Single(), Any() doesn't complain if there is no element in the source collection or any that matches the Lambda expression.

All()

This operator allows us to check whether all the parameters in the source collection satisfy the given condition. This expression can be passed to the method as a Lambda expression:

Suppose, we have a List of integers and we want to check whether all of them are even or not. This is the best method to do these kinds of operations.

In this section, we will discuss the following Merging operators:

Zip()

This operator lets us combine the values of several collections and project them in a single collection of type IEnumerable<T>. This has only one version as follows:

The second argument is the Lambda expression that explains how we want these projections to be made. That's why it is called resultSelector as it determines how the result will look. Assume this operator as a normal zipper of your bag. The following is a simple representation of how this operator works:

Say we have a list of first names, a last name and a set of salutations. We can zip all these together in a single List<string> as follows:

1. Copy the following as a query to LINQPad:

   string[] salutations = {"Mr.", "Mrs.", "Ms", "Master"};
   string[] firstNames = {"Samuel", "Jenny", "Joyace", "Sam"};
   string lastName = "McEnzie";
   salutations.Zip(firstNames, (sal, first) => sal + " " + first);
              .ToList();
              .ForEach(c => Console.WriteLine(c + " " + lastName));

2. Run the query and you should get the following output:

   

The Lambda expression: (sal, first) => sal + " " + first does the magic of concatenating the salutation and the first name of all the "McEnzie" family members.

Now once that is done, ToList() converts the resultant IEnumerable<string> holding the concatenated salutation and first name to a List<string> such that using ForEach() last name can be concatenated to all of them in a single line of code.

That's how we get the list of names printed.