101 LINQ Samples: Set Operators

Distinct - 1

This sample uses Distinct to remove duplicate elements in a sequence of factors of 300.

public void Linq46()
{
    int[] factorsOf300 = { 2, 2, 3, 5, 5 };
 
    var uniqueFactors = factorsOf300.Distinct();
 
    Console.WriteLine("Prime factors of 300:");
    foreach (var f in uniqueFactors)
    {
        Console.WriteLine(f);
    }
}

Result

Prime factors of 300:
2
3
5

Distinct - 2

This sample uses Distinct to find the unique Category names.

public void Linq47()
{
    List<Product> products = GetProductList();
 
    var categoryNames = (
        from p in products
        select p.Category)
        .Distinct();
 
    Console.WriteLine("Category names:");
    foreach (var n in categoryNames)
    {
        Console.WriteLine(n);
    }
}

Result

Category names:
Beverages
Condiments
Produce
Meat/Poultry
Seafood
Dairy Products
Confections
Grains/Cereals

Union - 1

This sample uses Union to create one sequence that contains the unique values from both arrays.

public void Linq48()
{
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 8 };
 
    var uniqueNumbers = numbersA.Union(numbersB);
 
    Console.WriteLine("Unique numbers from both arrays:");
    foreach (var n in uniqueNumbers)
    {
        Console.WriteLine(n);
    }
}

Result

Unique numbers from both arrays:
0
2
4
5
6
8
9
1
3
7

Union - 2

This sample uses Union to create one sequence that contains the unique first letter from both product and customer names.

public void Linq49()
{
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();
 
    var productFirstChars =
        from p in products
        select p.ProductName[0];
    var customerFirstChars =
        from c in customers
        select c.CompanyName[0];
 
    var uniqueFirstChars = productFirstChars.Union(customerFirstChars);
 
    Console.WriteLine("Unique first letters from Product names and Customer names:");
    foreach (var ch in uniqueFirstChars)
    {
        Console.WriteLine(ch);
    }
}

Result

Unique first letters from Product names and Customer names:
C
A
G
U
N
M
I
Q
K
T
P
S
R
B
J
Z
V
F
E
W
L
O
D
H

Intersect - 1

This sample uses Intersect to create one sequence that contains the common values shared by both arrays.

public void Linq50()
{
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 8 };
 
    var commonNumbers = numbersA.Intersect(numbersB);
 
    Console.WriteLine("Common numbers shared by both arrays:");
    foreach (var n in commonNumbers)
    {
        Console.WriteLine(n);
    }
}

Result

Common numbers shared by both arrays:
5
8

Intersect - 2

This sample uses Intersect to create one sequence that contains the common first letter from both product and customer names.

public void Linq51()
{
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();
 
    var productFirstChars =
        from p in products
        select p.ProductName[0];
    var customerFirstChars =
        from c in customers
        select c.CompanyName[0];
 
    var commonFirstChars = productFirstChars.Intersect(customerFirstChars);
 
    Console.WriteLine("Common first letters from Product names and Customer names:");
    foreach (var ch in commonFirstChars)
    {
        Console.WriteLine(ch);
    }
}

Result

Common first letters from Product names and Customer names:
C
A
G
N
M
I
Q
K
T
P
S
R
B
V
F
E
W
L
O

Except - 1

This sample uses Except to create a sequence that contains the values from numbersAthat are not also in numbersB.

public void Linq52()
{
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 8 };
 
    IEnumerable<int> aOnlyNumbers = numbersA.Except(numbersB);
 
    Console.WriteLine("Numbers in first array but not second array:");
    foreach (var n in aOnlyNumbers)
    {
        Console.WriteLine(n);
    }
}

Result

Numbers in first array but not second array:
0
2
4
6
9

Except - 2

This sample uses Except to create one sequence that contains the first letters of product names that are not also first letters of customer names.

public void Linq53()
{
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();
 
    var productFirstChars =
        from p in products
        select p.ProductName[0];
    var customerFirstChars =
        from c in customers
        select c.CompanyName[0];
 
    var productOnlyFirstChars = productFirstChars.Except(customerFirstChars);
 
    Console.WriteLine("First letters from Product names, but not from Customer names:");
    foreach (var ch in productOnlyFirstChars)
    {
        Console.WriteLine(ch);
    }
}

Result

First letters from Product names, but not from Customer names:
U
J
Z