¿Cómo añado una cláusula 'where' usando VB.NET y LINQ?

Question

Soy bastante nuevo en VB.NET y estoy teniendo problemas aquí con algo que pensé que debería ser simple.

Manteniéndolo simple, digamos que tengo una tabla de documentos con "Nombre" que quiero buscar (en realidad hay varias otras tablas, uniones, etc.). Necesito poder construir la consulta usando una cláusula where basada en valores de cadena pasados.

Ejemplo: el usuario puede pasar en "ABC", "ABC DEF", "ABC DEF GHI".

La pregunta final sería (la sintaxis no es correcta, lo sé):

Select * from Documents Where Name Like %ABC% AND Name Like %DEF% AND Name like %GHI% 

lo tanto, pensé que podía hacer algo como esto.

Dim query = From document In _context.Documents 

<< loop based on number of strings passed in >> 
query = query.Where(... what goes here??) 

Por alguna razón, siendo clínicamente muerto o algo así, no puedo encontrar la manera de hacer este trabajo en VB.NET, o si lo estoy haciendo correctamente.

Answer 1

Dim query = From document In _context.Documents where document.name = 'xpto' select document 

O

Dim query = From document In _context.Documents where document.name.contains('xpto') select document 

Answer 2

Creo que esta es la forma en que lo haría en VB (soy un desarrollador de C#):

query = query.where(Function(s) s = "ABC") 

Ver LINQ - Sample Queries para algunos ejemplos.

Answer 3

Si hace esto en un bucle, se puede hacer algo como esto:

.Where(Function(i as mytype) i.myfiltervar = WhatIWantToSelect) 

Answer 4

Creo que la parte difícil aquí es el número desconocido de los parámetros de consulta. Puede utilizar el LINQ IQueryable subyacente (Of T) aquí para ayudar.

creo que el siguiente iba a funcionar (no es compilado, solo código de bloc de notas aquí):

Public Function GetDocuments(criteria as String) 
    Dim splitCriteria = SplitTheCriteria(criteria) 

    dim query = from document in _context.Documents 

    For Each item in splitCriteria 
     Dim localItem = item 
     query = AddCriteriaToQuery(query, localItem) 
    Next 

    dim matchingDocuments = query.ToList() 
End Function 

Private Function AddCriteriaToQuery(query as IQueryable(Of Document), criteria as string) as IQueryable(Of Document) 
    return query.Where(Function(doc) doc.Name = criteria) 
End Function 

Desde LINQ retrasará a ejecutar la consulta puede anexar donde cláusulas favoritas en tu consulta en el bucle y luego llamar .ToList() al final para ejecutar la consulta.

Answer 5

En LINQ to SQL, puede agregar las cláusulas WHERE a su consulta utilizando el método .Where del objeto de consulta, como indicó en su pregunta. Para usar el operador LIKE, intente utilizar el método .Contains del objeto que está consultando en la expresión Lambda de su llamada al método Where.

Aquí hay un ejemplo simplificado en una aplicación de consola. Con suerte, te guiará en la dirección correcta.

Public Class Doc 

    Private _docName As String 
    Public Property DocName() As String 
     Get 
      Return _docName 
     End Get 
     Set(ByVal value As String) 
      _docName = value 
     End Set 
    End Property 

    Public Sub New(ByVal newDocName As String) 
     _docName = newDocName 
    End Sub 
End Class 

Sub Main() 
    Dim Documents As New List(Of Doc) 
    Documents.Add(New Doc("ABC")) 
    Documents.Add(New Doc("DEF")) 
    Documents.Add(New Doc("GHI")) 
    Documents.Add(New Doc("ABC DEF")) 
    Documents.Add(New Doc("DEF GHI")) 
    Documents.Add(New Doc("GHI LMN")) 

    Dim qry = From docs In Documents 

    qry = qry.Where(Function(d) d.DocName.Contains("GHI")) 

    Dim qryResults As List(Of Doc) = qry.ToList() 

    For Each d As Doc In qryResults 
     Console.WriteLine(d.DocName) 
    Next 

End Sub 

Observe la llamada .Contains ("GHI") en la expresión Lambda del método .Where. Me refiero al parámetro de la expresión, "d", que expone la propiedad DocName, que expone aún más el método .Contains. Esto debería producir la consulta LIKE que estás esperando.

Este método es aditivo, es decir, la llamada al método .Where podría incluirse en un bucle para agregar operadores LIKE adicionales a la cláusula WHERE de su consulta.