LINQ Programming: Applying a Criterion

	Applying a Criterion

Where is the Condition?

As you can see, simply using a Select statement as done above produces the same list of values in the array. A criterion is a condition applied to a set of values to find out which one(s) respond(s) to the condition or validate the condition. When applied to a list, a criterion examines each member, finds out what member responds to it, if so, adds that member to the From list.

To apply a criterion, you create a Boolean operation between the In statement and the Select statement. This criterion is actually formulated using the Where operator. The formula to use is:

Dim SubListName = From ValueHolder In List Where Condition Select ValueHolder

In the new section, the Where keyword is required. The Condition is formulated using one of the logical operators you are already familiar with. It can be in the form of:

ValueHolder = SomeValue: If ValueHolder is the same as SomeValue, the list member that is being examined is valid
ValueHolder < SomeValue: If ValueHolder is less than SomeValue, the list member that is being examined is valid
ValueHolder <= SomeValue: If ValueHolder is the same as, or lower than, SomeValue, the list member that is being examined is valid
ValueHolder > SomeValue: If ValueHolder is greater than SomeValue, the list member that is being examined is valid
ValueHolder >= SomeValue: If ValueHolder is the same as, or greater than, SomeValue, the list member that is being examined is valid
ValueHolder <> SomeValue: If ValueHolder is different from SomeValue, the list member that is being examined is valid
Not (ValueHolder = SomeValue): If ValueHolder is different from SomeValue, the list member that is being examined is valid

Remember that you must create the criterion as a Boolean operation. After applying the Select statement, you can then use it as you see fit. Here is an example:

Imports System.Linq
Imports System.Collections.Generic

Module Exercise
    Public Function Main() As Integer
        Dim Numbers = New List(Of Integer)

        Numbers.Add(12)
        Numbers.Add(45)
        Numbers.Add(38)
        Numbers.Add(5)
        Numbers.Add(128)
        Numbers.Add(525)
        Numbers.Add(2448)
        Numbers.Add(39)
        Numbers.Add(632)
        Numbers.Add(207)

        Dim Number = From N
                     In Numbers
                     Where N = 525
                     Select N

        For Each Member In Number
            Console.WriteLine(Member.ToString())
        Next

        Console.WriteLine()
        Return 0
    End Function
End Module

This would produce:

LINQ Where

Of course, the purpose of querying a list is to isolate one or more values. Base on this, you can create an expression that checks a value and applies some condition to it. For example, in a list of numbers, you may want to find out whether it contains one or more numbers that are divisible by 5. This operation can be carried by the Mod operator as in "Number Mod 5"; but Number Mod 5 is pure algebra, not Boolean. Therefore, you must add a condition to make it a valid Boolean expression. For example, you can find out if the Number Mod 5 operation is equal to 0. Here is an example:

Imports System.Linq
Imports System.Collections.Generic

Module Exercise
    Public Function Main() As Integer
        Dim Numbers = New List(Of Integer)

        Numbers.Add(12)
        Numbers.Add(45)
        Numbers.Add(38)
        Numbers.Add(5)
        Numbers.Add(128)
        Numbers.Add(525)
        Numbers.Add(2448)
        Numbers.Add(39)
        Numbers.Add(632)
        Numbers.Add(207)

        Dim Number = From N
                     In Numbers
                     Where N Mod 5 = 0
                     Select N

        For Each Member In Number
            Console.WriteLine(Member.ToString())
        Next

        Console.WriteLine()
        Return 0
    End Function
End Module

This would produce:

LINQ Where

To make the statement easier to read and less confusing, you should make it a habit to isolate the groups of statements in parentheses:

Imports System.Linq
Imports System.Collections.Generic

Module Exercise
    Public Function Main() As Integer
        Dim Numbers = New List(Of Integer)

        Numbers.Add(12)
        Numbers.Add(45)
        Numbers.Add(38)
        Numbers.Add(5)
        Numbers.Add(128)
        Numbers.Add(525)
        Numbers.Add(2448)
        Numbers.Add(39)
        Numbers.Add(632)
        Numbers.Add(207)

        Dim Number = From N
                     In Numbers
                     Where (N Mod 5) = 0
                     Select N

        For Each Member In Number
            Console.WriteLine(Member.ToString())
        Next

        Console.WriteLine()
        Return 0
    End Function
End Module

After applying a Where condition, you can sort the list using an Order By operator. For example, to get a list of odd numbers arranged in numerical order, you would write the statement as follows:

Imports System.Linq
Imports System.Collections.Generic

Module Exercise
    Public Function Main() As Integer
        Dim Numbers = New List(Of Integer)

        Numbers.Add(12)
        Numbers.Add(45)
        Numbers.Add(38)
        Numbers.Add(5)
        Numbers.Add(128)
        Numbers.Add(525)
        Numbers.Add(2448)
        Numbers.Add(39)
        Numbers.Add(632)
        Numbers.Add(207)

        Dim Number = From N
                     In Numbers
                     Where N Mod 2 <> 0
                     Order By N Ascending
                     Select N

        For Each Member In Number
            Console.WriteLine(Member.ToString())
        Next

        Console.WriteLine()
        Return 0
    End Function
End Module

This would produce:

LINQ Where

Negating a Condition

You can create a criterion that works perfectly but rather want its opposite. To get it, you can negate the expression. To do this, you use the ! operator of the C# language. To make the expression easy to read, you should include it in parentheses. That is, put the ! operator in the beginning of the logical expression followed by parentheses that include the actual logical expression. Here is an example:

Imports System.Linq
Imports System.Collections.Generic

Module Exercise
    Public Function Main() As Integer
        Dim Numbers = New List(Of Integer)

        Numbers.Add(12)
        Numbers.Add(45)
        Numbers.Add(38)
        Numbers.Add(5)
        Numbers.Add(128)
        Numbers.Add(525)
        Numbers.Add(2448)
        Numbers.Add(39)
        Numbers.Add(632)
        Numbers.Add(207)

        Dim Number = From N
                     In Numbers
                     Where Not ((N Mod 5) = 0)
                     Select N

        For Each Member In Number
            Console.WriteLine(Member.ToString())
        Next

        Console.WriteLine()
        Return 0
    End Function
End Module

This would produce:

LINQ Not

In the same way, you can negate a Where condition that involves any appropriate value.