Come si aggiunge una clausola 'where' usando VB.NET e LINQ?

Question

Sono abbastanza nuovo a VB.NET e sto avendo un po 'di problemi qui con qualcosa che ho pensato dovrebbe essere semplice.

Semplicità, diciamo che ho una tabella dei documenti con "Nome" su cui voglio cercare (in realtà ci sono molti altri tavoli, join, ecc ..). Devo essere in grado di creare la query utilizzando una clausola where basata su valori di stringa passati.

Esempio: l'utente può passare in "ABC", "ABC DEF", "ABC DEF GHI".

La query finale sarebbe (la sintassi non è corretta, lo so):

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

Così, ho pensato che avrei potuto fare qualcosa di simile.

Dim query = From document In _context.Documents 

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

Per qualche ragione, essendo morte cerebrale o qualcosa, non riesco a capire come fare questo lavoro in VB.NET, o se sto facendo correttamente.

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

Credo che questo è come si farebbe in VB (Sono uno sviluppatore C#):

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

Vedi LINQ - Sample Queries per alcuni esempi.

Answer 3

Se fate questo in un ciclo, si può fare qualcosa di simile:

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

Answer 4

penso che la parte difficile qui è il numero sconosciuto di parametri di query. Puoi utilizzare il LINQ IQueryable sottostante (Of T) qui per aiutarti.

penso che il seguente avrebbe funzionato (non è compilato, solo il codice blocco note qui):

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 

Dal LINQ ritarderà-eseguire la query è possibile aggiungere in cui le clausole sul vostro interrogazione nel ciclo e quindi chiamare .ToList() alla fine per eseguire la query.

Answer 5

In LINQ a SQL è possibile aggiungere clausole WHERE alla query utilizzando il metodo .Where dell'oggetto query, come indicato nella domanda. Per usare l'operatore LIKE, prova ad usare il metodo .Contains dell'oggetto che stai interrogando nell'espressione Lambda della tua chiamata al metodo Where.

Ecco un esempio semplificato in un'applicazione console. Spero che ti guidi nella direzione giusta.

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 

Nota la chiamata .Contains ("GHI") nell'espressione Lambda del metodo .Where. Sto facendo riferimento al parametro dell'espressione "d", che espone la proprietà DocName, che espone ulteriormente il metodo .Contains. Questo dovrebbe produrre la query LIKE che ti aspetti.

Questo metodo è additivo, ovvero la chiamata al metodo .Where potrebbe essere racchiusa in un ciclo per rendere aggiuntivi operatori LIKE aggiunti alla clausola WHERE della query.