Of the classes that provide support for LINQ is the IEnumerable generic interface. In reality, a LINQ statement is an object of type IEnumerable. Based on this, instead of the Dim keyword, you can declare the statement using that interface. Inside the parentheses, enter the type of list that the collection variable contains. Here is an example: Imports System.Linq
Imports System.Collections.Generic
Public Class Employee
Public EmployeeNumber As Integer
Public FirstName As String
Public LastName As String
Public HourlySalary As Double
Public Sub New(Optional ByVal Number As Integer = 0,
Optional ByVal FName As String = "John",
Optional ByVal LName As String = "Doe",
Optional ByVal salary As Double = 0D)
EmployeeNumber = Number
FirstName = FName
LastName = LName
HourlySalary = salary
End Sub
End Class
Module Exercise
Public Function Main() As Integer
Dim Employees() As Employee =
{
New Employee(971974, "Patricia", "Katts", 24.68),
New Employee(208411, "Raymond", "Kouma", 20.15),
New Employee(279374, "Hélène", "Mukoko", 15.55),
New Employee(707912, "Bertrand", "Yamaguchi", 24.68),
New Employee(294800, "Peter", "Mukoko", 18.85),
New Employee(971394, "Gertrude", "Monay", 20.55)
}
Dim Empls As IEnumerable(Of Employee) = From StaffMembers
In Employees
Select StaffMembers
Console.WriteLine("+========+============+===========+========+")
Console.WriteLine("| Empl # | First Name | Last Name | Salary |")
For Each Staff In empls
Console.WriteLine("+--------+------------+-----------+--------+")
Console.WriteLine("| {0,6} | {1,-10} | {2,-9} | {3,6} |",
Staff.EmployeeNumber, Staff.FirstName,
Staff.LastName, Staff.HourlySalary)
Next
Console.WriteLine("+=======+============+===========+=========+")
Console.WriteLine()
Return 0
End Function
End Module
This would produce:
Instead of processing a query locally, you can hand the job to an external method that would return the query. To create a method that returns a query, specify its return type as IEnumerable. If the method will receive the value it must process, you can pass it as argument. In the body of the method, create a (the) LINQ statement(s) as you see fit. Before the method closes, make sure it returns a value that either is of type IEnumerable or implements that interface. Here is an example: Imports System.Linq
Imports System.Collections.Generic
Module Exercise
Function GetQuery(ByVal List As Double()) As IEnumerable(Of Double)
Return From N In List Select N
End Function
Public Function Main() As Integer
Dim Numbers() = {12.44, 525.38, 6.28, 2448.32, 632.04}
Dim number = GetQuery(numbers)
For Each Member In number
Console.WriteLine(Member)
Next
Console.WriteLine()
Return 0
End Function
End Module
This would produce:
In this example, we used a method that returned a list of simple values. In the same way, you can create a method that returns a list of objects. You can also create a method that returns a single value from a query.
Besides, or instead of, the Select statement in LINQ, the IEnumerable interface provides its own mechanism for selecting the values. This can be done using the Select() method that is overloaded with two versions whose syntaxes are: <ExtensionAttribute> _
Public Shared Function Select(Of TSource, TResult) ( _
source As IEnumerable(Of TSource), _
selector As Func(Of TSource, TResult) _
) As IEnumerable(Of TResult)
<ExtensionAttribute> _
Public Shared Function Select(Of TSource, TResult) ( _
source As IEnumerable(Of TSource), _
selector As Func(Of TSource, Integer, TResult) _
) As IEnumerable(Of TResult)
This method expects a variable that would hold the result of the selection. You can pass it a lambda expression. You don't have to specify the TSource and the TResult classes. After doing this, the IEnumerable variable can be used in a foreach loop. Here is an example: Imports System.Linq
Imports System.Collections.Generic
Public Class Employee
Public EmployeeNumber As Integer
Public FirstName As String
Public LastName As String
Public HourlySalary As Double
Public Sub New(Optional ByVal Number As Integer = 0,
Optional ByVal FName As String = "John",
Optional ByVal LName As String = "Doe",
Optional ByVal salary As Double = 0D)
EmployeeNumber = Number
FirstName = FName
LastName = LName
HourlySalary = salary
End Sub
End Class
Module Exercise
Public Function Main() As Integer
Dim Employees() As Employee =
{
New Employee(971974, "Patricia", "Katts", 24.68),
New Employee(208411, "Raymond", "Kouma", 20.15),
New Employee(279374, "Hélène", "Mukoko", 15.55),
New Employee(707912, "Bertrand", "Yamaguchi", 24.68),
New Employee(294800, "Peter", "Mukoko", 18.85),
New Employee(971394, "Gertrude", "Monay", 20.55)
}
Dim Empls As IEnumerable(Of Employee) =
Employees.Select(Function(StaffMembers) StaffMembers)
Console.WriteLine("+========+============+===========+========+")
Console.WriteLine("| Empl # | First Name | Last Name | Salary |")
For Each Staff In empls
Console.WriteLine("+--------+------------+-----------+--------+")
Console.WriteLine("| {0,6} | {1,-10} | {2,-9} | {3,6} |",
Staff.EmployeeNumber,Staff.FirstName,
Staff.LastName, Staff.HourlySalary)
Next
Console.WriteLine("+=======+============+===========+=========+")
Console.WriteLine()
Return 0
End Function
End Module
To support conditions of a query, the Enumerable class is equipped with a method named Where that is overloaded with two versions. The syntax of one is: public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source,
Func<TSource, bool> predicate)
Here is an example of calling it: Imports System.Linq
Imports System.Collections.Generic
Module Exercise
Public Function Main() As Integer
Dim Numbers() = { 637.58, 48.5, 12.44, 525.38,
45.3, 6.28, 2448.32, 632.04}
Dim ListOfNumbers = From N
In Numbers
Select N
For Each Number In ListOfNumbers
Console.WriteLine(Number)
Next
Console.WriteLine("=+=+=+=+=+=+=+")
Dim ListWhere = (From N
In Numbers
Select N).Where(Function(high) high > 500)
For Each WhereCondition In ListWhere
Console.WriteLine(WhereCondition)
Next
Console.WriteLine()
Return 0
End Function
End Module
This would produce:
If you have a simple list of values of a primitive type and the LINQ variable is declared using the var keyword, we saw that you could sort it using the orderby operator. If the list is made of values that each is based on a class, you can also sort it the same way, in the IEnumerable expression. Here is an example: IEnumerable(Of Employee) empls = from staffMembers
in employees
orderby staffMembers.LastName
select staffMembers;
To support the ability to sort the values, the IEnumerable interface provides its own OrderBy() method that is overloaded with two versions. Their syntaxes are: Public Shared Function OrderBy(Of TSource, TKey) ( _
source As IEnumerable(Of TSource), _
keySelector As Func(Of TSource, TKey) _
) As IOrderedEnumerable(Of TSource)
Public Shared Function OrderBy(Of TSource, TKey) ( _
source As IEnumerable(Of TSource), _
keySelector As Func(Of TSource, TKey), _
comparer As IComparer(Of TKey) _
) As IOrderedEnumerable(Of TSource)
Here is an example: Imports System.Linq
Imports System.Collections.Generic
Public Class Employee
Public EmployeeNumber As Integer
Public FirstName As String
Public LastName As String
Public HourlySalary As Double
Public Sub New(Optional ByVal Number As Integer = 0,
Optional ByVal FName As String = "John",
Optional ByVal LName As String = "Doe",
Optional ByVal salary As Double = 0D)
EmployeeNumber = Number
FirstName = FName
LastName = LName
HourlySalary = salary
End Sub
End Class
Module Exercise
Public Function Main() As Integer
Dim Employees() As Employee =
{
New Employee(971974, "Patricia", "Katts", 24.68),
New Employee(208411, "Raymond", "Kouma", 20.15),
New Employee(279374, "Hélène", "Mukoko", 15.55),
New Employee(707912, "Bertrand", "Yamaguchi", 24.68),
New Employee(294800, "Peter", "Mukoko", 18.85),
New Employee(971394, "Gertrude", "Monay", 20.55)
}
Dim Empls As IEnumerable(Of Employee) =
Employees.OrderBy(Function(staffMembers) staffMembers.LastName)
Console.WriteLine("+========+============+===========+========+")
Console.WriteLine("| Empl # | First Name | Last Name | Salary |")
For Each Staff In empls
Console.WriteLine("+--------+------------+-----------+--------+")
Console.WriteLine("| {0,6} | {1,-10} | {2,-9} | {3,6} |",
Staff.EmployeeNumber, Staff.FirstName,
Staff.LastName, Staff.HourlySalary)
Next
Console.WriteLine("+=======+============+===========+=========+")
Console.WriteLine()
Return 0
End Function
End Module
Imagine you want to give the user the ability to sort the list but you want the list to be accessible from sections of the code. One way you can solve this problem is to declare a LINQ variable outside of the code sections but without initializing the variable, as long as you make sure the variable would be initialized before it is used. The problem with the Dim keyword is that you must initialize its variable when you declare it. The advantage with an IEnumerable variable is that you do not have to initialize it when declaring it. You can declare it, then specify its value in another section of the code. |
|
|||||||||||||||||||||||
|
|
||||||||||||||||||||||||
