From Clause

Specifies one or more range variables and a collection to query.

Syntax

From element [ As type ] In collection [ _ ]  
  [, element2 [ As type2 ] In collection2 [, ... ] ]  

Parts

TermDefinition elementRequired. A range variable used to iterate through the elements of the collection. A range variable is used to refer to each member of the collection as the query iterates through the collection. Must be an enumerable type. typeOptional. The type of element. If no type is specified, the type of element is inferred from collection. collectionRequired. Refers to the collection to be queried. Must be an enumerable type.

Remarks

The From clause is used to identify the source data for a query and the variables that are used to refer to an element from the source collection. These variables are called range variables. The From clause is required for a query, except when the Aggregate clause is used to identify a query that returns only aggregated results. For more information, see Aggregate Clause. You can specify multiple From clauses in a query to identify multiple collections to be joined. When multiple collections are specified, they are iterated over independently, or you can join them if they are related. You can join collections implicitly by using the Select clause, or explicitly by using the Join or Group Join clauses. As an alternative, you can specify multiple range variables and collections in a single From clause, with each related range variable and collection separated from the others by a comma. The following code example shows both syntax options for the From clause.

' Multiple From clauses in a query.
Dim result = From var1 In collection1, var2 In collection2

' Equivalent syntax with a single From clause.
Dim result2 = From var1 In collection1
              From var2 In collection2

The From clause defines the scope of a query, which is similar to the scope of a For loop. Therefore, each element range variable in the scope of a query must have a unique name. Because you can specify multiple From clauses for a query, subsequent From clauses can refer to range variables in the From clause, or they can refer to range variables in a previous From clause. For example, the following example shows a nested From clause where the collection in the second clause is based on a property of the range variable in the first clause.

Dim allOrders = From cust In GetCustomerList()
                From ord In cust.Orders
                Select ord

Each From clause can be followed by any combination of additional query clauses to refine the query. You can refine the query in the following ways:

• Combine multiple collections implicitly by using the From and Select clauses, or explicitly by using the Join or Group Join clauses.

• Use the Where clause to filter the query result.

• Sort the result by using the Order By clause.

• Group similar results together by using the Group By clause.

• Use the Aggregate clause to identify aggregate functions to evaluate for the whole query result.

• Use the Let clause to introduce an iteration variable whose value is determined by an expression instead of a collection.

• Use the Distinct clause to ignore duplicate query results.

• Identify parts of the result to return by using the Skip, Take, Skip While, and Take While clauses.

Example

The following query expression uses a From clause to declare a range variable cust for each Customer object in the customers collection. The Where clause uses the range variable to restrict the output to customers from the specified region. The For Each loop displays the company name for each customer in the query result.

Sub DisplayCustomersForRegion(ByVal customers As List(Of Customer),
                              ByVal region As String)

    Dim customersForRegion = From cust In customers
                             Where cust.Region = region

    For Each cust In customersForRegion
        Console.WriteLine(cust.CompanyName)
    Next
End Sub

See also

• Queries
• Introduction to LINQ in Visual Basic
• For Each...Next Statement
• For...Next Statement
• Select Clause
• Where Clause
• Aggregate Clause
• Distinct Clause
• Join Clause
• Group Join Clause
• Order By Clause
• Let Clause
• Skip Clause
• Take Clause
• Skip While Clause
• Take While Clause

Source/Reference

• https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/queries/
• https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/queries/from-clause