Utilizando LinQ y VB.NET

Introducción

Muchas veces hemos visto ejemplos de LINQ con C#, tantos que algunas veces se llega a pensar que LINQ es solo para C#. Pero como dice El Guille, lo bueno tiene dos letras: VB :) Este este pequeño articulo veremos un ejemplo práctico, teniendo dos clases, Alumno y Asignatura, he dejado los atributos públicos para facilitar el ejemplo, pero podríamos utilizar propiedades. Tendremos un formulario para poder realizar las consultas y mostrar los datos .

Nota:
Para bajar LINQ puedes ir a esta página del Guille y están los enlaces para que lo bajes. Para los que tenemos Windows XP Professional en español, y la instalación de LINQ nos falla, ya que el instalador nos indica que nuestra cuenta de usuario no tiene los privilegios suficientes ( incluso con la cuenta administrador) , podemos solucionar este problema creando la cuenta Power Users, eso si, debemos recordar que debe pertenecer al grupo de los administradores.

Comenzando

Una vez instalado LINQ, podemos comenzar, para eso elegimos nuevo proyecto "LINQ Windows Application", y creamos dos clases, muy sencillas:

Clase Alumno:

Public Class Alumno
  Public OID As Integer
  Public nombre As String
  Public apellido As String
  Public becado As Boolean
  Public ramos As List(Of Asignatura)

  Public Function Existe(ByVal nombreAsig As String) As Boolean
    Dim i As Integer
    For i = 0 To ramos.Count - 1
      If ramos.Item(i).nombre = nombreAsig Then
        Return True
      End If
    Next
  End Function

End Class

Clase Asignatura

Public Class Asignatura
  Public OID As Integer
  Public nombre As String
End Class

Public ramos As List(Of Asignatura)

Ahora bien, tendremos un formulario sencillo, de manera de seleccionar en un ComboBox las asignaturas y en un CheckBox seleccionaremos Becado/No Becado, todo esto servirá de filtro para nuestra búsqueda.

Con las nuevas mejoras que vienen en VB 9, constamos con tipos anónimos, inicializadores de objetos entre otros, vamos a ver como podemos utilizarlas.

Veamos el código:

Public Class Form1
  Private Sub Button1_Click(ByVal sender As System.Object, _
			    ByVal e As System.EventArgs) _
			    Handles cmd_buscar.Click
    'Limpieza del listbox
    lsb_listado.Items.Clear()

    'Creamos las Asignaturas y asignamos los valores
    'asignamos los valores direcamtente, sin necesidad de constructor!
    Dim Lenguaje As New Asignatura {OID := 1, nombre := "Lenguaje"}
    Dim Matematicas As New Asignatura {OID := 2, nombre := "Matematicas"}
    Dim Programacion As New Asignatura {OID := 3, nombre := "Programacion"}

    'Creamos listas genericas con Asignaturas
    Dim lista1 As New List(Of Asignatura)
    lista1.Add(Programacion)
    lista1.Add(Matematicas)

    Dim lista2 As New List(Of Asignatura)
    lista2.Add(Programacion)
    lista2.Add(Matematicas)
    lista2.Add(Lenguaje)

    Dim lista3 As New List(Of Asignatura)
    lista3.Add(Programacion)
    lista3.Add(Lenguaje)

    'Creamos una lista de objetos y de nuevo , asignamos los valores 
    ' haciendo uso de las nuevas caracteristicas de VB 9.
    Dim curso As New List(Of Alumno) { _
       {OID := 1, nombre := "Roberto", Apellido := "Pérez", _
				becado := True, ramos := lista1}, _
       {OID := 2, nombre := "Javier", Apellido := "Chavarria", _
				becado := True, ramos := lista2}, _
       {OID := 3, nombre := "Daniel", Apellido := "Quiroz", _
				becado := True, ramos := lista3}, _
       {OID := 4, nombre := "Jose Luis", Apellido := "Contreras", _
				becado := False, ramos := lista2}, _
       {OID := 5, nombre := "Rodrigo", Apellido := "FuenteAlba", _
				becado := False, ramos := lista3} _
       }

    'Hacemos la consulta de alumnos sobre la lista, 
    'hacemos uso de él método Existe para evaluar la coincidencia de ramos
    'y además consultamos si el alumno es becado 

    'Además podemos observar que el resultado es una nueva colección de objetos
    'que tiene dos atributos, y gracias a las nuevas caracteristicas, podemos
    'instanciar y asignar los valores, como en un constructor explicito.
    Dim resultado = From Alumno In curso _
      Where Alumno.Existe(cmb_asignaturas.SelectedItem.ToString) _
      AndAlso Alumno.becado = chk_becado.Checked _
      Select New {Codigo := Alumno.OID, _
			NombreCompleto := Alumno.nombre & " " & Alumno.apellido}

    'Ahora tenemos una colección de tipos anónimos,
    'la cual podemos recorrer 
    For Each al In resultado
      lsb_listado.Items.Add(al.Codigo & " " & al.NombreCompleto)
    Next

  End Sub
End Class

Analizando un poco.

Veamos algunos detalles importantes:

Dim Lenguaje As New Asignatura {OID := 1, nombre := "Lenguaje"}

VB 9.0 posee un nuevo inicializador de objetos, basado en la expresión with , de manera que lo anterior es similar a:

 Dim Lenguaje As New Asignatura()
    With Lenguaje
      .OID = 1
      .nombre = "Lenguaje"
    End With
End Class

Es similar a tener un constructor explícito en donde se le pasa como argumento los valores para inicializar los atributos del constructor, pero sin tenerlo, digámoslo de una manera sencilla, tener un constructor implícito que además permite inicializar los atributos :).

Luego, la idea es crear una lista de alumnos, inicializar sus valores y agregarlos a una lista genérica.

Dim curso As New List(Of Alumno) { _
       {OID := 1, nombre := "Roberto", Apellido := "Pérez", becado := True, ramos := lista1}, ... 

A continuación veamos la consulta sobre la colección de objetos:

Dim resultado = From Alumno In curso _
      Where Alumno.Existe(cmb_asignaturas.SelectedItem.ToString) _
      AndAlso Alumno.becado = chk_becado.Checked _ 
      Select New {Codigo := Alumno.OID, NombreCompleto := Alumno.nombre & " " & Alumno.apellido}
      

Tenemos una similitud muy grande con SQL, por lo que el aprendizaje de LINQ es mucho más rápido. Podemos ver que evaluamos también el resultado de un método en la consulta. Además fijémonos en la nueva características del tipo de datos anónimos, esto es resultado es una colección de instancias de tipos anónimos, esto es ,IEnumerable(Of { Codigo As Integer, NombreCompleto As String }) . Podemos abreviar aun más el Select de la consulta, en el caso que quisiéramos seleccionar solo el OID, y el nombre, creando un objeto con atributos idénticos a los de Alumno.

Select New { Alumno.OID, Alumno.nombre } 

Ahora podemos recorrer esta colección de instancias de tipos anónimos simplemente con el For Each, además fíjate que el IDE te mostrará inmediatamente después de creado el tipo anónimo los atributos que le pertenecen.

Luego, al ejecutar, vamos a tener el resultado en pantalla según la selección que hicimos en el formulario.
Hay que decir que este ejemplo es bastante simple, pero LINQ se puede aplicar a dataset, también XML y en el futuro, extensible a nuevas colecciones como lo son permisos de active directory, el filesystem, resultados de búsquedas, msn y mucho más.

Espero que este ejemplo te haya servido para aprender un poco más sobre lo que viene :)

Espacios de nombres usados en el código de este artículo:

Microsoft.VisualBasic.LINQ