Comment ajouter une clause 'where' avec VB.NET et LINQ?

Question

Je suis assez nouveau à VB.NET et j'ai un peu de problème ici avec quelque chose que je pensais être simple.

Garder simple, disons que j'ai une table de document avec « Nom » que je veux chercher sur (en réalité, il existe plusieurs autres tables, jointures, etc ..). Je dois être en mesure de construire la requête en utilisant une clause where basée sur les valeurs de chaîne passées.

Exemple - l'utilisateur peut transmettre "ABC", "ABC DEF", "ABC DEF GHI".

La requête finale serait (la syntaxe est pas correcte, je sais):

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

Alors, je pensais que je pouvais faire quelque chose comme ça.

Dim query = From document In _context.Documents 

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

Pour une raison quelconque, être mort cérébrale ou quelque chose, je ne peux pas comprendre comment faire ce travail en VB.NET, ou si je le fais correctement.

Answer 1

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

Ou

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

Answer 2

Je crois que c'est la façon dont vous le feriez en VB (Je suis un développeur C#):

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

Voir LINQ - Sample Queries quelques exemples.

Answer 3

Si vous faites cela dans une boucle, vous pouvez faire quelque chose comme ceci:

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

Answer 4

Je pense que la partie la plus délicate est ici le nombre de paramètres inconnus de la requête. Vous pouvez utiliser le LINQ IQueryable (Of T) sous-jacent ici pour vous aider.

Je pense que ce qui suit fonctionnerait (il est pas compilé, juste le code bloc-notes ici):

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 

Depuis LINQ retardera-exécution de la requête, vous pouvez ajouter où les clauses sur votre requête dans la boucle, puis appelez .ToList() à la fin pour exécuter la requête.

Answer 5

Dans LINQ to SQL vous pouvez ajouter des clauses WHERE à votre requête en utilisant la méthode .Lorsque de l'objet de la requête, comme vous l'avez dit dans votre question. Pour utiliser l'opérateur LIKE, essayez d'utiliser la méthode .Contains de l'objet que vous interrogez dans l'expression Lambda de votre appel à la méthode Where.

Voici un exemple simplifié dans une application console. J'espère que cela vous mènera dans la bonne direction.

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 

Notez l'appel .Contains ("GHI") dans l'expression Lambda de la méthode .Where. Je référence le paramètre de l'expression, "d", qui expose la propriété DocName, qui expose en outre la méthode .Contains. Cela devrait produire la requête LIKE que vous attendez.

Cette méthode est additive, c'est-à-dire que l'appel à la méthode .Where peut être inclus dans une boucle pour ajouter des opérateurs LIKE supplémentaires à la clause WHERE de votre requête.