Filtrado de datos en LinqDataSource con VB.NET

Recientemente me enfrenté al desafío de implementar un buscador dinámico en una aplicación ASP.NET WebForms utilizando VB.NET y un control LinqDataSource. Lo que parecía una tarea sencilla de filtrado se convirtió en un excelente caso de estudio sobre las limitaciones de traducción de LINQ to SQL y la necesidad de balancear el rendimiento con la simplicidad del código.

1. El escenario y el primer tropiezo

El objetivo inicial era filtrar una vista de base de datos (vw_planification) en el evento Selecting de un LinqDataSource. Quería permitir al usuario buscar registros que coincidieran con una lista de términos predefinidos en memoria. Mi primer intento intuitivo fue estructurar la consulta de la siguiente manera:

Dim busqueda As List(Of String) = New List(Of String) From {"Internado", "Medicina"}

e.Result = (From item In db.vw_planification
            Where item.term = terms And busqueda.Contains(item.subject)
            Select item).ToList()

Aunque la lógica parecía impecable, el control no retornaba ningún resultado. Aquí es donde radica la primera distinción importante en LINQ:

• lista.Contains(item.columna): Equivale a un operador IN en SQL (WHERE columna IN ('valor1', 'valor2')). Requiere coincidencias exactas.
• item.columna.Contains(cadena): Equivale a un operador LIKE (WHERE columna LIKE '%cadena%'). Permite coincidencias parciales.

2. El choque con las limitaciones de LINQ to SQL

Cuando intenté flexibilizar la búsqueda para que admitiera coincidencias parciales usando una secuencia local con la función Any, me topé con un error crítico en tiempo de ejecución:

Este error ocurre porque el proveedor de LINQ to SQL no sabe cómo traducir una colección en memoria (como una lista de strings de búsqueda) combinada con un método de extensión como Any(Function(x) columna.Contains(x)) a una sentencia SQL válida. El motor de base de datos se queda sin saber qué hacer y la ejecución falla.

3. Diseñando un buscador flexible (Multi-palabra y Case-Insensitive)

Para solucionar esto, primero debíamos entender cómo procesar la entrada del usuario. Si el usuario escribe "internado medicina" en un cuadro de texto, necesitamos separar estas palabras para buscar registros que contengan ambos términos, sin importar el orden y sin distinguir entre mayúsculas y minúsculas.

La estrategia consiste en limpiar el texto de entrada, dividirlo por espacios y generar una lista limpia de términos:

Dim busqueda As String = wucBusqueda1.TextoBuscar.Trim().ToLower()
Dim listaBusqueda As List(Of String) = busqueda.Split({" "c}, StringSplitOptions.RemoveEmptyEntries).Select(Function(s) s.Trim()).ToList()

4. La solución: Filtrado híbrido en memoria

Dado que la base de datos con la que estaba trabajando para este catálogo específico contenía un volumen controlado de datos (alrededor de 250 registros), la solución más pragmática y eficiente fue realizar un filtrado híbrido. Primero, traemos los datos a memoria (LINQ to Objects) y luego aplicamos la lógica de búsqueda compleja que SQL no puede procesar directamente:

Protected Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
    Dim busqueda As String = wucBusqueda1.TextoBuscar.Trim().ToLower()
    Dim listaBusqueda As List(Of String) = busqueda.Split({" "c}, StringSplitOptions.RemoveEmptyEntries).Select(Function(s) s.Trim()).ToList()

    Dim db As New dtcVistasDataContext
    ' 1. Traemos los datos a memoria (LINQ to Objects)
    Dim todosLosRegistros = (From p In db.vw_planification Select p).ToList()

    ' 2. Filtramos usando "All" para asegurar que todas las palabras buscadas existan en el campo
    Dim valores = todosLosRegistros.Where(Function(p)
                                Dim subjectLower = p.subject.ToLower()
                                Return listaBusqueda.All(Function(term) subjectLower.Contains(term))
                            End Function).ToList()

    GridView1.DataSource = valores
    GridView1.DataBind()
End Sub

En este código, term (que podría llamarse de cualquier otra forma, como x o palabra) actúa como la variable de iteración de la expresión lambda. Representa cada palabra individual dentro de nuestra listaBusqueda. Al usar listaBusqueda.All(...), garantizamos que el registro solo se seleccionará si todas las palabras ingresadas por el usuario se encuentran dentro del campo subject, resolviendo el problema de buscar términos fuera de orden (por ejemplo, buscar "Internado Pediatría" y encontrar "Internado de Pediatría Rotatorio").

5. ¿Vale la pena filtrar en memoria?

Cuando trabajamos con bases de datos, la regla general suele ser "deja que el motor de base de datos haga el trabajo pesado". Sin embargo, en el desarrollo de software real, la teoría debe balancearse con la práctica:

• Cuándo es una excelente opción: Para conjuntos de datos pequeños o moderados (menos de 1,000 registros). La diferencia de rendimiento entre resolver la consulta en SQL Server o en la memoria del servidor web es de apenas unos milisegundos, y nos ahorramos la complejidad de escribir Árboles de Expresión (Expression Trees) dinámicos en LINQ.
• Cuándo evitarlo: Si la tabla posee decenas de miles de registros o crece exponencialmente. En ese escenario, descargar toda la tabla con .ToList() saturará la memoria del servidor y degradará el rendimiento general del sistema.