Compartir a través de

Operaciones básicas de consulta (Visual Basic)

En este tema se proporciona una breve introducción a las expresiones de consulta de Language-Integrated (LINQ) en Visual Basic y a algunos de los tipos típicos de operaciones que se realizan en una consulta. Para obtener más información, consulte los temas siguientes:

Introducción a LINQ en Visual Basic

Consultas

Tutorial: Escritura de consultas en Visual Basic

Especificando el origen de datos (Desde)

En una consulta LINQ, el primer paso es especificar el origen de datos que desea consultar. Por lo tanto, la From cláusula de una consulta siempre viene primero. Los operadores de consulta seleccionan y dan forma al resultado en función del tipo del origen.

Dim query = From cust In customers
'           ...

La From cláusula especifica el origen de datos, customers, y una variable de intervalo, cust. La variable de rango es como una variable de iteración de bucle, excepto que en una expresión de consulta, no se produce ninguna iteración real. Cuando se ejecuta la consulta, a menudo mediante un For Each bucle , la variable de intervalo actúa como referencia a cada elemento sucesivo de customers. Dado que el compilador puede deducir el tipo de cust, no es necesario especificarlo explícitamente. Para obtener ejemplos de consultas escritas con y sin escritura explícita, vea Relaciones de tipos en operaciones de consulta (Visual Basic) .

Para obtener más información sobre cómo usar la From cláusula en Visual Basic, vea From Clause.

Filtrado de datos (dónde)

Probablemente la operación de consulta más común es aplicar un filtro en forma de una expresión booleana. Luego, la consulta devuelve solo los elementos para los que la expresión es verdadera. Se usa una Where cláusula para realizar el filtrado. El filtro especifica qué elementos del origen de datos se van a incluir en la secuencia resultante. En el ejemplo siguiente, solo se incluyen los clientes que tienen una dirección en Londres.

Dim londonCusts = From cust In customers
                  Where cust.City = "London"
'                 ...

Puede usar operadores lógicos como And y Or para combinar expresiones de filtro en una Where cláusula . Por ejemplo, para devolver solo los clientes que son de Londres y cuyo nombre es Devon, use el código siguiente:

Where cust.City = "London" And cust.Name = "Devon"

Para devolver clientes de Londres o París, use el código siguiente:

Where cust.City = "London" Or cust.City = "Paris"

Para obtener más información sobre cómo usar la Where cláusula en Visual Basic, vea Where Clause.

Ordenar datos (Ordenar por)

A menudo es conveniente ordenar los datos devueltos en un orden determinado. La Order By cláusula hará que los elementos de la secuencia devuelta se ordenan en un campo o campos especificados. Por ejemplo, la consulta siguiente ordena los resultados en función de la Name propiedad . Dado que Name es una cadena, los datos devueltos se ordenarán alfabéticamente, de A a Z.

Dim londonCusts1 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
'                   ...

Para ordenar los resultados en orden inverso, de Z a A, use la Order By...Descending cláusula . El valor predeterminado es Ascending cuando no se especifica ni Ascending ni Descending.

Para obtener más información sobre cómo usar la Order By cláusula en Visual Basic, vea Order By Clause.

Seleccionar datos (Select)

La Select cláusula especifica el formato y el contenido de los elementos devueltos. Por ejemplo, puede especificar si los resultados constarán de objetos completos Customer , solo una Customer propiedad, un subconjunto de propiedades, una combinación de propiedades de varios orígenes de datos o algún tipo de resultado nuevo basado en un cálculo. Cuando la Select cláusula genera algo distinto de una copia del elemento de origen, la operación se denomina proyección.

Para recuperar una colección que consta de objetos completos Customer , seleccione la propia variable de intervalo:

Dim londonCusts2 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select cust

Si una Customer instancia es un objeto grande que tiene muchos campos y todo lo que desea recuperar es el nombre, puede seleccionar cust.Name, como se muestra en el ejemplo siguiente. La inferencia de tipos locales reconoce que esto cambia el tipo de resultado de una colección de Customer objetos a una colección de cadenas.

Dim londonCusts3 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select cust.Name

Para seleccionar varios campos del origen de datos, tiene dos opciones:

  • En la Select cláusula , especifique los campos que desea incluir en el resultado. El compilador definirá un tipo anónimo que tenga esos campos como propiedades. Para obtener más información, consulte Tipos anónimos (Guía de programación de C#).

    Dado que los elementos devueltos en el ejemplo siguiente son instancias de un tipo anónimo, no puede hacer referencia al tipo por nombre en otro lugar del código. El nombre designado por el compilador para el tipo contiene caracteres que no son válidos en el código normal de Visual Basic. En el ejemplo siguiente, los elementos de la colección devueltas por la consulta en londonCusts4 son instancias de un tipo anónimo.

    Dim londonCusts4 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select Name = cust.Name, Phone = cust.Phone

For Each londonCust In londonCusts4
    Console.WriteLine(londonCust.Name & " " & londonCust.Phone)
Next

    -o-

  • Defina un tipo con nombre que contenga los campos concretos que desea incluir en el resultado y cree e inicialice instancias del tipo en la Select cláusula . Use esta opción solo si tiene que usar resultados individuales fuera de la colección en la que se devuelven o si tiene que pasarlos como parámetros en las llamadas al método. El tipo de londonCusts5 en el ejemplo siguiente es IEnumerable(Of NamePhone).

    Public Class NamePhone
    Public Name As String
    Public Phone As String
    ' Additional class elements
End Class

    Dim londonCusts5 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select New NamePhone With {.Name = cust.Name,
                                              .Phone = cust.Phone}

Para obtener más información sobre cómo usar la Select cláusula en Visual Basic, vea Select Clause( Cláusula Select).

Combinación de datos (Join y Group Join)

Puede combinar más de un origen de datos de varias maneras en la From cláusula . Por ejemplo, el código siguiente usa dos orígenes de datos y combina implícitamente propiedades de ambas en el resultado. La consulta selecciona a los alumnos cuyos apellidos comienzan por una vocal.

Dim vowels() As String = {"A", "E", "I", "O", "U"}
Dim vowelNames = From student In students, vowel In vowels
                 Where student.Last.IndexOf(vowel) = 0
                 Select Name = student.First & " " &
                 student.Last, Initial = vowel
                 Order By Initial

For Each vName In vowelNames
    Console.WriteLine(vName.Initial & ":  " & vName.Name)
Next

Nota:

Puede ejecutar este código con la lista de alumnos creados en Cómo: Crear una lista de elementos.

La Join palabra clave es equivalente a un INNER JOIN en SQL. Combina dos colecciones basadas en valores clave coincidentes entre los elementos de las dos colecciones. La consulta devuelve todos o parte de los elementos de colección que tienen valores de clave coincidentes. Por ejemplo, el código siguiente duplica la acción de la combinación implícita anterior.

Dim vowelNames2 = From student In students
                  Join vowel In vowels
                  On student.Last(0) Equals vowel
                  Select Name = student.First & " " &
                  student.Last, Initial = vowel
                  Order By Initial

Group Join combina colecciones en una sola colección jerárquica, al igual que en LEFT JOIN SQL. Para obtener más información, vea Join (Cláusula) y Group Join (Cláusula).

Agrupar datos (agrupar por)

Puede agregar una Group By cláusula para agrupar los elementos de un resultado de consulta según uno o varios campos de los elementos. Por ejemplo, el código siguiente agrupa a los alumnos por año de clase.

Dim studentsByYear = From student In students
                     Select student
                     Group By year = student.Year
                     Into Classes = Group

For Each yearGroup In studentsByYear
    Console.WriteLine(vbCrLf & "Year: " & yearGroup.year)
    For Each student In yearGroup.Classes
        Console.WriteLine("   " & student.Last & ", " & student.First)
    Next
Next

Si ejecuta este código con la lista de alumnos creados en How to: Create a List of Items (Cómo: Crear una lista de elementos), la salida de la For Each instrucción es:

Año: Junior

Tucker, Michael

García, Hugo

Garcia, Debra

Tucker, Lance

Año: Senior

Omelchenko, Svetlana

Osada, Michiko

Fakhouri, Fadi

Feng, Hanying

Adams, Terry

Año: Estudiante de primer año

Mortensen, Sven

García, Cesar

La variación que se muestra en el código siguiente ordena los años de clase y, a continuación, ordena a los alumnos dentro de cada año por apellido.

Dim studentsByYear2 = From student In students
                      Select student
                      Order By student.Year, student.Last
                      Group By year = student.Year
                      Into Classes = Group

Para obtener más información sobre Group By, vea Group By Clause.

Consulte también

  • Last updated on