Introducción a LINQ en Visual BasicIntroduction to LINQ in Visual Basic

Language-Integrated Query (LINQ) agrega capacidades de consulta a Visual Basic y proporciona funcionalidades sencillas y eficaces cuando se trabaja con todos los tipos de datos.Language-Integrated Query (LINQ) adds query capabilities to Visual Basic and provides simple and powerful capabilities when you work with all kinds of data. En lugar de enviar una consulta a una base de datos que se va a procesar o trabajar con una sintaxis de consulta diferente para cada tipo de datos que se está buscando, LINQ presenta las consultas como parte del lenguaje Visual Basic.Rather than sending a query to a database to be processed, or working with different query syntax for each type of data that you are searching, LINQ introduces queries as part of the Visual Basic language. Utiliza una sintaxis unificada independientemente del tipo de datos.It uses a unified syntax regardless of the type of data.

LINQ permite consultar datos de una base de datos SQL Server, XML, matrices y colecciones en memoria, conjuntos de datos ADO.NET o cualquier otro origen de datos remoto o local que admita LINQ.LINQ enables you to query data from a SQL Server database, XML, in-memory arrays and collections, ADO.NET datasets, or any other remote or local data source that supports LINQ. Puede hacer todo esto con los elementos de lenguaje de Visual Basic comunes.You can do all this with common Visual Basic language elements. Dado que las consultas se escriben en el lenguaje Visual Basic, los resultados de la consulta se devuelven como objetos fuertemente tipados.Because your queries are written in the Visual Basic language, your query results are returned as strongly-typed objects. Estos objetos son compatibles con IntelliSense, lo que le permite escribir código más rápidamente y detectar errores en las consultas en tiempo de compilación en lugar de en tiempo de ejecución.These objects support IntelliSense, which enables you to write code faster and catch errors in your queries at compile time instead of at run time. Las consultas LINQ se pueden utilizar como el origen de consultas adicionales para refinar los resultados.LINQ queries can be used as the source of additional queries to refine results. También se pueden enlazar a controles para que los usuarios puedan ver y modificar fácilmente los resultados de la consulta.They can also be bound to controls so that users can easily view and modify your query results.

Por ejemplo, en el siguiente ejemplo de código se muestra una consulta LINQ que devuelve una lista de clientes de una colección y los agrupa basándose en su ubicación.For example, the following code example shows a LINQ query that returns a list of customers from a collection and groups them based on their location.

' Obtain a list of customers.
Dim customers As List(Of Customer) = GetCustomers()

' Return customers that are grouped based on country.
Dim countries = From cust In customers
                Order By cust.Country, cust.City
                Group By CountryName = cust.Country
                Into CustomersInCountry = Group, Count()
                Order By CountryName

' Output the results.
For Each country In countries
    Debug.WriteLine(country.CountryName & " count=" & country.Count)

    For Each customer In country.CustomersInCountry
        Debug.WriteLine("   " & customer.CompanyName & "  " & customer.City)
    Next
Next

' Output:
'   Canada count=2
'      Contoso, Ltd  Halifax
'      Fabrikam, Inc.  Vancouver
'   United States count=1
'      Margie's Travel  Redmond

Ejecución de los ejemplosRunning the examples

Para ejecutar los ejemplos de la introducción y en la estructura de una consulta LINQ , incluya el siguiente código, que devuelve listas de clientes y pedidos.To run the examples in the introduction and in the Structure of a LINQ Query section, include the following code, which returns lists of customers and orders.

' Return a list of customers.
Private Function GetCustomers() As List(Of Customer)
    Return New List(Of Customer) From
        {
            New Customer With {.CustomerID = 1, .CompanyName = "Contoso, Ltd", .City = "Halifax", .Country = "Canada"},
            New Customer With {.CustomerID = 2, .CompanyName = "Margie's Travel", .City = "Redmond", .Country = "United States"},
            New Customer With {.CustomerID = 3, .CompanyName = "Fabrikam, Inc.", .City = "Vancouver", .Country = "Canada"}
        }
End Function

' Return a list of orders.
Private Function GetOrders() As List(Of Order)
    Return New List(Of Order) From
        {
            New Order With {.CustomerID = 1, .Amount = "200.00"},
            New Order With {.CustomerID = 3, .Amount = "600.00"},
            New Order With {.CustomerID = 1, .Amount = "300.00"},
            New Order With {.CustomerID = 2, .Amount = "100.00"},
            New Order With {.CustomerID = 3, .Amount = "800.00"}
        }
End Function

' Customer Class.
Private Class Customer
    Public Property CustomerID As Integer
    Public Property CompanyName As String
    Public Property City As String
    Public Property Country As String
End Class

' Order Class.
Private Class Order
    Public Property CustomerID As Integer
    Public Property Amount As Decimal
End Class

Proveedores LINQLINQ providers

Un proveedor LINQ asigna las consultas LINQ Visual Basic al origen de datos que se consulta.A LINQ provider maps your Visual Basic LINQ queries to the data source being queried. Cuando usted escribe una consulta LINQ, el proveedor toma esa consulta y la traduce en comandos que podrá ejecutar el origen de datos.When you write a LINQ query, the provider takes that query and translates it into commands that the data source will be able to execute. El proveedor también convierte los datos del origen en los objetos que forman el resultado de su consulta.The provider also converts data from the source to the objects that make up your query result. Por último, convierte los objetos en datos cuando envía actualizaciones al origen de datos.Finally, it converts objects to data when you send updates to the data source.

Visual Basic incluye los siguientes proveedores LINQ.Visual Basic includes the following LINQ providers.

ProveedorProvider DescripciónDescription
LINQ to ObjectsLINQ to Objects El proveedor LINQ to Objects le permite consultar las matrices y colecciones en memoria.The LINQ to Objects provider enables you to query in-memory collections and arrays. Si un objeto es compatible con las interfaces IEnumerable o IEnumerable<T>, el proveedor LINQ to Objects le permite consultarlo.If an object supports either the IEnumerable or IEnumerable<T> interface, the LINQ to Objects provider enables you to query it.

Puede habilitar el proveedor de LINQ to Objects importando el espacio de nombres System.Linq, que se importa de forma predeterminada para todos los proyectos de Visual Basic.You can enable the LINQ to Objects provider by importing the System.Linq namespace, which is imported by default for all Visual Basic projects.

Para obtener más información sobre el proveedor de LINQ to Objects, vea LINQ to Objects.For more information about the LINQ to Objects provider, see LINQ to Objects.
LINQ to SQLLINQ to SQL El proveedor LINQ to SQL le permite consultar y modificar datos en una base de datos de SQL Server.The LINQ to SQL provider enables you to query and modify data in a SQL Server database. Esto hace que sea fácil asignar el modelo de objetos de una aplicación a las tablas y los objetos de una base de datos.This makes it easy to map the object model for an application to the tables and objects in a database.

Visual Basic facilita el trabajo con LINQ to SQL incluyendo el Object Relational Designer (Object Relational Designer).Visual Basic makes it easier to work with LINQ to SQL by including the Object Relational Designer (O/R Designer). Este diseñador se usa para crear un modelo de objetos en una aplicación que se asigna a los objetos de una base de datos.This designer is used to create an object model in an application that maps to objects in a database. O/R Designer también proporciona funcionalidad para asignar procedimientos almacenados y funciones al objeto DataContext, que administra la comunicación con la base de datos y almacena el estado de las comprobaciones de simultaneidad optimista.The O/R Designer also provides functionality to map stored procedures and functions to the DataContext object, which manages communication with the database and stores state for optimistic concurrency checks.

Para obtener más información sobre el proveedor de LINQ to SQL, vea LINQ to SQL.For more information about the LINQ to SQL provider, see LINQ to SQL. Para obtener más información sobre el Object Relational Designer, vea herramientas de LINQ to SQL en Visual Studio.For more information about the Object Relational Designer, see LINQ to SQL Tools in Visual Studio.
LINQ to XMLLINQ to XML El proveedor LINQ to XML le permite consultar y modificar XML.The LINQ to XML provider enables you to query and modify XML. Puede modificar XML en memoria o puede cargar XML desde un archivo y guardarlo en él.You can modify in-memory XML, or you can load XML from and save XML to a file.

Además, el proveedor de LINQ to XML habilita literales XML y propiedades de eje XML que le permiten escribir XML directamente en el código de Visual Basic.Additionally, the LINQ to XML provider enables XML literals and XML axis properties that enable you to write XML directly in your Visual Basic code. Para obtener más información, vea XML.For more information, see XML.
LINQ to DataSetLINQ to DataSet El proveedor de LINQ to DataSet permite consultar y actualizar datos en un conjunto de datos de ADO.NET.The LINQ to DataSet provider enables you to query and update data in an ADO.NET dataset. Puede agregar la eficacia de LINQ a las aplicaciones que utilicen conjuntos de datos con el fin de simplificar y ampliar las funcionalidades de consulta, agregado y actualización de los datos del conjunto de datos.You can add the power of LINQ to applications that use datasets in order to simplify and extend your capabilities for querying, aggregating, and updating the data in your dataset.

Para más información, vea LINQ to DataSet.For more information, see LINQ to DataSet.

Estructura de una consulta LINQStructure of a LINQ query

Una consulta LINQ, a la que se suele hacer referencia como una expresión de consulta, consta de una combinación de cláusulas de consulta que identifican los orígenes de datos y las variables de iteración de la consulta.A LINQ query, often referred to as a query expression, consists of a combination of query clauses that identify the data sources and iteration variables for the query. Una expresión de consulta también incluye instrucciones para ordenar, filtrar, agrupar y combinar, o cálculos para aplicar al origen de datos.A query expression can also include instructions for sorting, filtering, grouping, and joining, or calculations to apply to the source data. La sintaxis de las expresiones de consulta se parece a la sintaxis de SQL; por lo tanto, le puede resultar familiar gran parte de la sintaxis.Query expression syntax resembles the syntax of SQL; therefore, you may find much of the syntax familiar.

Una expresión de consulta comienza con una cláusula From.A query expression starts with a From clause. Esta cláusula identifica los datos de origen de una consulta y las variables que se usan para referirse individualmente a cada elemento de los datos de origen.This clause identifies the source data for a query and the variables that are used to refer to each element of the source data individually. Estas variables se denominan variables de rango o variables de iteración.These variables are named range variables or iteration variables. La cláusula From se requiere para una consulta, excepto para consultas Aggregate, donde la cláusula From es opcional.The From clause is required for a query, except for Aggregate queries, where the From clause is optional. Una vez que se hayan identificado el ámbito y el origen de la consulta en las cláusulas From o Aggregate, puede incluir cualquier combinación de cláusulas de consulta para refinar la consulta.After the scope and source of the query are identified in the From or Aggregate clauses, you can include any combination of query clauses to refine the query. Para obtener más información sobre las cláusulas de consulta, vea Visual Basic operadores de consulta LINQ más adelante en este tema.For details about query clauses, see Visual Basic LINQ Query Operators later in this topic. Por ejemplo, la siguiente consulta identifica una colección de origen de datos de cliente como la variable customers y una variable de iteración denominada cust.For example, the following query identifies a source collection of customer data as the customers variable, and an iteration variable named cust.

Dim customers = GetCustomers()

Dim queryResults = From cust In customers

For Each result In queryResults
    Debug.WriteLine(result.CompanyName & "  " & result.Country)
Next

' Output:
'   Contoso, Ltd  Canada
'   Margie's Travel  United States
'   Fabrikam, Inc.  Canada

Este ejemplo es una consulta válida por sí misma; sin embargo, la consulta es mucho más eficaz cuando agrega más cláusulas de consulta para refinar los resultados.This example is a valid query by itself; however, the query becomes far more powerful when you add more query clauses to refine the result. Por ejemplo, puede agregar una cláusula Where para filtrar los resultados mediante uno o varios valores.For example, you can add a Where clause to filter the result by one or more values. Las expresiones de consulta son una sola línea de código; puede simplemente anexar cláusulas de consulta adicionales al final de la consulta.Query expressions are a single line of code; you can just append additional query clauses to the end of the query. Puede dividir una consulta en varias líneas de texto para mejorar la legibilidad mediante el carácter de continuación de línea de subrayado (_).You can break up a query across multiple lines of text to improve readability by using the underscore (_) line-continuation character. En el siguiente ejemplo de código se muestra una consulta que incluye una cláusula Where.The following code example shows an example of a query that includes a Where clause.

Dim queryResults = From cust In customers
                   Where cust.Country = "Canada"

Otra cláusula de consulta eficaz es la cláusula Select, que sólo le permite devolver los campos seleccionados del origen de datos.Another powerful query clause is the Select clause, which enables you to return only selected fields from the data source. Las consultas LINQ devuelven colecciones enumerables de objetos fuertemente tipados.LINQ queries return enumerable collections of strongly typed objects. Una consulta puede devolver una colección de tipos anónimos o de tipos con nombre.A query can return a collection of anonymous types or named types. Puede utilizar la cláusula Select para que solo se devuelva un único campo del origen de datos.You can use the Select clause to return only a single field from the data source. Al hacerlo, el tipo de la colección devuelto es el tipo de ese campo único.When you do this, the type of the collection returned is the type of that single field. También puede utilizar la cláusula Select para devolver varios campos del origen de datos.You can also use the Select clause to return multiple fields from the data source. Al hacerlo, el tipo de la colección devuelto es un nuevo tipo anónimo.When you do this, the type of the collection returned is a new anonymous type. También puede hacer coincidir los campos devueltos por la consulta a los campos de un tipo con nombre especificado.You can also match the fields returned by the query to the fields of a specified named type. En el siguiente ejemplo de código se muestra una expresión de consulta que devuelve una colección de tipos anónimos con miembros rellenados con datos de los campos seleccionados del origen de datos.The following code example shows a query expression that returns a collection of anonymous types that have members populated with data from the selected fields from the data source.

Dim queryResults = From cust In customers
               Where cust.Country = "Canada"
               Select cust.CompanyName, cust.Country

Las consultas LINQ también pueden utilizarse para combinar varios orígenes de datos y devolver un único resultado.LINQ queries can also be used to combine multiple sources of data and return a single result. Esto puede hacerse con una o más cláusulas From o mediante las cláusulas de consulta Join o Group Join.This can be done with one or more From clauses, or by using the Join or Group Join query clauses. En el siguiente ejemplo de código se muestra una expresión de consulta que combina datos de clientes y pedidos y devuelve una colección de tipos anónimos que contiene datos de clientes y pedidos.The following code example shows a query expression that combines customer and order data and returns a collection of anonymous types containing customer and order data.

Dim customers = GetCustomers()
Dim orders = GetOrders()

Dim queryResults = From cust In customers, ord In orders
           Where cust.CustomerID = ord.CustomerID
           Select cust, ord

For Each result In queryResults
    Debug.WriteLine(result.ord.Amount & "  " & result.ord.CustomerID & "  " & result.cust.CompanyName)
Next

' Output:
'   200.00  1  Contoso, Ltd
'   300.00  1  Contoso, Ltd
'   100.00  2  Margie's Travel
'   600.00  3  Fabrikam, Inc.
'   800.00  3  Fabrikam, Inc.

Puede utilizar la cláusula Group Join para crear un resultado de consulta jerárquica que contenga una colección de objetos Customer.You can use the Group Join clause to create a hierarchical query result that contains a collection of customer objects. Cada objeto Customer tiene una propiedad que contiene una colección de todos los pedidos para ese cliente.Each customer object has a property that contains a collection of all orders for that customer. En el siguiente ejemplo de código se muestra una expresión de consulta que combina datos de clientes y pedidos como un resultado jerárquico y devuelve una colección de tipos anónimos.The following code example shows a query expression that combines customer and order data as a hierarchical result and returns a collection of anonymous types. La consulta devuelve un tipo que incluye una propiedad CustomerOrders que contiene una colección de datos de pedidos del cliente.The query returns a type that includes a CustomerOrders property that contains a collection of order data for the customer. También incluye una propiedad OrderTotal que contiene la suma de los totales de todos los pedidos de ese cliente.It also includes an OrderTotal property that contains the sum of the totals for all the orders for that customer. (Esta consulta es equivalente a una combinación externa izquierda).(This query is equivalent to a LEFT OUTER JOIN.)

Dim customers = GetCustomers()
Dim orders = GetOrders()

Dim queryResults = From cust In customers
                   Group Join ord In orders On
                     cust.CustomerID Equals ord.CustomerID
                     Into CustomerOrders = Group,
                          OrderTotal = Sum(ord.Amount)
                   Select cust.CompanyName, cust.CustomerID,
                          CustomerOrders, OrderTotal

For Each result In queryResults
    Debug.WriteLine(result.OrderTotal & "  " & result.CustomerID & "  " & result.CompanyName)
    For Each ordResult In result.CustomerOrders
        Debug.WriteLine("   " & ordResult.Amount)
    Next
Next

' Output:
'   500.00  1  Contoso, Ltd
'      200.00
'      300.00
'   100.00  2  Margie's Travel
'      100.00
'   1400.00  3  Fabrikam, Inc.
'      600.00
'      800.00

Hay varios operadores de consulta LINQ adicionales que puede utilizar para crear expresiones de consulta eficaces.There are several additional LINQ query operators that you can use to create powerful query expressions. En la siguiente sección de este tema se describen las diversas cláusulas de consulta que puede incluir en una expresión de consulta.The next section of this topic discusses the various query clauses that you can include in a query expression. Para obtener más información sobre las cláusulas de consulta de Visual Basic, vea consultas.For details about Visual Basic query clauses, see Queries.

Visual Basic operadores de consulta LINQVisual Basic LINQ query operators

Las clases en el espacio de nombres System.Linq y los otros espacios de nombres compatibles con consultas LINQ incluyen métodos a los que puede llamar para crear y refinar las consultas en función de las necesidades de su aplicación.The classes in the System.Linq namespace and the other namespaces that support LINQ queries include methods that you can call to create and refine queries based on the needs of your application. Visual Basic incluye palabras clave para las siguientes cláusulas de consulta comunes.Visual Basic includes keywords for the following common query clauses. Para obtener más información sobre las cláusulas de consulta de Visual Basic, vea consultas.For details about Visual Basic query clauses, see Queries.

Cláusula FromFrom clause

Se requiere una cláusula From o una cláusula Aggregate para iniciar una consulta.Either a From clause or an Aggregate clause is required to begin a query. Una cláusula From especifica una colección de origen y una variable de iteración de una consulta.A From clause specifies a source collection and an iteration variable for a query. Por ejemplo:For example:

' Returns the company name for all customers for which
' the Country is equal to "Canada".
Dim names = From cust In customers
            Where cust.Country = "Canada"
            Select cust.CompanyName

Select (cláusula)Select clause

Opcional.Optional. Una cláusulaSelect declara un conjunto de variables de iteración para una consulta.A Select clause declares a set of iteration variables for a query. Por ejemplo:For example:

' Returns the company name and ID value for each
' customer as a collection of a new anonymous type.
Dim customerList = From cust In customers
                   Select cust.CompanyName, cust.CustomerID

Si no se especifica una cláusula Select, las variables de iteración de la consulta se componen de las variables de iteración especificadas por la cláusula From o Aggregate.If a Select clause is not specified, the iteration variables for the query consist of the iteration variables specified by the From or Aggregate clause.

Cláusula WhereWhere clause

Opcional.Optional. Una cláusulaWhere especifica una condición de filtrado para una consulta.A Where clause specifies a filtering condition for a query. Por ejemplo:For example:

' Returns all product names for which the Category of
' the product is "Beverages".
Dim names = From product In products
            Where product.Category = "Beverages"
            Select product.Name

Order by, cláusula]Order By clause]

| Opta.|Optional. Una cláusulaOrder By especifica el criterio de ordenación de las columnas de una consulta.An Order By clause specifies the sort order for columns in a query. Por ejemplo:For example:

' Returns a list of books sorted by price in 
' ascending order.
Dim titlesAscendingPrice = From b In books
                           Order By b.price

Join (cláusula)Join clause

Opcional.Optional. Una cláusulaJoin combina dos colecciones en una sola colección.A Join clause combines two collections into a single collection. Por ejemplo:For example:

' Returns a combined collection of all of the 
' processes currently running and a descriptive
' name for the process taken from a list of 
' descriptive names.
Dim processes = From proc In Process.GetProcesses
                Join desc In processDescriptions
                  On proc.ProcessName Equals desc.ProcessName
                Select proc.ProcessName, proc.Id, desc.Description

Group By (cláusula)Group By clause

Opcional.Optional. Una cláusulaGroup By agrupa los elementos del resultado de una consulta.A Group By clause groups the elements of a query result. Se puede usar para aplicar funciones de agregado a cada grupo.It can be used to apply aggregate functions to each group. Por ejemplo:For example:

' Returns a list of orders grouped by the order date
' and sorted in ascending order by the order date.
Dim orderList = From order In orders
                Order By order.OrderDate
                Group By OrderDate = order.OrderDate
                Into OrdersByDate = Group

Group Join (cláusula)Group Join clause

Opcional.Optional. Una cláusulaGroup Join combina dos colecciones en una sola colección jerárquica.A Group Join clause combines two collections into a single hierarchical collection. Por ejemplo:For example:

' Returns a combined collection of customers and
' customer orders.
Dim customerList = From cust In customers
                   Group Join ord In orders On
                     cust.CustomerID Equals ord.CustomerID
                   Into CustomerOrders = Group,
                        TotalOfOrders = Sum(ord.Amount)
                   Select cust.CompanyName, cust.CustomerID,
                          CustomerOrders, TotalOfOrders

Aggregate (cláusula)Aggregate clause

Se requiere una cláusulaAggregate o una cláusula From para iniciar una consulta.Either an Aggregate clause or a From clause is required to begin a query. Una cláusula Aggregate aplica una o más funciones agregadas a una colección.An Aggregate clause applies one or more aggregate functions to a collection. Por ejemplo, puede usar la cláusula Aggregate para calcular una suma de todos los elementos devueltos por una consulta, como hace el siguiente ejemplo.For example, you can use the Aggregate clause to calculate a sum for all the elements returned by a query, as the following example does.

' Returns the sum of all order amounts.
Dim orderTotal = Aggregate order In orders
                 Into Sum(order.Amount)

También puede utilizar la cláusula Aggregate para modificar una consulta.You can also use the Aggregate clause to modify a query. Por ejemplo, puede utilizar la cláusula Aggregate para realizar un cálculo en una colección de consultas relacionada.For example, you can use the Aggregate clause to perform a calculation on a related query collection. Por ejemplo:For example:

' Returns the customer company name and largest 
' order amount for each customer.
Dim customerMax = From cust In customers
                  Aggregate order In cust.Orders
                  Into MaxOrder = Max(order.Amount)
                  Select cust.CompanyName, MaxOrder

Let (cláusula)Let clause

Opcional.Optional. Una cláusulaLet calcula un valor y lo asigna a una nueva variable en la consulta.A Let clause computes a value and assigns it to a new variable in the query. Por ejemplo:For example:

' Returns a list of products with a calculation of
' a ten percent discount.
Dim discountedProducts = From prod In products
                         Let Discount = prod.UnitPrice * 0.1
                         Where Discount >= 50
                         Select prod.Name, prod.UnitPrice, Discount

Distinct (cláusula)Distinct clause

Opcional.Optional. Una cláusula Distinct restringe los valores de la variable de iteración actual para eliminar los valores duplicados en los resultados de la consulta.A Distinct clause restricts the values of the current iteration variable to eliminate duplicate values in query results. Por ejemplo:For example:

' Returns a list of cities with no duplicate entries.
Dim cities = From item In customers
             Select item.City
             Distinct

Skip (cláusula)Skip clause

Opcional.Optional. Una cláusulaSkip omite un número especificado de elementos de una colección y, a continuación, devuelve los elementos restantes.A Skip clause bypasses a specified number of elements in a collection and then returns the remaining elements. Por ejemplo:For example:

' Returns a list of customers. The first 10 customers
' are ignored and the remaining customers are
' returned.
Dim customerList = From cust In customers
                   Skip 10

Skip While (cláusula)Skip While clause

Opcional.Optional. Una cláusulaSkip While omite los elementos de una colección siempre que se true una condición especificada y, a continuación, devuelve los elementos restantes.A Skip While clause bypasses elements in a collection as long as a specified condition is true and then returns the remaining elements. Por ejemplo:For example:

' Returns a list of customers. The query ignores all
' customers until the first customer for whom
' IsSubscriber returns false. That customer and all
' remaining customers are returned.
Dim customerList = From cust In customers
                   Skip While IsSubscriber(cust)

Take (cláusula)Take clause

Opcional.Optional. Una cláusulaTake devuelve un número especificado de elementos contiguos desde el principio de una colección.A Take clause returns a specified number of contiguous elements from the start of a collection. Por ejemplo:For example:

' Returns the first 10 customers.
Dim customerList = From cust In customers
                   Take 10

Take While (cláusula)Take While clause

Opcional.Optional. Una cláusulaTake While incluye los elementos de una colección siempre que se true una condición especificada y se omiten los elementos restantes.A Take While clause includes elements in a collection as long as a specified condition is true and bypasses the remaining elements. Por ejemplo:For example:

' Returns a list of customers. The query returns
' customers until the first customer for whom 
' HasOrders returns false. That customer and all 
' remaining customers are ignored.
Dim customersWithOrders = From cust In customers
                          Order By cust.Orders.Count Descending
                          Take While HasOrders(cust)

Usar características de consulta LINQ adicionalesUse additional LINQ query features

Puede usar características de consulta LINQ adicionales llamando a los miembros de los tipos de enumerables y consultables proporcionados por LINQ.You can use additional LINQ query features by calling members of the enumerable and queryable types provided by LINQ. Puede utilizar estas funciones adicionales llamando a un operador de consulta determinado en el resultado de una expresión de consulta.You can use these additional capabilities by calling a particular query operator on the result of a query expression. Por ejemplo, en el ejemplo siguiente se usa el método Enumerable.Union para combinar los resultados de dos consultas en el resultado de una consulta.For example, the following example uses the Enumerable.Union method to combine the results of two queries into one query result. Utiliza el método Enumerable.ToList para devolver el resultado de la consulta como una lista genérica.It uses the Enumerable.ToList method to return the query result as a generic list.

Public Function GetAllCustomers() As List(Of Customer)
    Dim customers1 = From cust In domesticCustomers
    Dim customers2 = From cust In internationalCustomers

    Dim customerList = customers1.Union(customers2)

    Return customerList.ToList()
End Function

Para obtener más información acerca de las funcionalidades adicionales de LINQ, consulte información general sobre operadores de consulta estándar.For details about additional LINQ capabilities, see Standard Query Operators Overview.

Conectarse a una base de datos mediante LINQ to SQLConnect to a database by using LINQ to SQL

En Visual Basic, se identifican los objetos de base de datos de SQL Server, como tablas, vistas y procedimientos almacenados, a los que se desea obtener acceso mediante un archivo de LINQ to SQL.In Visual Basic, you identify the SQL Server database objects, such as tables, views, and stored procedures, that you want to access by using a LINQ to SQL file. Un archivo LINQ to SQL tiene una extensión .dbml.A LINQ to SQL file has an extension of .dbml.

Si tiene una conexión válida a una base de datos de SQL Server, puede Agregar una plantilla de elementos de LINQ to SQL clases al proyecto.When you have a valid connection to a SQL Server database, you can add a LINQ to SQL Classes item template to your project. De este modo se mostrará el Object Relational Designer (O/R Designer).This will display the Object Relational Designer (O/R designer). Object Relational Designer le permite arrastrar los elementos a los que desea obtener acceso en el código desde el Explorador de servidores/Explorador de bases de datos hasta la superficie del diseñador.The O/R Designer enables you to drag the items that you want to access in your code from the Server Explorer/Database Explorer onto the designer surface. El archivo LINQ to SQL agrega un objeto DataContext al proyecto.The LINQ to SQL file adds a DataContext object to your project. Este objeto incluye propiedades y colecciones para las tablas y vistas a las que desea acceder y métodos para los procedimientos almacenados a los que desea llamar.This object includes properties and collections for the tables and views that you want access to, and methods for the stored procedures that you want to call. Después de haber guardado los cambios en el archivo LINQ to SQL (.dbml), puede acceder a estos objetos en el código haciendo referencia al objeto DataContext definido por el O/R Designer.After you have saved your changes to the LINQ to SQL (.dbml) file, you can access these objects in your code by referencing the DataContext object that is defined by the O/R Designer. El nombre del objeto DataContext del proyecto se determina en función del nombre del archivo LINQ to SQL.The DataContext object for your project is named based on the name of your LINQ to SQL file. Por ejemplo, un archivo LINQ to SQL denominado Northwind.dbml creará un objeto DataContext denominado NorthwindDataContext.For example, a LINQ to SQL file that is named Northwind.dbml will create a DataContext object named NorthwindDataContext.

Para obtener ejemplos con instrucciones paso a paso, consulte Cómo: consultar una base de datos y Cómo: llamar a un procedimiento almacenado.For examples with step-by-step instructions, see How to: Query a Database and How to: Call a Stored Procedure.

Visual Basic características compatibles con LINQVisual Basic features that support LINQ

Visual Basic incluye otras características destacables que facilitan el uso de LINQ y reducen la cantidad de código que debe escribir para realizar consultas LINQ.Visual Basic includes other notable features that make the use of LINQ simple and reduce the amount of code that you must write to perform LINQ queries. Entre ellas se incluyen las siguientes:These include the following:

  • Tipos anónimos, que permiten crear un nuevo tipo basado en el resultado de una consulta.Anonymous types, which enable you to create a new type based on a query result.

  • Variables con tipo implícito, que permiten aplazar la especificación de un tipo y permitir que el compilador infiera el tipo basándose en el resultado de la consulta.Implicitly typed variables, which enable you to defer specifying a type and let the compiler infer the type based on the query result.

  • Métodos de extensión, que permiten extender un tipo existente con sus propios métodos sin modificar el propio tipo.Extension methods, which enable you to extend an existing type with your own methods without modifying the type itself.

Para obtener más información, vea Visual Basic características compatibles con LINQ.For details, see Visual Basic Features That Support LINQ.

Ejecución de consultas diferida e inmediataDeferred and immediate query execution

La ejecución de una consulta se realiza de manera independiente con respecto a la creación de una consulta.Query execution is separate from creating a query. Después de crear una consulta, un mecanismo independiente desencadena su ejecución.After a query is created, its execution is triggered by a separate mechanism. Una consulta se puede ejecutar en cuanto se define (ejecución inmediata) o se puede almacenar la definición y la consulta se puede ejecutar más adelante (ejecución aplazada).A query can be executed as soon as it is defined (immediate execution), or the definition can be stored and the query can be executed later (deferred execution).

De forma predeterminada, cuando crea una consulta, la propia consulta no se ejecuta inmediatamente.By default, when you create a query, the query itself does not execute immediately. En su lugar, la definición de la consulta se almacena en la variable que se utiliza para hacer referencia al resultado de la consulta.Instead, the query definition is stored in the variable that is used to reference the query result. Cuando se accede a la variable de resultado de la consulta más adelante en el código, como, por ejemplo, en un bucle For…Next, se ejecuta la consulta.When the query result variable is accessed later in code, such as in a For…Next loop, the query is executed. Este proceso se conoce como ejecución aplazada.This process is referred to as deferred execution.

Las consultas también se pueden ejecutar cuando se definen, lo que se conoce como ejecución inmediata.Queries can also be executed when they are defined, which is referred to as immediate execution. Puede desencadenar la ejecución inmediata aplicando un método que requiera acceso a elementos individuales del resultado de la consulta.You can trigger immediate execution by applying a method that requires access to individual elements of the query result. Esto puede ser el resultado de incluir una función de agregado, como Count, Sum, Average, Min o Max.This can be the result of including an aggregate function, such as Count, Sum, Average, Min, or Max. Para obtener más información sobre las funciones de agregado, vea cláusula Aggregate.For more information about aggregate functions, see Aggregate Clause.

El uso de los métodos ToList o ToArray también fuerza la ejecución inmediata.Using the ToList or ToArray methods will also force immediate execution. Esto le puede resultar útil cuando desee ejecutar la consulta inmediatamente y almacenar en caché los resultados.This can be useful when you want to execute the query immediately and cache the results. Para obtener más información sobre estos métodos, vea convertir tipos de datos.For more information about these methods, see Converting Data Types.

Para obtener más información sobre la ejecución de consultas, vea escribir su primera consulta LINQ.For more information about query execution, see Writing Your First LINQ Query.

XML en Visual BasicXML in Visual Basic

Las características XML de Visual Basic incluyen literales XML y propiedades de eje XML, lo que le permite crear fácilmente, tener acceso, consultar y modificar XML en el código.The XML features in Visual Basic include XML literals and XML axis properties, which enable you easily to create, access, query, and modify XML in your code. Los literales XML le permiten escribir XML directamente en el código.XML literals enable you to write XML directly in your code. El compilador de Visual Basic trata el XML como un objeto de datos de primera clase.The Visual Basic compiler treats the XML as a first-class data object.

En el siguiente ejemplo de código se muestra cómo crear un elemento XML, acceder a sus subelementos y atributos y consultar el contenido del elemento mediante LINQ.The following code example shows how to create an XML element, access its sub-elements and attributes, and query the contents of the element by using LINQ.

' Place Imports statements at the top of your program.  
Imports <xmlns:ns="http://SomeNamespace">

Module Sample1

    Sub SampleTransform()

        ' Create test by using a global XML namespace prefix. 

        Dim contact = 
            <ns:contact>
                <ns:name>Patrick Hines</ns:name>
                <ns:phone ns:type="home">206-555-0144</ns:phone>
                <ns:phone ns:type="work">425-555-0145</ns:phone>
            </ns:contact>

        Dim phoneTypes = 
          <phoneTypes>
              <%= From phone In contact.<ns:phone> 
                  Select <type><%= phone.@ns:type %></type> 
              %>
          </phoneTypes>

        Console.WriteLine(phoneTypes)
    End Sub

End Module

Para obtener más información, vea XML.For more information, see XML.

TemaTopic DescripciónDescription
XMLXML Describe las características XML de Visual Basic que se pueden consultar y que permiten incluir XML como objetos de datos de primera clase en el código Visual Basic.Describes the XML features in Visual Basic that can be queried and that enable you to include XML as first-class data objects in your Visual Basic code.
ConsultasQueries Proporciona información de referencia sobre las cláusulas de consulta que están disponibles en Visual Basic.Provides reference information about the query clauses that are available in Visual Basic.
LINQ (Language Integrated Query)LINQ (Language-Integrated Query) Incluye información general, instrucciones de programación y ejemplos de LINQ.Includes general information, programming guidance, and samples for LINQ.
LINQ to SQLLINQ to SQL Incluye información general, guía de programación y ejemplos de LINQ to SQL.Includes general information, programming guidance, and samples for LINQ to SQL.
LINQ to ObjectsLINQ to Objects Incluye información general, guía de programación y ejemplos de LINQ to Objects.Includes general information, programming guidance, and samples for LINQ to Objects.
LINQ to ADO.NET (Página de portal)LINQ to ADO.NET (Portal Page) Incluye vínculos a información general, guía de programación y ejemplos de LINQ to ADO.NET.Includes links to general information, programming guidance, and samples for LINQ to ADO.NET.
LINQ to XMLLINQ to XML Incluye información general, guía de programación y ejemplos de LINQ to XML.Includes general information, programming guidance, and samples for LINQ to XML.

Temas de procedimientos y tutorialesHow to and walkthrough topics

Cómo: Consultar una base de datosHow to: Query a Database

Cómo: Llamar a un procedimiento almacenadoHow to: Call a Stored Procedure

Cómo: Modificar datos en una bases de datosHow to: Modify Data in a Database

Cómo: Combinar datos con cláusulas JoinHow to: Combine Data with Joins

Cómo: Ordenar los resultados de una consultaHow to: Sort Query Results

Cómo: Filtrar los resultados de una consultaHow to: Filter Query Results

Cómo: Hacer el recuento, la suma o el promedio de datosHow to: Count, Sum, or Average Data

Cómo: Buscar los valores máximo y mínimo en el resultado de una consultaHow to: Find the Minimum or Maximum Value in a Query Result

Cómo: Asignar procedimientos almacenados para realizar actualizaciones, inserciones y eliminaciones (Object Relational Designer)How to: Assign stored procedures to perform updates, inserts, and deletes (O/R Designer)

Capítulo 17: LINQ en programación Visual Basic 2008Chapter 17: LINQ in Programming Visual Basic 2008

Vea tambiénSee also