Back to: LINQ Tutorial For Beginners and Professionals
LINQ Where Filtering Method in C# with Examples
In this article, I am going to discuss LINQ Where Filtering Method in C# with Examples. Please read our previous article where we discussed the LINQ SelectMany Projection Method in C# with Examples. At the end of this article, you will understand the following concepts.
- What is Filtering?
- What are the Filtering Methods available in LINQ?
- The “Where” Method and its Examples using both Method and Query Syntax
- What is a Predicate?
What is Filtering?
Filtering is nothing but the process to get only those elements from a data source that satisfied the given condition. It is also possible to fetch the data from a data source with more than one condition as per our business requirements. For example:
- Employees having a salary greater than 50000.
- Students Having Marks greater than 80% from a particular batch.
- Employees having experience of more than 6 Years and the department is IT, etc.
What are the Filtering Methods Available in LINQ?
There are two methods provided by LINQ in C# which are used for filtering. They are as follows:
- Where Method
- OfType Method
In this article, I am going to discuss the LINQ Where Method in detail with Examples. In the next article, I am going to discuss the LINQ OfType Method with Examples.
LINQ Where Filtering Operator or Method:
The standard query operator “Where” comes under the Filtering Operators category in LINQ. We need to use the Where standard query operator or method in LINQ when we need to filter the data returned from a data source based on some condition(s) just like we did in SQL using the Where clause. So in simple words, we can say that it is used to filter the data from a data source based on some condition(s).
The “Where” Method always expects at least one condition and we can specify the condition(s) using predicates. The conditions can be written using the ==, >=, <=, &&, ||, >, <, etc. symbols. There are two overloaded versions of the “Where” Method available in LINQ. They are as follows:
As you can see in the above signatures, the methods are implemented as extension methods on IEnumerable<T> interface. The methods accept a predicate as a parameter. So let us first understand what a predicate is.
What is a Predicate in C#?
A Predicate is nothing but a function or technically you can say a delegate that is used to test each and every element for a given condition. Let us understand this with an example. In the below example, the Lambda expression (num => num > 5) runs for each and every element present in the “intList” collection. Then it will check, whether the number is greater than 5 or not. If the number value is greater than 5, then a boolean value true is returned otherwise false. In the below example, I am showing both Method and Query Syntax.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
List<int> intList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//Method Syntax
IEnumerable<int> filteredData = intList.Where(num => num > 5);
//Query Syntax
IEnumerable<int> filteredResult = from num in intList
where num > 5
select num;
foreach (int number in filteredData)
{
Console.WriteLine(number);
}
Console.ReadKey();
}
}
}
When we execute the above program, it will give us the following output as expected.
When you hover the mouse over the WHERE extension method in the above example, then visual studio intelligence shows the following.
As you can see in the above image, the Predicate (Func<int, bool> predicate) expects one input parameter of type integer and it returns a boolean value. The Func is a generic delegate that takes one or more input parameters and returns one out parameter. The last parameter is considered the return value. The return type is mandatory but the input parameter is not.
If you are new to Generic Delegate, then I strongly recommended you read the following article where we discussed the Generic Delegates in C# with Examples.
https://dotnettutorials.net/lesson/generic-delegates-csharp/
The lambda expression that we passed to the Where extension method in the above example operates on integer data type and should return a boolean value else we will get a compile-time error. So the following line of code from the above example
IEnumerable<int> filteredData = intList.Where(num => num > 5);
Can be rewritten as shown below
Func<int, bool> predicate = i => i > 5;
IEnumerable<int> filteredData = intList.Where(predicate);
It should give the same output as expected. You can also create a separate function as shown below which also works as expected.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
List<int> intList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//Method Syntax
IEnumerable<int> filteredData = intList.Where(num => CheckNumber(num));
foreach (int number in filteredData)
{
Console.WriteLine(number);
}
Console.ReadKey();
}
public static bool CheckNumber(int number)
{
if (number > 5)
{
return true;
}
else
{
return false;
}
}
}
} Example to Understand the Second Overloaded Version of the Where Method in LINQ:
In the second overloaded version of the “Where” extension method, the int parameter of the predicate function represents the index position of the source element.
public static IEnumerable<TSource> Where<TSource>(
this IEnumerable<TSource> source,
Func<TSource, int, bool> predicate);
Let us see an example to understand this. Here we need to filter only the odd numbers i.e. the numbers which are not divisible by 2. Along with the numbers we also need to fetch the index position of the number. The index is 0 based.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
List<int> intList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//Method Syntax
var OddNumbersWithIndexPosition = intList.Select((num, index) => new
{
Numbers = num,
IndexPosition = index
}).Where(x => x.Numbers % 2 != 0)
.Select(data => new
{
Number = data.Numbers,
IndexPosition = data.IndexPosition
});
foreach (var item in OddNumbersWithIndexPosition)
{
Console.WriteLine($"IndexPosition :{item.IndexPosition} , Value : {item.Number}");
}
Console.ReadKey();
}
}
} Now run the application and you will see the odd numbers along with their index position as shown below.
Let’s rewrite the same example using LINQ Query Syntax.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
List<int> intList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//Query Syntax
var OddNumbersWithIndexPosition = from number in intList.Select((num, index) => new {Numbers = num, IndexPosition = index })
where number.Numbers % 2 != 0
select new
{
Number = number.Numbers,
IndexPosition = number.IndexPosition
};
foreach (var item in OddNumbersWithIndexPosition)
{
Console.WriteLine($"IndexPosition :{item.IndexPosition} , Value : {item.Number}");
}
Console.ReadKey();
}
}
} Now run the application and it will also give the same output as the method syntax output as shown in the below image.
Complex Example to Understand LINQ Where Extension Method using C#:
Let us see how to use the LINQ Where Extension Method with Complex Data Type using C#. We are going to use the following Employee class. So, create a class file with the name Employee.cs and then copy and paste the following code into it. As we can see. we created the following Employee class with five properties i.e. ID, Name, Gender, Salary, and Technology. Here, we have also created one method which will return the list of all employees which will be going to our data source.
using System.Collections.Generic;
namespace LINQDemo
{
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
public string Gender { get; set; }
public int Salary { get; set; }
public List<string> Technology { get; set; }
public static List<Employee> GetEmployees()
{
List<Employee> employees = new List<Employee>()
{
new Employee {ID = 101, Name = "Preety", Gender = "Female", Salary = 60000,
Technology = new List<string>() {"C#", "Jave", "C++"} },
new Employee {ID = 102, Name = "Priyanka", Gender = "Female", Salary = 50000,
Technology =new List<string>() { "WCF", "SQL Server", "C#" } },
new Employee {ID = 103, Name = "Hina", Gender = "Female", Salary = 40000,
Technology =new List<string>() { "MVC", "Jave", "LINQ"}},
new Employee {ID = 104, Name = "Anurag", Gender = "Male", Salary = 450000},
new Employee {ID = 105, Name = "Sambit", Gender = "Male", Salary = 550000},
new Employee {ID = 106, Name = "Sushanta", Gender = "Male", Salary = 700000,
Technology =new List<string>() { "ADO.NET", "C#", "LINQ" }}
};
return employees;
}
}
} Now, we need to fetch all the employees whose salary is greater than 50000. For this, we need to use the LINQ Where Extension Method and we need to specify the condition as emp => emp.Salary > 50000 using Method Syntax and employee.Salary > 50000 using Query Syntax which is shown in the below example.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Query Syntax
var QuerySyntax = from employee in Employee.GetEmployees()
where employee.Salary > 50000
select employee;
//Method Syntax
var MethodSyntax = Employee.GetEmployees()
.Where(emp => emp.Salary > 50000);
foreach (var emp in QuerySyntax)
{
Console.WriteLine($"Name : {emp.Name}, Salary : {emp.Salary}, Gender : {emp.Gender}");
if(emp.Technology != null && emp.Technology.Count() > 0)
{
Console.Write(" Technology : ");
foreach (var tech in emp.Technology)
{
Console.Write(tech + " ");
}
Console.WriteLine();
}
else
{
Console.WriteLine(" Technology Not Available ");
}
}
Console.ReadKey();
}
}
} Output:
Example to Understand How to Specify Multiple Conditions using LINQ Where Method in C#
We need to fetch all the employees whose gender is Male and also whose Salary is greater than 500000. So, here we have two conditions. The first condition is Gender = Male and the second condition is Salary > 500000. If we have more than one condition, then we need to use && (AND) or || (OR) logical Operators based on our requirement. Here, we are going to use the AND (&&). That means if both the conditions satisfy then only return the data.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Query Syntax
var QuerySyntax = from employee in Employee.GetEmployees()
where employee.Salary > 500000 && employee.Gender == "Male"
select employee;
//Method Syntax
var MethodSyntax = Employee.GetEmployees()
.Where(emp => emp.Salary > 500000 && emp.Gender == "Male")
.ToList();
foreach (var emp in MethodSyntax)
{
Console.WriteLine($"Name : {emp.Name}, Salary : {emp.Salary}, Gender : {emp.Gender}");
if(emp.Technology != null && emp.Technology.Count() > 0)
{
Console.Write(" Technology : ");
foreach (var tech in emp.Technology)
{
Console.Write(tech + " ");
}
Console.WriteLine();
}
else
{
Console.WriteLine(" Technology Not Available ");
}
}
Console.ReadKey();
}
}
}
Output:
Complex Example to Understand LINQ Where Method:
Let us see a more complex example to understand the LINQ Where Extension Method. Now, we are going to provide Multiple conditions with the custom operations and project the data to an anonymous type. The following is our business requirement.
We need to fetch all the employees whose salary is greater than or equal to 50000 and technology should not be null. And we need to project the following information to an anonymous type.
- Name as it is
- Gender as it is
- MonthlySalary = Salary / 12
The Complete Example Code is Given Below. In the below example, I am showing both the Method and Query syntax with the Where Extension Method to achieve the above requirement.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Query Syntax
var QuerySyntax = (from employee in Employee.GetEmployees()
where employee.Salary >= 50000 && employee.Technology != null
select new {
EmployeeName = employee.Name,
Gender = employee.Gender,
MonthlySalary = employee.Salary / 12
}).ToList();
//Method Syntax
var MethodSyntax = Employee.GetEmployees()
.Where(emp => emp.Salary >= 50000 && emp.Technology != null)
.Select(emp => new {
EmployeeName = emp.Name,
Gender = emp.Gender,
MonthlySalary = emp.Salary / 12
})
.ToList();
foreach (var emp in QuerySyntax)
{
Console.WriteLine($"Name : {emp.EmployeeName}, Gender : {emp.Gender}, Monthly Salary : {emp.MonthlySalary}");
}
Console.ReadKey();
}
}
} Output:
Example to Fetch Elements along with their Index position using Where Method in C#
Now, we need to fetch all the employees whose Gender is Male and whose Salary is greater than 500000 along with their index position to an anonymous type.
using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Query Syntax
var QuerySyntax = (from data in Employee.GetEmployees().Select((Data, index) => new { employee = Data, Index = index })
where data.employee.Salary >= 500000 && data.employee.Gender == "Male"
select new
{
EmployeeName = data.employee.Name,
Gender = data.employee.Gender,
Salary = data.employee.Salary,
IndexPosition = data.Index
}).ToList();
//Method Syntax
var MethodSyntax = Employee.GetEmployees().Select((Data, index) => new { employee = Data, Index = index })
.Where(emp => emp.employee.Salary >= 500000 && emp.employee.Gender == "Male")
.Select(emp => new
{
EmployeeName = emp.employee.Name,
Gender = emp.employee.Gender,
Salary = emp.employee.Salary,
IndexPosition = emp.Index
})
.ToList();
foreach (var emp in QuerySyntax)
{
Console.WriteLine($"Position : {emp.IndexPosition} Name : {emp.EmployeeName}, Gender : {emp.Gender}, Salary : {emp.Salary}");
}
Console.ReadKey();
}
}
} Output:
In the next article, I am going to discuss the LINQ OfType Operator using C# with Examples. I hope this article gives you a very good understanding of the LINQ Where Filtering Method in C# with Examples.
