Introducción a LINQ en Visual Basic

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 una 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 la sección de una consulta LINQ”, incluye el siguiente código, que devuelven listas de customers y 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 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.

Estructura de una 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.

' 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

' 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

' 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

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

' 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

' 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

' 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

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

' 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

' 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

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

' 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

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

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

' 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 para combinar los resultados de dos consultas en un resultado de consulta.Utiliza el método ToList<TSource> 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

Temas "Cómo..." y tutoriales

Cómo: Consultar una base de datos usando LINQ (Visual Basic)

Cómo: Llamar a un procedimiento almacenado usando LINQ (Visual Basic)

Cómo: Modificar datos en una base de datos usando LINQ (Visual Basic)

Cómo: Combinar datos con LINQ usando cláusulas Join (Visual Basic)

Cómo: Ordenar los resultados de una consulta mediante LINQ (Visual Basic)

Cómo: Filtrar los resultados de consultas usando LINQ (Visual Basic)

Cómo: Hacer el recuento, la suma o el promedio de datos usando LINQ (Visual Basic)

Cómo: Buscar los valores máximo y mínimo en el resultado de una consulta usando LINQ (Visual Basic)

Walkthrough: Creating LINQ to SQL Classes (O/R Designer)

How to: Assign Stored Procedures to Perform Updates, Inserts, and Deletes (O/R Designer)

Capítulos destacados del libro

Chapter 17: LINQ en Programming Visual Basic 2008

Vea también

Tareas

Ejemplos de LINQ

Conceptos

Información general sobre LINQ to XML en Visual Basic

LINQ to DataSet Overview

DataContext Methods (O/R Designer)

Otros recursos

LINQ (Language-Integrated Query)

LINQ to SQL

Object Relational Designer (O/R Designer)