LINQ Tutorial

System.Linq namespace defines many useful extension methods.Following extension methods are used to return single value from the collection.

• FirstOrDefault
• SingleOrDefault

FirstOrDefault

FirstOrDefault is an extension method defined in the System.Linq namespace.It can be called byt the collections implementing IEnumerable.It returns the default value for the type if the collection doesn’t contain any elements.If the collection contains elements than it returns the first element of the collection.

For example if we declare the collection as:

int[] items = {1,2,3,4,5 };
int returnValue = items.FirstOrDefault();


the returnValue will contain the value 1.Since the collection consists of multilple items it returns the first element
which is 1.

On the other hand if declare the collection as:
int[] items = {};
int returnValue = items.FirstOrDefault();

Since the collection doesn’t contain any items it returns the default value for integer which is 0.
So the returnValue will contain the value 0.

Default value to return for the type is determined by the method default(T).

SingleOrDefault

SingleOrDefault returns a single item from the collection if one element exists for the condition.If more than one element exists for the condition than exception is thrown.
List<int> items = new List<int> { 1,2,3,4,5 };
items.SingleOrDefault(item => item ==1);//returns 1
items.SingleOrDefault(item => item ==0);//returns 0 default value for integer
items.SingleOrDefault();//throws exception

In the above SingleOrDefault method calls, the last call throws exception.Since the items collection consists of more than one elements so the method call returns exception.

First

First returns first matching element from a collection if collection consists of more than one matching elements.

List<int> items = new List<int> { 1,2,3,4,5 };
List<int> itemEmpty = new List<int> {};
items.First(item => item >0);//returns 1 ,first element
itemEmpty.First();//returns exception

The First(item => item >0) method call above returns 1 ,since there are multiple matching elements.The second method call throws exception since the collection doesn’t
contain any elements.

Single

Single returns element if a single matching element is found.If more than one element are found or no element is found than exception is thrown.

Follow on:

There are two ways in which we can execute the LINQ queries ,Immediate and Deferred .Immediate and Deferred query execution in LINQ means when the query is executed.This is because the query declaration in LINQ is different from query execution.

When we write a LINQ query we declare a query variable which contains the result of the LINQ query.
Usually we declare a query variable using var type as:

var results= from student in students
where student.class == 12
select student

The above result variable contains the result of the query execution.

You may think that by just declaring the query above ,the result variable will contain the list of students of class
12th.This doesn’t happen.

results variable will not contain the result of query execution until we loop or iterate over the query variable.

class Student
{
public string Name { get; set; }
public string Subject { get; set; }
public int Marks { get; set; }

public int Class { get; set; }
}
var students=new List<Student>{
new Student{Name="Amit",Class=12},
new Student{Name="John",Class=10},
new Student{Name="Raj",Class=8},
new Student{Name="Greg",Class=12},
new Student{Name="Priya",Class=12},
};

var results = from student in students
where student.Class == 12
select student;

Following iteration executes the query referred by the query variable.

foreach(var student in results)
{
Console.WriteLine(student);
}

This is called deferred query execution

If we want to immediately execute the query we can do so.Immediately query execution will immediately execute the query as soon as we assign the query to the query variable.
We can immediately execute the query by any of the following ways

1.By calling aggregate method such as count.We use this when we need to retrieve a single value such as count of the elements contained in the results collection.

var results = (from student in students
where student.Class == 12
select student).Count();

2.By calling the collection methods such as ToList().We use this when we need to convert the results variable to list value such as count of the elements contained in the results collection.

var results = (from student in students
where student.Class == 12
select student).ToList();

 

Follow on:

LINQ stands for Language Integrated Query.You can use the Average method to calculate the average of numerical values in a collection.
It returns a single value which is an average of the values in the collection.

If we execute the following then we get the average as 3.

IList<int> list = new List<int>() {1,2,3,4,5};
var avg= list.Average();
Console.WriteLine(avg);

Other than int average can be used with double,float or decimal values also.Following  Average function call returns the value 3.2

IList<float> list = new List<float>() {1.5f,2f,3f,4.5f,5f};
var avg= list.Average();
Console.WriteLine(avg);

Calculating average of specific items in a collection using Average function

In the following example we  are calculating average of list items after filtering the items.

We have declared student class as:

class Student
{
public string Name { get; set; }
public string Subject { get; set; }
public int Marks { get; set; }
}

We can calculate the marks of a particular student by using the following

IList<Student> list = new List<Student>() {
new Student{Name="Mark",Subject="Maths",Marks=60},
new Student{Name="John",Subject="English",Marks=66},
new Student{Name="Mark",Subject="English",Marks=76},
new Student{Name="Ajay",Subject="Maths",Marks=66}

};
var avg= list.Where(x=>x.Name=="Mark").Select(x=>x.Marks).Average();
Console.WriteLine(avg);

 

Follow on:

In SQL we have the requirement to filter the results based on a maximum or a minimum value.We use the top operator in SQL server to filter the top results based on a criteria.

We can achieve similar functionality in LINQ using the Take() and TakeWhile() extension methods.Take extension method returns the specified number of elements.TakeWhile returns the elements from a collection as long as the specified predicate returns true.

Example of Take method

We have a list of students.Each student has a RollNo and TotalMarks property.Suppose we want to display the top most students who have scored most marks.We can very easily implement this using the Take() method.

Suppose our list contains the elements as:

List<Student> lstStudents = new List<Student>();
lstStudents.Add(new Student {RollNo=1,TotalMarks=400 });
lstStudents.Add(new Student { RollNo =2, TotalMarks = 450 });
lstStudents.Add(new Student { RollNo = 3, TotalMarks = 350 });
lstStudents.Add(new Student { RollNo = 4, TotalMarks = 500 });
lstStudents.Add(new Student { RollNo = 5, TotalMarks = 650 });
lstStudents.Add(new Student { RollNo = 6, TotalMarks = 350 });
lstStudents.Add(new Student { RollNo = 7, TotalMarks = 456 });
lstStudents.Add(new Student { RollNo = 8, TotalMarks = 368 });

We can select the top 5 students who have scored most marks as:

var TopFive = (from student in lstStudents
orderby student.TotalMarks
select student).Take(5);

We first order the students based on the total marks .Then we select the top 5 students using the Take() method.

We display the filtered students as:

int iRank = 1;
foreach (var student in TopFive)
{
Console.WriteLine(string.Format("Roll No={0},Rank={1}",student.RollNo,iRank));
iRank++;
}

Above will print the following Student values

Roll No=3,Rank=1
Roll No=6,Rank=2
Roll No=8,Rank=3
Roll No=1,Rank=4
Roll No=2,Rank=5

Example of TakeWhile method

TakeWhile method includes the elements in the list till the predicate passed as the parameter returns true.TakeWhile method exits and does not include any more elements in the list as soon as the predicate returns false.

Suppose we want to display the list of students who have scored more than 400 TotalMarks then we can use the TakeWhile() method.

var  MinimumMarks = (from student in lstStudents orderby student.TotalMarks descending 
select student).TakeWhile(x=>x.TotalMarks>400);

Please note that we are ordering the students based on the TotalMarks.This is required since the TakeWhile method exits as soon as the predicate returns the first false value.

Above list will contain the following Student elements

Roll No=5,TotalMarks=650
Roll No=4,TotalMarks=500
Roll No=7,TotalMarks=456
Roll No=2,TotalMarks=450

Follow on:

Join clause in LINQ is used when we have multiple data sources and we want to match the elements in those data sources based on some common property.For example we can have two Lists and we want to associate every element in the first list with the elements in the second list.

In the following example we have two classes Employee and Department.Employee class represents an employee.Every employee has an Id,Name,DepartmentId and Designation.
Department class defines the Name and Id.If we want to get the department name to which an employee belongs to then we need to match the Employee class and the Department class.We can match these two classes on the common DepartmentId property which is declared in the Department class as Id property.

class Employee
{
public int Id { get; set; }
public int DepartmentId { get; set; }
public string Name { get; set; }
public string Designation { get; set; }
}

class Department
{
public string Name { get; set; }
public int Id { get; set; }
}

We create two lists which contains the objects of Employee and Department types.

List<Employee> lstEmployees = new List<Employee>();
lstEmployees.Add(new Employee {Name = "Ajay", DepartmentId = 1, Id = 1});
lstEmployees.Add(new Employee { Name = "Amit", DepartmentId = 1, Id = 2 });
lstEmployees.Add(new Employee { Name = "John", DepartmentId = 2, Id = 3 });
lstEmployees.Add(new Employee { Name = "Mark", DepartmentId = 2, Id = 4 });


List<Department> lstDepartments = new List<Department>();
lstDepartments.Add(new Department { Name = "Sales", Id = 1});
lstDepartments.Add(new Department { Name = "Marketing", Id = 2});

As every employee in the lstEmployees list has a departmentId so we can use inner join to retrieve the department name to which an employee belongs to.

var empDept = from employee in lstEmployees
join department in lstDepartments
on employee.DepartmentId equals department.Id 
select new
{
EmployeeName = employee.Name,
Department = department.Name
};

If we iterate over the empDept list using the following loop

foreach (var empDept in results)
{
Console.WriteLine("Employee Name={0},Department={1}", empDept.EmployeeName,empDept.Department);
}

then we get the following output

Employee Name=Ajay,Department=Sales
Employee Name=Amit,Department=Sales
Employee Name=John,Department=Marketing
Employee Name=Mark,Department=Marketing

Lets say there is an employee Rachel who has not been assigned to any department yet.

lstEmployees.Add(new Employee { Name = "Rachel", DepartmentId = 0, Id = 4 });

So if we use inner join then since Rachel has not been assigned to any department will not be included in the join.To include such elements which are present in only one table we use left outer join

var results =
from employee in lstEmployees
join department in lstDepartments on employee.DepartmentId equals department.Id into prodGroup
from j in prodGroup.DefaultIfEmpty(new Department() { Name = "Unassigned" })
select new
{
DeptName = j.Id,
EmpName = employee.Name,
EmpDesignation=employee.Designation
};

This will give us the following output:

Employee Name=Ajay,Department=1,Designation=Manager
Employee Name=Amit,Department=1,Designation=Team Lead
Employee Name=John,Department=2,Designation=Customer Care Executive
Employee Name=Mark,Department=2,Designation=Manager
Employee Name=Rachel,Department=0,Designation=

Even though Rachel is not assigned to any Department ,she is included in the result because of left outer join.

Follow on: