# LINQ Min Method in C#

## LINQ Min Method in C# with Examples

In this article, I am going to discuss the LINQ Min Method in C# with examples. Please read our previous article before proceeding to this article where we discussed the LINQ Max Aggregate Method in C# with Examples.

##### What is LINQ Min Method in C#?

The LINQ Min Method belongs to the category of Aggregate Operators. This method is used to return the smallest numeric value from the collection on which it is applied.

##### Example to Understand Min Method in C#:

Let us understand the LINQ Min() method with Examples in C# using both Method and Query Syntax. The following example returns the smallest number from the collection using both query and method syntax. The point that you need to remember is the Min Method is going to work with numeric values only. In this case, the collection stores integer values, and hence we can apply the Min Method. We don’t have any operator called min in the Query Syntax. So here we need to use mixed syntax.

```using System;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
int[] intNumbers = new int[] { 60, 80, 50, 90, 10, 30, 70, 40, 20, 100 };

//Using Method Syntax
int MSLowestNumber = intNumbers.Min();

//Using Query Syntax
int QSLowestNumber = (from num in intNumbers
select num).Min();

Console.WriteLine("Lowest Number = " + MSLowestNumber);

}
}
}
```

Output: Lowest Number = 10

##### Example to Understand LINQ Min Method with Where Extension Method using C#

Let us see an example to Understand how we can use the LINQ Min Method along with the Where Extension Method in C# using both Method and Query Syntax. Now our requirement is to return the smallest number from the collection where the number is greater than 50. The following example code exactly does the same.

```using System;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
int[] intNumbers = new int[] { 60, 80, 50, 90, 10, 30, 70, 40, 20, 100 };

//Using Method Syntax
int MSLowestNumber = intNumbers.Where(num => num > 50).Min();

//Using Query Syntax
int QSLowestNumber = (from num in intNumbers
where num > 50
select num).Min();

Console.WriteLine("Lowest Number = " + MSLowestNumber);
}
}
}
```

Output: Lowest Number = 60

##### Example to Understand How to use LINQ Min Method with Predicate in C#

Let us see an example to Understand How to use LINQ Min Method with Predicate in C# using both Method and Query Syntax. Instead of using the Where Extension method to filter the data, we can also use the other overloaded version of the Min Extension method which takes a Predicate as a parameter, and using the predicate, we can write the logic to filter the data. In the below example, within the Min Method, we are using a Predicate and we are providing the condition whether the number is greater than 50 or not. If the number is greater than 50, then we are returning that number else we are returning 0. The following example will return the smallest number which is greater than 50.

```using System;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
int[] intNumbers = new int[] { 60, 80, 50, 90, 10, 30, 70, 40, 20, 100 };

//Using Method Syntax
int MSLowestNumber = intNumbers.Where(num => num > 50).Min(num => {
if (num > 50)
return num;
else
return 0;
});

Console.WriteLine("Lowest Number = " + MSLowestNumber);
}
}
}
```

Output: Lowest Number = 60

##### Example to Understand LINQ Min Method with Complex Type in C#:

Let us see an example to Understand How to use LINQ Min Method with Complex Data Type in C# using both Method and Query Syntax. We are going to work with the following Employee class. As you can see, it is a very simple class having four properties such as ID, Name, Salary, and Department. Here, we also created one method i.e. GetAllEmployees() which will return the list of all the employees and this is going to be our data source.

```using System.Collections.Generic;
namespace LINQDemo
{
public class Employee
{
public int ID { get; set; }
public string Name { get; set; }
public int Salary { get; set; }
public string Department { get; set; }

public static List<Employee> GetAllEmployees()
{
List<Employee> listStudents = new List<Employee>()
{
new Employee{ID= 101,Name = "Preety", Salary = 10000, Department = "IT"},
new Employee{ID= 102,Name = "Priyanka", Salary = 15000, Department = "Sales"},
new Employee{ID= 103,Name = "James", Salary = 50000, Department = "Sales"},
new Employee{ID= 104,Name = "Hina", Salary = 20000, Department = "IT"},
new Employee{ID= 105,Name = "Anurag", Salary = 30000, Department = "IT"},
new Employee{ID= 106,Name = "Sara", Salary = 25000, Department = "IT"},
new Employee{ID= 107,Name = "Pranaya", Salary = 35000, Department = "IT"},
new Employee{ID= 108,Name = "Manoj", Salary = 11000, Department = "Sales"},
new Employee{ID= 109,Name = "Sam", Salary = 45000, Department = "Sales"},
new Employee{ID= 110,Name = "Saurav", Salary = 25000, Department = "Sales"}
};

return listStudents;
}
}
}
```

Now, our requirement is to return the lowest salary among all the employees. The following example returns the lowest salary among all the employees using both Method and Query Syntax. Here, to the Min method, we are specifying the numeric Salary column using a lambda expression.

```using System;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Using Method Syntax
var MSLowestSalary = Employee.GetAllEmployees()
.Min(emp => emp.Salary);

//Using Query Syntax
var QSLowestSalary = (from emp in Employee.GetAllEmployees()
select emp).Min(e => e.Salary);

Console.WriteLine("Lowest Salary = " + MSLowestSalary);
}
}
}
```

Output: Lowest Salary =  10000

##### Example using Min and Where Extension Method in C#:

Let us see an example to Understand How to use both LINQ Min and Where Extension Methods with Complex Type using both Method and Query Syntax. Our requirement is to return the Lowest Salary in the IT department. The following example exactly does the same. Using the Where Extension Method we are filtering the IT department employees and using the Min method we are specifying the Salary numeric column which will return the Lowest Salary of the IT department.

```using System;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Using Method Syntax
var MSLowestSalary = Employee.GetAllEmployees()
.Where(emp => emp.Department == "IT")
.Min(emp => emp.Salary);

//Using Query Syntax
var QSLowestSalary = (from emp in Employee.GetAllEmployees()
where emp.Department == "IT"
select emp).Min(e => e.Salary);

Console.WriteLine("IT Department Lowest Salary = " + QSLowestSalary);
}
}
}
```

Output: IT Department Lowest Salary =  10000

Let’s rewrite the previous example using the custom predicate. As you can see, within the Min method, we are checking the Department property value and if the Department value is It, we are returning the corresponding Salary else we are returning null.

```using System;
using System.Linq;
namespace LINQDemo
{
class Program
{
static void Main(string[] args)
{
//Using Method Syntax and Predicate
var MinumumSalaryMS = Employee.GetAllEmployees()
.Min(emp => {
if (emp.Department == "IT")
return emp.Salary;
else
return null;
});

Console.WriteLine("IT Department Lowest Salary = " + MinumumSalaryMS);