Comment rechercher une propriété à partir d'une table avec linq?

Question

J'ai besoin de rechercher une table dblinq afin que la fonction retourne la liste des lignes si l'un des champs correspond à l'entrée de recherche.

Il est plus similaire à la recherche Google où vous effectuez une recherche avec un mot-clé et la liste des documents correspondants sont affichés.

J'ai utilisé la réflexion pour cette technique. Pouvez-vous vérifier si cette méthode est correcte ou existe-t-il une méthode simple pour y parvenir?

J'ai toutes les propriétés des lignes de la table dblinq et comparé si son type de chaîne, puis vérifier la valeur.

Le code que je l'ai utilisé

public static List<Contacts> SearchContact(string searchText) 
    { 

     List<Contacts> list = new List<Contacts>(); 
     try 
     { 
      var rows= from p in context.tblContacts select p; 

      foreach (var contact in rows) 
      { 
       Type type = contact.GetType(); 
       Type typesearch = searchText.GetType(); 
       PropertyInfo[] properties = type.GetProperties(); 
       foreach (PropertyInfo pro in properties) 
       { 
        if (pro.PropertyType == typesearch) 
        { 

         var value = pro.GetValue(contact, null); 
         string val = value as string; 

          if (val != null && val == searchText) 
          { 
           list.Add(contact); 
           break; 
          } 

        } 
       } 
      } 
     } 
     catch (Exception ex) 
     { 
     } 
     return list; 
    } 

PS: Je reçois les résultats attendus de cette méthode, mais je voudrais savoir si j'ai trop une autre façon.

Answer 1

J'ai pas Visual Studio à la main pour le tester, mais cela devrait fonctionner aussi:

var contactProperties = typeof(Contact).GetProperties() 
           .Where(x => x.PropertyType == typeof(string)) 
           .ToArray(); 

from contact in context.tblContacts 
from property in contactProperties 
let value = property.GetValue(contact, null) as string 
where value == searchText 
select contact 

je recevrais les propriétés qu'une seule fois parce qu'il est le même à chaque fois.

Sur votre question de savoir si utiliser la réflexion ou non .. cela dépend. Si votre type Contact ne possède que quelques propriétés de chaîne (2-5), j'implémenterais cette méthode à la main au lieu d'utiliser la réflexion. Cela peut être un peu fastidieux mais payant en termes de lisibilité, de rapidité (mais ne devrait pas être une différence notable) et vous pouvez contrôler quelles propriétés sont comparées (peut-être votre Contact contient une propriété de chaîne qui ne devrait pas être recherchée).

Si vous envisagez d'étendre/modifier le type Contact ou de vérifier un gros morceau de propriétés, je voudrais aller avec la réflexion.

Answer 2

public static List<Contacts> SearchContact(string searchText) 
{ 
     return (from contact in context.tblContacts 
      let type = contact.GetType() 
      let typesearch = searchText.GetType() 
      let properties = type.GetProperties() 
      where (from pro in properties 
        where pro.PropertyType == typesearch 
        select pro.GetValue(contact, null) 
        into value 
        select value as string).Any(val => val != null && val == searchText) 
      select contact).ToList(); 
} 

EDIT: la partie gestion des exceptions est manquante mais il est assez facile à comprendre.