Author :
Complexity : Beginner

# Set Operator in LINQ

Set Operator in LINQ takes data from the different collection or same collection and returns the sequence based on requirements like combining elements, removing duplicates, etc. There are four Set Operator are available in LINQ as follow:

1. UNION
2. INTERSECT
3. DISTINCT
4. EXCEPT

Now we will discuss each operator one by one.

### UNION Operator

UNION operator is used to take data from different collections and return a sequence of unique elements. Union keyword is used for this purpose. Below are some examples in this category.

### Query to create one sequence that contains unique values from two arrays.

``````
class Program
{
static void Main(string[] args)
{
int[] numberA = { 3, 6, 9, 12, 15 };
int[] numberB = { 2, 4, 6, 8, 12 };

//Linq Query
var result_Linq = numberA.Union(numberB);

//Lambda Expression
var result_Lambda = numberA.Union(numberB);

//Display Linq Query Result
Console.WriteLine("Unique Numbers (Using Linq):");
foreach (int item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Unique Numbers (Using Lambda):");
foreach (int item in result_Lambda)
{
Console.WriteLine(item);
}

}
}``````

Output

``````Unique Numbers (Using Linq):
3
6
9
12
15
2
4
8
Unique Numbers (Using Lambda):
3
6
9
12
15
2
4
8``````

### Query to create one sequence that contains unique names from employee names and manager names.

``````public class Employee
{
public string Emp_Name { get; set; }
public string Emp_Department { get; set; }
public int Emp_Salary { get; set; }
}

class Program
{
static void Main(string[] args)
{
List<Employee> employees = GetEmployeeList();
List<Employee> managers = GetManagerList();

//Linq Query
var employee_Name = from p in employees select p.Emp_Name;
var employee_Dept = from p in managers select p.Emp_Name;
var result_Linq = employee_Name.Union(employee_Dept);

//Lambda Expression
var employee_Name_L = employees.Select(p => p.Emp_Name);
var employee_Dept_L = managers.Select(p => p.Emp_Name);
var result_Lambda = employee_Name_L.Union(employee_Dept_L);

//Display Linq Query Result
Console.WriteLine("Unique Names between Employee Name and Manager Name (Using Linq):");
foreach (string item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Unique Names between Employee Name and Manager Name (Using Lambda):");
foreach (string item in result_Lambda)
{
Console.WriteLine(item);
}

}

/// <summary>
/// Method to get employee list
/// </summary>
/// <returns></returns>
private static List<Employee> GetEmployeeList()
{
List<Employee> employees = new List<Employee>();
employees.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 70000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 20000, Emp_Department = "HR" });
employees.Add(new Employee() { Emp_Name = "Suresh", Emp_Salary = 40000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Nitish", Emp_Salary = 80000, Emp_Department = "Account" });
return employees;
}

/// <summary>
/// Method to get manager list
/// </summary>
/// <returns></returns>
private static List<Employee> GetManagerList()
{
List<Employee> managers = new List<Employee>();
managers.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 170000, Emp_Department = "IT" });
managers.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 120000, Emp_Department = "HR" });
managers.Add(new Employee() { Emp_Name = "Sandeep", Emp_Salary = 140000, Emp_Department = "IT" });
managers.Add(new Employee() { Emp_Name = "Neeraj", Emp_Salary = 180000, Emp_Department = "Account" });
return managers;
}
}``````

Output

``````Unique Names between Employee Name and Manager Name (Using Linq):
Rahul
Amit
Suresh
Nitish
Sandeep
Neeraj
Unique Names between Employee Name and Manager Name (Using Lambda):
Rahul
Amit
Suresh
Nitish
Sandeep
Neeraj``````

### INTERSECT Operator

INTERSECT Operator is used to take data from different collections and return a sequence of common elements. Intersect keyword is used for this purpose. Below are some examples in this category.

### Query to create one sequence that contains common values from two arrays.

``````class Program
{
static void Main(string[] args)
{
int[] numberA = { 3, 6, 9, 12, 15 };
int[] numberB = { 2, 4, 6, 8, 12 };

//Linq Query
var result_Linq = numberA.Intersect(numberB);

//Lambda Expression
var result_Lambda = numberA.Intersect(numberB);

//Display Linq Query Result
Console.WriteLine("Common Numbers (Using Linq):");
foreach (int item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Common Numbers (Using Lambda):");
foreach (int item in result_Lambda)
{
Console.WriteLine(item);
}

}
}``````

Output

``````Common Numbers (Using Linq):
6
12
Common Numbers (Using Lambda):
6
12``````

### Query to create one sequence that contains common names from employee names and manager names.

``````public class Employee
{
public string Emp_Name { get; set; }
public string Emp_Department { get; set; }
public int Emp_Salary { get; set; }
}

class Program
{
static void Main(string[] args)
{
List<Employee> employees = GetEmployeeList();
List<Employee> managers = GetManagerList();

//Linq Query
var employee_Name = from p in employees select p.Emp_Name;
var employee_Dept = from p in managers select p.Emp_Name;
var result_Linq = employee_Name.Intersect(employee_Dept);

//Lambda Expression
var employee_Name_L = employees.Select(p => p.Emp_Name);
var employee_Dept_L = managers.Select(p => p.Emp_Name);
var result_Lambda = employee_Name_L.Intersect(employee_Dept_L);

//Display Linq Query Result
Console.WriteLine("Common Names between Employee Name and Manager Name (Using Linq):");
foreach (string item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Common Names between Employee Name and Manager Name (Using Lambda):");
foreach (string item in result_Lambda)
{
Console.WriteLine(item);
}

}

/// <summary>
/// Method to get employee list
/// </summary>
/// <returns></returns>
private static List<Employee> GetEmployeeList()
{
List<Employee> employees = new List<Employee>();
employees.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 70000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 20000, Emp_Department = "HR" });
employees.Add(new Employee() { Emp_Name = "Suresh", Emp_Salary = 40000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Nitish", Emp_Salary = 80000, Emp_Department = "Account" });
return employees;
}

/// <summary>
/// Method to get manager list
/// </summary>
/// <returns></returns>
private static List<Employee> GetManagerList()
{
List<Employee> managers = new List<Employee>();
managers.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 170000, Emp_Department = "IT" });
managers.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 120000, Emp_Department = "HR" });
managers.Add(new Employee() { Emp_Name = "Sandeep", Emp_Salary = 140000, Emp_Department = "IT" });
managers.Add(new Employee() { Emp_Name = "Neeraj", Emp_Salary = 180000, Emp_Department = "Account" });
return managers;
}
}
``````

Output

``````Common Names between Employee Name and Manager Name (Using Linq):
Rahul
Amit
Common Names between Employee Name and Manager Name (Using Lambda):
Rahul
Amit``````

### DISTINCT Operator

DISTINCT Operator is used to take data from a collection and return a sequence of unique elements. Distinct keyword is used for this purpose. Below are some examples in this category.

### Query to remove duplicate elements from the number array.

``````class Program
{
static void Main(string[] args)
{
int[] numbers = { 3, 6, 6, 12, 12 };

//Linq Query
var result_Linq = (from p in numbers select p).Distinct();

//Lambda Expression
var result_Lambda = numbers.Distinct();

//Display Linq Query Result
Console.WriteLine("Distinct Numbers (Using Linq):");
foreach (int item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Distinct Numbers (Using Lambda):");
foreach (int item in result_Lambda)
{
Console.WriteLine(item);
}

}
}``````

Output

``````Distinct Numbers (Using Linq):
3
6
12
Distinct Numbers (Using Lambda):
3
6
12``````

### Query to find unique department names from the employee list.

``````public class Employee
{
public string Emp_Name { get; set; }
public string Emp_Department { get; set; }
public int Emp_Salary { get; set; }
}

class Program
{
static void Main(string[] args)
{
List<Employee> employees = GetEmployeeList();

//Linq Query
var result_Linq = (from p in employees select p.Emp_Department).Distinct();

//Lambda Expression
var result_Lambda = employees.Select(p=>p.Emp_Department).Distinct();

//Display Linq Query Result
Console.WriteLine("Distinct Employee Department (Using Linq):");
foreach (string item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Distinct Employee Department (Using Lambda):");
foreach (string item in result_Lambda)
{
Console.WriteLine(item);
}

}

/// <summary>
/// Method to get employee list
/// </summary>
/// <returns></returns>
private static List<Employee> GetEmployeeList()
{
List<Employee> employees = new List<Employee>();
employees.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 70000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 20000, Emp_Department = "HR" });
employees.Add(new Employee() { Emp_Name = "Suresh", Emp_Salary = 40000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Nitish", Emp_Salary = 80000, Emp_Department = "Account" });
return employees;
}
}``````

Output

``````Distinct Employee Department (Using Linq):
IT
HR
Account
Distinct Employee Department (Using Lambda):
IT
HR
Account``````

### EXCEPT Operator

EXCEPT Operator takes data from different collections and returns a sequence of elements from the first collection, which is not present in the second collection. Except keyword is used for this purpose. Below are some examples in this category.

### Query to create one sequence that contains values from the first array but not in the second array.

``````class Program
{
static void Main(string[] args)
{
int[] numberA = { 3, 6, 9, 12, 15 };
int[] numberB = { 2, 4, 6, 8, 12 };

//Linq Query
var result_Linq = numberA.Except(numberB);

//Lambda Expression
var result_Lambda = numberA.Except(numberB);

//Display Linq Query Result
Console.WriteLine("Numbers not in second array (Using Linq):");
foreach (int item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Numbers not in second array (Using Lambda):");
foreach (int item in result_Lambda)
{
Console.WriteLine(item);
}

}
}``````

Output

``````Numbers not in second array (Using Linq):
3
9
15
Numbers not in second array (Using Lambda):
3
9
15``````

### Query to create one sequence that contains names from employee names, not manager names.

``````public class Employee
{
public string Emp_Name { get; set; }
public string Emp_Department { get; set; }
public int Emp_Salary { get; set; }
}

class Program
{
static void Main(string[] args)
{
List<Employee> employees = GetEmployeeList();
List<Employee> managers = GetManagerList();

//Linq Query
var employee_Name = from p in employees select p.Emp_Name;
var employee_Dept = from p in managers select p.Emp_Name;
var result_Linq = employee_Name.Except(employee_Dept);

//Lambda Expression
var employee_Name_L = employees.Select(p => p.Emp_Name);
var employee_Dept_L = managers.Select(p => p.Emp_Name);
var result_Lambda = employee_Name_L.Except(employee_Dept_L);

//Display Linq Query Result
Console.WriteLine("Employee Names which are not in Manager Name List (Using Linq):");
foreach (string item in result_Linq)
{
Console.WriteLine(item);
}

//Display Lambda Expression Result
Console.WriteLine("Employee Names which are not in Manager Name List (Using Lambda):");
foreach (string item in result_Lambda)
{
Console.WriteLine(item);
}

}

/// <summary>
/// Method to get employee list
/// </summary>
/// <returns></returns>
private static List<Employee> GetEmployeeList()
{
List<Employee> employees = new List<Employee>();
employees.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 70000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 20000, Emp_Department = "HR" });
employees.Add(new Employee() { Emp_Name = "Suresh", Emp_Salary = 40000, Emp_Department = "IT" });
employees.Add(new Employee() { Emp_Name = "Nitish", Emp_Salary = 80000, Emp_Department = "Account" });
return employees;
}

/// <summary>
/// Method to get manager list
/// </summary>
/// <returns></returns>
private static List<Employee> GetManagerList()
{
List<Employee> managers = new List<Employee>();
managers.Add(new Employee() { Emp_Name = "Rahul", Emp_Salary = 170000, Emp_Department = "IT" });
managers.Add(new Employee() { Emp_Name = "Amit", Emp_Salary = 120000, Emp_Department = "HR" });
managers.Add(new Employee() { Emp_Name = "Sandeep", Emp_Salary = 140000, Emp_Department = "IT" });
managers.Add(new Employee() { Emp_Name = "Neeraj", Emp_Salary = 180000, Emp_Department = "Account" });
return managers;
}
}``````

Output

``````Employee Names which are not in Manager Name List (Using Linq):
Suresh
Nitish
Employee Names which are not in Manager Name List (Using Lambda):
Suresh
Nitish``````