Introducción a LINQ en Visual Basic

Artículo
06/08/2015

Language-Integrated Query (LINQ) agrega funcionalidades de consulta a Visual Basic y proporciona funcionalidades sencillas y eficaces para trabajar con todo tipo de datos. En lugar de enviar una consulta a una base de datos para que se procese o trabajar con distintas sintaxis de consulta para cada tipo de datos que busque, LINQ presenta las consultas como parte del lenguaje de Visual Basic. Utiliza una sintaxis unificada independientemente del tipo de datos.

LINQ permite consultar datos desde una base de datos de 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. Puede hacer todo esto con elementos comunes del lenguaje Visual Basic. Puesto que las consultas se escriben en el lenguaje Visual Basic, sus resultados se devuelven como objetos fuertemente tipados. Estos objetos admiten IntelliSense; por tanto, se puede escribir código más rápidamente y detectar los errores de las consultas en tiempo de compilación en vez de en tiempo de ejecución. Las consultas LINQ se pueden usar como el origen de consultas adicionales para refinar los resultados. También se pueden enlazar a los controles para que los usuarios puedan ver y modificar con facilidad los resultados de la consulta.

Por ejemplo, el ejemplo de código siguiente muestra una consulta LINQ que devuelve una lista de clientes de una colección y los agrupa basándose en su ubicación.

' 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

En este tema, encontrará información sobre las áreas siguientes:

Ejecutar los ejemplos
Proveedores LINQ
Estructura de un consulta LINQ
Operadores de consulta de LINQ de Visual Basic
Conexión a una base de datos mediante LINQ to SQL
Características de Visual Basic que admiten LINQ
Ejecución de una consulta aplazada e inmediata
XML en Visual Basic
Recursos relacionados
Temas "Cómo..." y tutoriales

Ejecutar los ejemplos

Para ejecutar los ejemplos de la introducción y en "Estructura de un consulta LINQ", incluya el siguiente código, que devuelve listas de clientes y pedidos.

' 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 LINQ

Un proveedor LINQ asigna las consultas LINQ de Visual Basic al origen de datos que se consulta. Al escribir una consulta LINQ, el proveedor toma la consulta y la traduce a los comandos que podrá ejecutar el origen de datos. Además, convierte los datos del origen en los objetos que constituyen el resultado de la consulta. Finalmente, convierte los objetos en datos cuando envíe actualizaciones al origen de datos.

Visual Basic incluye los siguientes proveedores LINQ.

Proveedor	Descripción
LINQ to Objects	El proveedor LINQ to Objects permite consultar colecciones y matrices en memoria. Si un objeto admite las interfaces IEnumerable o IEnumerable, el proveedor LINQ to Objects permite consultarlo. Puede habilitar el proveedor LINQ to Objects importando el espacio de nombres System.Linq, que se importa de forma predeterminada para todos los proyectos de Visual Basic. Para obtener más información sobre el proveedor LINQ to Objects, vea LINQ to Objects.
LINQ to SQL	El proveedor LINQ to SQL permite consultar y modificar los datos de una base de datos de SQL Server. De esta forma, es fácil asignar el modelo de objetos de una aplicación a las tablas y los objetos de una base de datos. Visual Basic facilita el trabajo con LINQ to SQL incluyendo el Object Relational 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. El Object Relational Designer también proporciona funcionalidad para asignar procedimientos y funciones almacenados al objeto DataContext, que administra la comunicación con la base de datos y almacena el estado de las comprobaciones de simultaneidad optimista. Para obtener más información sobre el proveedor LINQ to SQL, vea LINQ a SQL [LINQ to SQL]. Para obtener más información sobre el Object Relational Designer, vea Object Relational Designer.
LINQ to XML	El proveedor LINQ to XML permite consultar y modificar XML. Puede modificar XML en memoria o puede cargarlo desde un archivo y guardarlo en él. Además, el proveedor LINQ to XML habilita literales XML y propiedades de eje XML que permiten escribir XML directamente el código de Visual Basic. Para obtener más información, vea XML en Visual Basic.
LINQ to DataSet	El proveedor LINQ to DataSet permite consultar y actualizar los datos de un conjunto de datos ADO.NET. Puede agregar la eficacia de LINQ a las aplicaciones que usen conjuntos de datos para simplificar y ampliar las funcionalidades de consulta, agregación y actualización de los datos del conjunto. Para obtener más información, vea LINQ to DataSet.

Estructura de un consulta LINQ

Una consulta LINQ, a la que se suele hacer referencia como una expresión de consulta, está formada por una combinación de cláusulas de consulta que identifican los orígenes de datos y las variables de iteración de la consulta. Una expresión de consulta también puede incluir instrucciones para ordenar, filtrar, agrupar y combinar los cálculos que se van a aplicar a los datos de origen. La sintaxis de las expresiones de consulta se parece a la sintaxis de SQL; por consiguiente, puede que la mayor parte de la sintaxis le resulte familiar.

Una expresión de consulta se inicia con una cláusula From. Esta cláusula identifica los datos de origen de una consulta y las variables que se usan para hacer referencia a cada elemento de los datos de origen por separado. Estas variables se denominan variables de intervalo o variables de iteración. La cláusula From se requiere para una consulta, salvo para las consultas Aggregate, en las que la cláusula From es opcional. Después de identificar 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 con el fin de refinar la consulta. Para obtener detalles sobre las cláusulas de consulta, vea Operadores de consulta de LINQ de Visual Basic más adelante en este tema. 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.

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 en sí misma; sin embargo, la consulta es mucho más eficaz cuando agrega más cláusulas de consulta para refinar los resultados. Por ejemplo, puede agregar una cláusula Where para filtrar los resultados por uno o más valores. Las expresiones de consulta son una sola línea de código; puede anexar cláusulas de consulta adicionales al final de la consulta. Puede dividir una consulta en varias líneas de texto para mejorar la legibilidad mediante el carácter de subrayado (_)-continuación de línea. El ejemplo de código siguiente muestra un ejemplo de una consulta que incluye una cláusula Where.

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

Otra cláusula de consulta eficaz es la cláusula Select, que permite obtener sólo los campos seleccionados del origen de datos. Las consultas LINQ devuelven colecciones enumerables de objetos fuertemente tipados. Una consulta puede devolver una colección de tipos anónimos o los tipos con nombre. Puede utilizar la cláusula Select para devolver sólo un campo único del origen de datos. De esta forma, el tipo de la colección devuelto es el tipo de ese campo único. También puede usar la cláusula Select para devolver varios campos del origen de datos. De esta forma, el tipo de la colección devuelto es un nuevo tipo anónimo. Además, puede hacer coincidir los campos devueltos por la consulta con los de un tipo con nombre especificado. El ejemplo de código siguiente 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.

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

Las consultas LINQ también se pueden usar para combinar varios orígenes de datos y devolver un solo resultado. Esto se puede hacer con una o más cláusulas From o con las cláusulas de consulta Join o Group Join. El siguiente ejemplo de código muestra una expresión de consulta que combina los datos de cliente y de pedido y devuelve una colección de tipos anónimos que contienen estos datos.

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árquico que contiene una colección de objetos de cliente. Cada objeto de cliente tiene una propiedad que contiene una colección de todos los pedidos de ese cliente. El siguiente ejemplo de código muestra una expresión de consulta que combina los datos de cliente y de pedido como resultado jerárquico y devuelve una colección de tipos anónimos. La consulta devuelve un tipo que incluye una propiedad CustomerOrders que contiene una colección de datos de pedido del cliente. También incluye una propiedad OrderTotal que contiene la suma de los totales de todos los pedidos de ese cliente. (Esta consulta es equivalente 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

Existen varios operadores de consulta LINQ adicionales que puede utilizar para crear expresiones de consulta eficaces. La sección siguiente de este tema describe las distintas cláusulas de consulta que puede incluir en una expresión de consulta. Para obtener información detallada sobre cláusulas de consulta de Visual Basic, vea Consultas de Visual Basic.

Operadores de consulta de LINQ de Visual Basic

Las clases del espacio de nombres System.Linq y los otros espacios de nombres que admiten consultas LINQ incluyen métodos que se pueden invocar para crear y limitar las consultas según las necesidades de la aplicación. Visual Basic incluye palabras clave para las cláusulas de consulta más comunes, tal y como se describe en la siguiente tabla.

Término	Definición
From (Cláusula, Visual Basic)	Se necesita una cláusula From o Aggregate para iniciar una consulta. Una cláusula From especifica una colección de origen y una variable de iteración de una consulta. Por ejemplo: `' 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, Visual Basic)	Opcional. Declara un conjunto de variables de iteración de una consulta. Por ejemplo: `' 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 están formadas por la cláusula From o Aggregate.
Where (Cláusula, Visual Basic)	Opcional. Especifica una condición de filtrado de una consulta. Por ejemplo: `' 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, Visual Basic)	Opcional. Especifica el criterio de ordenación de las columnas de una consulta. Por ejemplo: `' Returns a list of books sorted by price in ' ascending order. Dim titlesAscendingPrice = From b In books Order By b.price`
Join (Cláusula, Visual Basic)	Opcional. Combina dos colecciones en una sola. Por ejemplo: `' 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, Visual Basic)	Opcional. Agrupa los elementos del resultado de una consulta. Se puede utilizar para aplicar funciones de agregado a cada grupo. Por ejemplo: `' 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, Visual Basic)	Opcional. Combina dos colecciones en una sola colección jerárquica. Por ejemplo: `' 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, Visual Basic)	Se necesita una cláusula From o Aggregate para iniciar una consulta. Una cláusula Aggregate aplica una o más funciones de agregado a una colección. Por ejemplo, puede utilizar la cláusula Aggregate para calcular una suma de todos los elementos devueltos por una consulta. `' Returns the sum of all order amounts. Dim orderTotal = Aggregate order In orders Into Sum(order.Amount)` También puede usar la cláusula Aggregate para modificar una consulta. Por ejemplo, puede usar la cláusula Aggregate para realizar un cálculo en una colección de consultas relacionada. `' 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, Visual Basic)	Opcional. Calcula un valor y lo asigna a una nueva variable de la consulta. Por ejemplo: `' 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, Visual Basic)	Opcional. Restringe los valores de la variable de iteración actual para eliminar los valores duplicados de los resultados de la consulta. Por ejemplo: `' Returns a list of cities with no duplicate entries. Dim cities = From item In customers Select item.City Distinct`
Skip (Cláusula, Visual Basic)	Opcional. Omite un número especificado de elementos de una colección y, a continuación, devuelve los elementos restantes. Por ejemplo: `' 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, Visual Basic)	Opcional. Omite los elementos de una colección en tanto que una condición especificada sea true y, a continuación, devuelva los elementos restantes. Por ejemplo: `' 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, Visual Basic)	Opcional. Devuelve un número especificado de elementos contiguos desde el principio de una colección. Por ejemplo: `' Returns the first 10 customers. Dim customerList = From cust In customers Take 10`
Take While (Cláusula, Visual Basic)	Opcional. Incluye los elementos de una colección en tanto que una condición especificada sea true y omita los elementos restantes. Por ejemplo: `' 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)`

Para obtener información detallada sobre cláusulas de consulta de Visual Basic, vea Consultas de Visual Basic.

Puede usar las características de consulta LINQ adicionales llamando a los miembros de los tipos que se pueden enumerar y consultar proporcionados por LINQ. Puede utilizar estas funciones adicionales llamando a un operador de consulta determinado en el resultado de una expresión de consulta. Por ejemplo, el siguiente ejemplo de código usa el método Union``1 para combinar los resultados de dos consultas en un resultado de consulta. Utiliza el método ToList``1 para devolver el resultado de la consulta como lista genérica.

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 información detallada sobre funcionalidades adicionales de LINQ adicionales, vea Información general sobre operadores de consulta estándar.

Conexión a una base de datos mediante LINQ to SQL

En Visual Basic, identifique los objetos de base de datos de SQL Server, como las tablas, las vistas y los procedimientos almacenados, a los que desee obtener acceso mediante un archivo LINQ to SQL. Un archivo LINQ to SQL tiene una extensión .dbml.

Cuando se dispone de una conexión válida a una base de datos de SQL Server, puede agregar una plantilla de elementos Clases de LINQ to SQL al proyecto. De esta forma, se mostrará el Object Relational Designer. Este diseñador permite arrastrar los elementos a los que desee obtener acceso en el código desde el Explorador de servidores o el Explorador de base de datos hasta la superficie del diseñador. El archivo LINQ to SQL agrega un objeto DataContext al proyecto. Este objeto incluye propiedades y colecciones para las tablas y vistas a las que desee tener acceso, así como métodos para los procedimientos almacenados a los que desee llamar. Después de haber guardado los cambios en el archivo LINQ to SQL (.dbml), puede tener acceso a estos objetos en el código haciendo referencia al objeto DataContext que define el Object Relational Designer. Al objeto DataContext del proyecto se le asigna un nombre basándose en el nombre del archivo LINQ to SQL. Por ejemplo, un archivo LINQ to SQL que se denomina Northwind.dbml creará un objeto DataContext denominado NorthwindDataContext.

Para obtener ejemplos con instrucciones paso a paso, vea Cómo: Consultar una base de datos usando LINQ (Visual Basic) y Cómo: Llamar a un procedimiento almacenado usando LINQ (Visual Basic).

Características de Visual Basic que admiten 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. Se incluyen las siguientes:

Tipos anónimos, que permiten crear un nuevo tipo basado en el resultado de una consulta.
Variables con tipo implícito, que permiten aplazar la especificación de un tipo y dejar que el compilador infiera el tipo basándose en el resultado de la consulta.
Métodos de extensión, que permiten ampliar un tipo existente con sus propios métodos sin modificar el propio tipo.

Para obtener información detallada, vea Características de Visual Basic que admiten LINQ.

Ejecución de una consulta aplazada e inmediata

La ejecución de una consulta no tiene nada que ver con su creación. Después de crear una consulta, un mecanismo independiente desencadena su ejecución. Se puede ejecutar un consulta en cuanto esté definida (ejecución inmediata), o se puede guardar la definición y ejecutar la consulta más tarde (ejecución aplazada).

De forma predeterminada, al crear una consulta, no se ejecuta inmediatamente. En su lugar, se almacena la definición de la consulta en la variable que se usa para hacer referencia a su resultado. Más tarde cuando se tiene acceso a la consulta en código, como en un bucle For…Next, se ejecuta. Este proceso se denomina ejecución aplazada.

Las consultas también se pueden ejecutar cuando están definidas, a lo que se denomina ejecución inmediata. Puede desencadenar una ejecución inmediata aplicando un método que requiere acceso a elementos individuales del resultado de la consulta. Este puede ser el resultado de incluir una función de agregado, como Count, Sum, Average, Min o Max. Para obtener más información acerca de las funciones de agregado, vea Aggregate (Cláusula, Visual Basic).

Al usar los métodos ToList o ToArray, también se forzará la ejecución inmediata. Esto puede ser útil si desea ejecutar la consulta inmediatamente y almacenar en caché los resultados. Para obtener más información sobre estos métodos, vea Convertir tipos de datos.

Para obtener más información sobre la ejecución de consultas, vea Escribir la primera consulta con LINQ (Visual Basic).

XML en Visual Basic

Las características XML de Visual Basic incluyen literales XML y propiedades de ejes XML, lo que permite crear, tener acceso, consultar y modificar fácilmente el XML en el código. Los literales XML permiten escribir XML directamente en el código. El compilador de Visual Basic trata el XML como objeto de datos de primera clase.

El siguiente ejemplo de código muestra cómo crear un elemento XML, tener acceso a sus subelementos y atributos, así como consultar el contenido del elemento mediante 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 en Visual Basic.

Recursos relacionados

Tema	Descripción
XML en Visual Basic	Describe las características XML de Visual Basic que se pueden consultar para incluir XML como objetos de primera clase en el código de Visual Basic.
Consultas de Visual Basic	Proporciona información de referencia sobre las cláusulas de consulta que están disponibles en Visual Basic.
LINQ (Language-Integrated Query)	Incluye información general, instrucciones de programación y ejemplos de LINQ.
LINQ a SQL [LINQ to SQL]	Incluye información general, instrucciones de programación y ejemplos de LINQ to SQL.
LINQ to Objects	Incluye información general, instrucciones de programación y ejemplos de LINQ to Objects.
LINQ to ADO.NET (Página de portal)	Incluye vínculos a información general, instrucciones de programación y ejemplos de LINQ to ADO.NET.
LINQ to XML	Incluye información general, instrucciones de programación y ejemplos de LINQ to XML.