Avril 2019

Volume 34, numéro 4

[.NET]

Implémentation de votre propre recherche de contenu d'entreprise

Par Xavier Morera

Recherche est probablement fallu pour reçoivent. Vous utilisez tous les jours pour effectuer toutes sortes de tâches, de découvrir une salle pour votre prochain voyage, à la localisation des informations que vous avez besoin pour votre travail. Une recherche correctement mise en œuvre peut vous aider à économiser de l’argent, ou générer des revenus. Et même dans une application réussie, une recherche incorrecte crée toujours une expérience peu satisfaisante utilisateur.

Le problème est qu’en dépit de son importance, recherche est une des fonctionnalités plus mal comprises dans l’informatique, ne remarqué que lorsque manquant ou rompu. Mais la recherche n’a pas besoin être une fonctionnalité obscure est difficile à implémenter. Dans cet article je vais expliquer comment vous pouvez développer une API de recherche de l’entreprise dans C#.

Pour en savoir plus sur la recherche, vous avez besoin d’un moteur de recherche. De nombreuses options, à partir de l’open source pour les commerciaux et tous les éléments entre eux, bon nombre d'entre elles exploiter en interne Lucene, la bibliothèque de la récupération des informations de choix. Cela inclut la recherche Azure, ElasticSearch et Solr. Aujourd'hui, je vais utiliser Solr. Pour quelle raison ? Il a été autour pendant une longue période, a une bonne documentation, une communauté active, nombre d’utilisateurs notable, et je l’ai personnellement utilisée pour implémenter la recherche dans de nombreuses applications, à partir de sites de petite taille pour les grandes entreprises.

Obtention de Solr

L’installation d’un moteur de recherche peut sembler une tâche complexe et, en effet, si vous configurez une instance de Solr de production qui doit prendre en charge d’un grand nombre de requêtes par seconde (RPS), puis Oui, il peut être compliqué. (Requêtes par seconde est une mesure commune utilisée pour faire référence à la charge de travail de recherche).

Ces étapes sont décrites en détail dans la section « Installation Solr » de la documentation de Solr (lucene.apache.org/solr), comme la section « Guide de référence de Apache Solr » ainsi que dans des « The Well-Configured Solr Instance » (bit.ly/2IK7mqY). Mais je dois simplement une instance de Solr développement, donc j’accède simplement à bit.ly/2tEXqoo et obtenir une version binaire ; solr-7.7.0.zip fonctionnera.

Télécharger le fichier .zip, décompressez, ouvrez la ligne de commande et accédez au répertoire à la racine du dossier dans lequel j’ai décompressé le fichier. Ensuite, j’émets la commande suivante :

> bin\solr.cmd start

C'est terminé. Je dois simplement accéder à http://localhost:8983, où je suis accueilli avec Solr Admin UI, illustrée Figure 1.

En cours d’exécution et de la figure 1 un moteur de recherche de

Obtention de données

Ensuite, j’ai besoin de données. Il existe de nombreuses de jeux de données disponibles avec des données intéressantes, mais tous les jours des milliers de développeurs se retrouvent sur StackOverflow, car ils vous ignorez comment écrire dans un fichier ; ils ne peuvent pas quitter VIM ; ou dont ils ont besoin un C# extrait de code qui résout un problème particulier. La bonne nouvelle est que les données de Stack Overflow seront disponibles comme un dump XML contenant les badges de questions et réponses, balises, environ 10 millions, les informations utilisateur anonymes et bien plus encore (bit.ly/1GsHll6).

Mieux encore, je peux sélectionner un jeu de données avec le même format à partir d’un site StackExchange plus petits qui les contient quelques milliers. Je peux tester d’abord avec le jeu de données plus petits et plus tard Dopez l’infrastructure pour travailler avec plus de données.

Je vais commencer par les données à partir de datascience.stackexchange.com, qui contient des billets d’environ 25 mille. Le fichier est nommé datascience.stackexchange.com.7z. J’ai le télécharger et extraire Posts.xml.

Quelques Concepts requis

J’ai un moteur de recherche et des données, il est temps de passer en revue quelques-unes des concepts importants. Si vous êtes habitué à utiliser avec les bases de données relationnelles, ils seront probablement familiers.

L’index est où un moteur de recherche stocke toutes les données collectées pour la recherche. À un niveau élevé, Solr stocke les données dans ce que l'on appelle un index inversé. Dans un index inversé, mots (ou jetons) pointent vers des documents spécifiques. Lorsque vous recherchez un mot particulier, qui est une requête. Si le mot est trouvé (une baisse ou une correspondance), l’index indique quels documents contiennent ce mot et où.

Le schéma est la façon dont vous spécifiez la structure des données. Chaque enregistrement est appelé un document, et simplement que vous définissez les colonnes d’une base de données, vous spécifiez les champs d’un document dans un moteur de recherche.

Vous construisez le schéma en modifiant un fichier XML appelé schema.xml, en définissant les champs avec leurs types. Toutefois, vous pouvez également utiliser des champs dynamiques, dans lequel un nouveau champ est créé automatiquement lors de l’ajout d’un champ inconnu. Il se peut que cela peut être utile lorsque vous n’avez pas sûrs de tous les champs qui sont présents dans les données.

Il sont peut-être déjà produites à vous que Solr est assez semblable à une banque de documents NoSQL, comme il peut contenir des documents avec des champs qui sont dénormalisées et pas nécessairement cohérentes entre la collection de documents.

Le mode sans schéma est une autre façon de modélisation des données au sein de l’index. Dans ce cas, vous n’explicitement dites Solr les champs que vous devez être l’indexation. Au lieu de cela, vous ajoutez simplement les données et Solr construit un schéma basé sur le type de données ajoutés à l’index. Pour utiliser le mode sans schéma, vous devez disposer d’un schéma géré, ce qui signifie que vous ne pouvez pas modifier manuellement les champs. Cela est particulièrement utile pour une phase d’exploration de données ou la preuve de concept.

Je vais utiliser un schéma modifié manuellement, ce qui est l’approche recommandée pour la production car il cède le contrôle supérieur.

L’indexation est le processus d’ajout de données à l’index. Lors de l’indexation, une application lit à partir de différentes sources et prépare les données pour l’ingestion. C’est le mot utilisé pour l’ajout de documents ; Vous entendrez également l’alimentation du terme.

Une fois que les documents sont indexés, il est possible de rechercher, j’espère que retourner les documents les plus pertinents pour une recherche particulière dans les positions supérieures. 

Classement de pertinence est la façon dont les résultats plus appropriés sont retournés en haut. Il s’agit d’un concept simple à expliquer. Dans le meilleur des cas, vous exécutez une requête et le moteur de recherche « lit » d’avis, retourner exactement les documents que vous recherchez.

Précision et de rappel : La précision indique combien de vos résultats sont pertinentes (la qualité de vos résultats), tandis que le rappel signifie nombre au total retourné les résultats sont pertinentes (la quantité ou l’exhaustivité des résultats). 

Analyseurs, générateurs de jetons et filtres : Indexé ou rechercher des données, un analyseur examine le texte et génère un flux de jetons. Les transformations sont ensuite appliquées par le biais de filtres pour tenter de faire correspondre des requêtes avec les données indexées. Vous devez comprendre ces si vous souhaitez une compréhension plus approfondie de la technologie de moteur de recherche. Heureusement, vous pouvez commencer à créer une application simplement une vue d’ensemble.

Présentation des données

J’ai besoin de comprendre les données pour modeler l’index. Pour ce faire, j’ouvre Posts.xml et analysez-le. 

Voici à quoi ressemblent les données. Le nœud publications contient plusieurs nœuds enfants de ligne. Chaque nœud enfant correspond à un seul enregistrement, avec chaque champ exporté en tant qu’attribut dans chaque nœud enfant. Les données sont relativement nettoyées pour l’ingestion dans le moteur de recherche, ce qui convient :

<posts>
  <row Id=”5” PostTypeId=”1” CreationDate=”2014-05-13T23:58:30.457”
    Score=”9” ViewCount=”448” Body=”<Contains the body of the question or answer>”
      OwnerUserId=”5” LastActivityDate=”2014-05-14T00:36:31.077”
        Title=”How can I do simple machine learning without hard-coding behavior?”
          Tags=”<machine-learning,artificial-intelligence>;” AnswerCount=”4”
            CommentCount=”5” FavoriteCount=”1”
              ClosedDate=”2014-05-14T14:40:25.950” />
  ...
</posts>

En un clin de œil, je peux observer rapidement les champs de types différents. Il existe un identificateur unique, plusieurs dates, deux champs numériques, certains champs de texte longs et courts certaines et certains champs de métadonnées. Par souci de concision, j’ai modifié le corps, qui est un champ de texte de grande taille, mais toutes les autres sont dans leur état d’origine.

Solr à utiliser un schéma classique de configuration

Il existe plusieurs façons de spécifier la structure des données pour l’index. Par défaut, Solr utilise un schéma géré, ce qui signifie qu’il utilise le mode sans schéma. Mais je veux construire le schéma manuellement, ce que l'on appelle un schéma classique, donc je dois apporter quelques modifications de configuration. Tout d’abord, je vais créer un dossier pour stocker la configuration de mon index, que j’appellerai msdnarticledemo. Le dossier est situé dans < solr > \server\solr\, où < solr > est le dossier dans lequel j’ai décompressé Solr.

Ensuite, je crée un fichier texte à la racine de ce dossier appelé core.properties, qui doit uniquement la ligne suivante ajoutée : nom = msdnarticledemo. Ce fichier est utilisé pour créer un cœur Solr, qui est simplement une instance en cours d’exécution d’un index Lucene. Vous entendrez la mot collection, trop, ce qui peut avoir une signification différente selon le contexte. Mon intention actuelle et un à des fins, un cœur est l’équivalent d’un index.

Je dois maintenant copier le contenu d’un index propre échantillon à utiliser comme base. Solr inclut un dans < solr > \server\solr\configsets\_default. Copier le dossier conf dans msdnarticledemo.

Dans la prochaine étape très importante, savoir Solr que je souhaite utiliser un schéma classique ; Autrement dit, que je vais modifier manuellement mon schéma. Pour ce faire, j’ai ouvrez solrconfig.xml et ajoutez la ligne suivante :

<schemaFactory class=”ClassicIndexSchemaFactory”/>

En outre, toujours dans ce fichier, j’ai commentaire à deux nœuds, l’updateRequestProcessorChain avec :

name=”add-unknown-fields-to-the-schema”
and updateProcessor with:
name=”add-schema-fields”

Ces deux fonctionnalités sont celles qui permettent de Solr pour ajouter de nouveaux champs lors de l’indexation des données en mode sans schéma. J’ai également supprimer le commentaire à l’intérieur de ce nœud xml, étant donné que «-- » n’est pas autorisé dans les commentaires xml.

Enfin, je renomme schéma géré pour le fichier schema.xml. Comme cela, Solr est prêt à utiliser un schéma créé manuellement.

Création du schéma

L’étape suivante consiste à définir les champs dans le schéma, afin de pouvoir ouvrir le fichier schema.xml et faites défiler jusqu'à trouver la définition de l’id, _text_ et _root_.

Voici comment chaque champ est défini comme un nœud xml < champ > qui contient :

• name : Le nom de chaque champ.
• Type : Le type du champ ; Vous pouvez modifier les modalités de chaque type dans le fichier schema.xml.
• indexés : True indique que ce champ peut être utilisé pour la recherche.
• stockées : True indique que ce champ peut être retourné pour l’affichage.
• Obligatoire : True indique que ce champ doit être indexé, sinon une erreur est générée.
• à valeurs multiples : True indique que ce champ peut contenir plusieurs valeurs.

Il peut s’agir à confusion au départ, mais certains champs peut être affiché, mais pas examiné et certaines peuvent être recherchés, mais peuvent ne pas pouvoir être récupérées après l’indexation. Autres attributs avancées, mais je n’entrerai dans les détails associés à ce stade.

Figure 2 montre comment j’ai définir les champs dans le schéma pour les publications. Pour les types de texte, j’ai diverses, y compris la chaîne, text_get_sort et text_general. Recherche de texte sont des principaux objectifs de la recherche, par conséquent, les différents types prenant en charge de texte. J’ai également une date, un entier, virgule flottante et un champ qui contient plusieurs valeurs, les balises.

Figure 2 les champs dans le fichier Schema.xml

<field name=”id” type=”string” indexed=”true” stored=”true”
  required=”true” multiValued=”false” />
<field name=”postTypeId” type=”pint” indexed=”true” stored=”true” />
<field name=”title” type=”text_gen_sort” indexed=”true”
  stored=”true” multiValued=”false”/
<field name=”body” type=”text_general” indexed=”false”
  stored=”true” multiValued=”false”/>
<field name=”tags” type=”string” indexed=”true” stored=”true”
  multiValued=”true”/>
<field name=”postScore” type=”pfloat” indexed=”true” stored=”true”/>
<field name=”ownerUserId” type=”pint” indexed=”true” stored=”true” />
<field name=”answerCount” type=”pint” indexed=”true” stored=”true” />
<field name=”commentCount” type=”pint” indexed=”true” stored=”true” />
<field name=”favoriteCount” type=”pint” indexed=”true” stored=”true” />
<field name=”viewCount” type=”pint” indexed=”true” stored=”true” />                
<field name=”creationDate” type=”pdate” indexed=”true” stored=”true” />
<field name=”lastActivityDate” type=”pdate” indexed=”true” stored=”true” />
<field name=”closedDate” type=”pdate” indexed=”true” stored=”true” />

Les prochaines étapes peuvent varier selon l’implémentation. Pour le moment, ont de nombreux champs et je peux spécifier celle que je veux rechercher Active et l’importance de ce champ par rapport à d’autres champs.

Mais pour commencer, je peux utiliser le champ de fourre-tout _text_ pour effectuer une recherche sur tous les champs de mon. J’ai simplement créer un copyField et indiquer Solr que les données à partir de tous les champs doivent être copiées dans Mon champ par défaut :

<copyField source=”*” dest=”_text_”/>

Maintenant, lorsque j’exécute une recherche, Solr rechercher dans ce champ et retourner n’importe quel document qui correspond à ma requête.

Ensuite, j’ai redémarrer Solr pour charger le noyau et appliquer les modifications, en exécutant la commande suivante :

> bin\solr.cmd restart

Je suis maintenant prêt à commencer à créer un C# application.                 

Obtention de SolrNet et de modélisation des données

Solr fournit une API REST de type que vous pouvez facilement utiliser à partir de n’importe quelle application. Mieux encore, il existe une bibliothèque nommée SolrNet (bit.ly/2XwkROA) qui fournit une abstraction sur Solr, ce qui vous permet de travailler facilement avec des objets fortement typés, avec de nombreuses fonctionnalités pour rendre le développement d’applications de recherche plus rapidement.

Le moyen le plus simple d’obtenir SolrNet consiste à installer le package SolrNet à partir de NuGet. Je vais inclure la bibliothèque dans la nouvelle Application de Console que j’ai créé à l’aide de Visual Studio 2017. Vous pourrez également que vous souhaitez télécharger des packages supplémentaires, telles que SolrCloud, qui sont requis pour l’utilisation d’autres mécanismes de contrôle d’inversion et de fonctionnalités supplémentaires.

Dans mon application de console, j’ai besoin de modéliser les données dans mon index. C’est assez simple : Je crée simplement un nouveau fichier de classe appelé Post.cs, comme indiqué dans Figure 3.

Modèle de Document figure 3 Post

class Post
{
  [SolrUniqueKey(“id”)]
  public string Id { get; set; }
  [SolrField(“postTypeId”)]
  public int PostTypeId { get; set; }
  [SolrField(“title”)]
  public string Title { get; set; }
  [SolrField(“body”)]
  public string Body { get; set; }
  [SolrField(“tags”)]
  public ICollection<string> Tags { get; set; } = new List<string>();
  [SolrField(“postScore”)]
  public float PostScore { get; set; }
  [SolrField(“ownerUserId”)]
  public int? OwnerUserId { get; set; }
  [SolrField(“answerCount”)]
  public int? AnswerCount { get; set; }
  [SolrField(“commentCount”)]
  public int CommentCount { get; set; }
  [SolrField(“favoriteCount”)]
  public int? FavoriteCount { get; set; }
  [SolrField(“viewCount”)]
  public int? ViewCount { get; set; }
  [SolrField(“creationDate”)]
  public DateTime CreationDate { get; set; }
  [SolrField(“lastActivityDate”)]
  public DateTime LastActivityDate { get; set; }
  [SolrField(“closedDate”)]
  public DateTime? ClosedDate { get; set; }
}

Cela n’est rien de plus qu’un simple ancien objet CLR (POCO) qui représente chaque document dans mon index, mais avec un attribut qui indique à SolrNet à un champ chaque propriété est mappée.

Création d’une Application de recherche

Lorsque vous créez une application de recherche, vous créez généralement deux fonctionnalités distinctes :

L’indexeur : Il s’agit de l’application que je dois créer tout d’abord. Tout simplement, pour que les données à rechercher, j’ai besoin que les données de flux vers Solr. Cela peut impliquer la lecture des données provenant de plusieurs sources, la conversion à partir de différents formats et bien plus encore, jusqu'à ce qu’il est maintenant prête pour la recherche.

L’application de recherche : Une fois que j’ai des données dans mon index, je peux commencer à travailler sur l’application de recherche.

Avec les deux, la première étape nécessite l’initialisation SolrNet, vous pouvez le faire à l’aide de la ligne suivante dans l’application console (Assurez-vous que Solr est en cours d’exécution !) :

Startup.Init<Post>(“http://localhost:8983/solr/msdnarticledemo”);

Je vais créer une classe pour chaque fonctionnalité dans mon application.

Création de l’indexeur

Pour indexer les documents, je commence par obtenir l’instance de service SolrNet, qui me permet de démarrer toutes les opérations prises en charge :

var solr = ServiceLocator.Current.GetInstance<ISolrOperations<Post>>();

Ensuite, j’ai besoin de lire le contenu de Posts.xml dans un objet XMLDocument, ce qui implique une itération sur chaque nœud, créant un nouvel objet de Post, extraction de chaque attribut de XMLNode et l’affecter à la propriété correspondante.

Notez que, dans le champ de données de récupération d’informations, ou la recherche, est stockée dénormalisées. En revanche, lorsque vous travaillez avec des bases de données, vous normalisez généralement des données pour éviter la duplication. Au lieu d’ajouter le nom du propriétaire à un billet, vous ajoutez un Id d’entier et créez une table séparée pour correspondre à l’Id pour un nom. Dans la recherche, toutefois, vous ajoutez le nom dans le cadre de la publication, duplication des données. Pour quelle raison ? Étant donné que lorsque les données sont normalisées, vous avez besoin effectuer des jointures pour la récupération, qui sont assez onéreux. Mais l’un des principaux objectifs d’un moteur de recherche est la vitesse. Les utilisateurs s’attendent à un bouton et obtenir les résultats qu’ils souhaitent immédiatement.

Revenons maintenant à la création de l’objet de publication. Dans Figure 4, je vais montrer uniquement trois champs que l’ajout d’autres est très simple. Notez comment les balises est à valeurs multiples et que je vérifie les valeurs null éviter les exceptions.  

Figure 4 les champs durant le remplissage

Post post = new Post();
post.Id = node.Attributes[“Id”].Value;
if (node.Attributes[“Title”] != null)
{
  post.Title = node.Attributes[“Title”].Value;
}
if (node.Attributes[“Tags”] != null){
  post.Tags = node.Attributes[“Tags”].Value.Split(new char[] { ‘<’, ‘>’ })
    .Where(t => !string.IsNullOrEmpty(t)).ToList();}
// Add all other fields

Une fois que j’ai rempli l’objet, je peux ajouter chaque instance à l’aide de la méthode Add :

solr.Add(post);

Ou bien, je peux créer une collection de billets et ajouter des publications par lots à l’aide de AddRange :

solr.AddRange(post_list);

Chacune de ces approches convient, mais il a été observé dans de nombreux déploiements de production l’ajout de documents par lots de 100 tend à améliorer les performances. Notez que l’ajout d’un document ne soit pas disponible pour la recherche. J’ai besoin de valider :

solr.Commit();

Maintenant je vais exécuter et, selon la quantité de données en cours d’indexation et l’ordinateur sur lequel il est en cours d’exécution, il peut prendre de quelques secondes à quelques minutes.

Une fois le processus terminé, je peux accéder à l’interface utilisateur administrateur de Solr, recherchez une liste déroulante au milieu gauche qui indique que le sélecteur de base et choisir mon core (msdnarticledemo). À partir de l’onglet vue d’ensemble, je peux voir les statistiques, ce qui me dire combien de documents simplement, j’ai indexé.

Dans mon fichier de vidage de données, j’ai dû 25,488 billets, qui correspond à ce que je vois :

Statistics
  Last Modified: less than a minute ago
  Num Docs:25488
  Max Doc:25688

Maintenant que j’ai des données dans mon index, je suis prêt à commencer à travailler sur le côté de la recherche.

Recherche dans Solr

Avant de passer dans Visual Studio, je souhaite démontrer une recherche rapide à partir Admin UI de Solr et expliquent certains des paramètres qui sont disponibles.

Dans le cœur msdnarticledemo, je cliquez sur la requête et appuyez sur le bouton bleu en bas qui indique que d’exécuter la requête. J’obtiens en retour tous mes documents au format JSON, comme indiqué dans Figure 5.

Requête figure 5 dans Solr via l’interface utilisateur administrateur

Par conséquent, ce qui exactement effectuées et pourquoi ai-je reçu dans tous les documents dans l’index ? La réponse est simple. Examinons les paramètres, la colonne avec le Gestionnaire de requêtes (qt) en haut. Comme vous pouvez le voir, un seul paramètre est étiqueté q, et il a la valeur * : *.  C’est ce que montées tous les documents. En fait, la requête que j’ai exécuté était pour rechercher tous les champs pour toutes les valeurs, à l’aide d’une paire clé-valeur. Si au lieu de cela, je souhaitais seulement Rechercher Solr dans le titre, la valeur q serait titre : Solr. 

Cela est très utile pour créer des requêtes plus complexes qui fournissent différents poids pour chaque champ, ce qui est logique. Un mot ou une expression qui se trouve dans un titre est plus importante que l’autre dans le contenu. Par exemple, si un document a Enterprise Search dans le titre, il est très probable que la totalité du document doit être sur la recherche d’entreprise. Mais si je trouve cette expression dans n’importe quelle partie du corps d’un document, il peut être simplement une référence à un élément lié à peine.

Le paramètre q est probablement le plus important, car elle récupère les documents par ordre de pertinence en calculant un score. Mais un certain nombre d’autres paramètres que vous pouvez utiliser via le Gestionnaire de demandes pour configurer la façon dont les demandes sont traitées par Solr, avec la requête de filtre (fq), tri, la liste de champs (Floride) et de nombreux plus que vous trouverez dans la documentation de Solr sur bit.ly/2GVmYGl. Avec ces paramètres vous pouvez commencer à créer des requêtes plus complexes. Prend un certain temps à maîtriser, mais plus vous découvrez, le classement de pertinence mieux que vous obtiendrez.

N’oubliez pas que le Admin UI n’est pas une application fonctionne avec Solr. Pour ce faire, l’interface de type REST est utilisée. Si vous regardez juste au-dessus des résultats, il existe un lien dans une zone grise qui contient l’appel pour cette requête spécifique. Cliquant sur celle-ci ouvre une nouvelle fenêtre, qui conserve la réponse.

Il s’agit de ma requête :

http://localhost:8983/solr/msdnarticledemo/select?q=*%3A*&wt=json

SolrNet effectue des appels à ceci sous le capot, mais il présente les objets que je peux utiliser à partir de mon application .NET. Maintenant, je vais créer une application de recherche de base.

Génération de l’Application de recherche

Dans ce cas particulier, je vais rechercher les questions dans mon jeu de données, dans tous les champs. Étant donné que les données contiennent des questions et réponses, je vais filtrer par le PostTypeId, avec « 1 », ce qui signifie que c’est une question.  Pour ce faire, j’utilise une requête de filtre, le paramètre fq.

En outre, j’ai définirez certaines options de requête pour retourner une page de résultats à la fois, à savoir les lignes, pour indiquer le nombre de résultats et StartOrCursor, pour spécifier le décalage (démarrage). Et, bien sûr, je définis la requête.

Figure 6 montre le code requis pour exécuter une recherche de base, avec la requête en cours le texte pour lequel je recherche.

Figure 6 une recherche de base en cours d’exécution

QueryOptions query_options = new QueryOptions
{
  Rows = 10,
  StartOrCursor = new StartOrCursor.Start(0),
  FilterQueries = new ISolrQuery[] {
    new SolrQueryByField(“postTypeId”, “1”),
    }
};
// Construct the query
SolrQuery query = new SolrQuery(keywords);
// Run a basic keyword search, filtering for questions only
var posts = solr.Query(query, query_options);

Après avoir exécuté la requête, j’obtiens des billets, qui est un objet SolrQueryResults. Elle contient une collection de résultats, ainsi que de nombreuses propriétés avec plusieurs objets qui fournissent des fonctionnalités supplémentaires. Maintenant que j’ai ces résultats, je peux les afficher à l’utilisateur.

Affiner les résultats

Dans de nombreux cas, les résultats d’origine peuvent être bénéfique, mais l’utilisateur peut souhaiter limiter par un champ de métadonnées particulier. Il est possible d’approfondir par un champ à l’aide de facettes. Dans une facette, j’obtiens une liste de paires clé / valeur. Par exemple, avec des balises obtenir chaque balise et combien de fois que chacun d’eux se produit. Facettes sont couramment utilisés avec les champs de date, numérique ou de chaîne. Champs de texte sont plus complexes.

Pour activer les facettes, je dois ajouter une nouveau QueryOption, facette :  

Facet = new FacetParameters
{
  Queries = new[] {
    new SolrFacetFieldQuery(“tags”)
  }
}

Maintenant je peux également récupérer mes facettes à partir de publications. FacetFields [« tags »], qui est une collection de paires clé-valeur qui contiennent chaque balise particulière, et combien de fois chaque balise se produit dans le jeu de résultats.

Puis j’ai puis-je autoriser l’utilisateur à sélectionner les balises à Explorer, en réduisant le nombre de résultats avec une requête de filtre, de retour dans l’idéal, les documents pertinents. 

Amélioration de votre recherche : quelle est la suite ?

Jusqu’ici, j’ai abordé les éléments essentiels de l’implémentation de recherche de base dans C# avec Solr et SolrNet à poser des questions à partir d’un des sites StackExchange. Toutefois, cela est que le début d’un nouveau parcours où je peux approfondir l’art de retourner des résultats pertinents, l’utilisation de Solr.

Les étapes suivantes quelques-unes des recherche par des champs individuels avec des poids différents ; fournir la mise en évidence dans les résultats à afficher correspond à du contenu ; application des synonymes pour retourner des résultats qui sont liées, mais ne peuvent pas contenir les termes exacts qui ont été recherchés ; recherche de radical, qui est ce qui réduit les mots à leur base d’augmenter le rappel ; Recherche phonétique, ce qui permet aux utilisateurs internationaux ; et bien plus encore.

En résumé, pour apprendre à implémenter la recherche est une compétence utile qui peut potentiellement générer précieuses retourne dans votre avenir en tant que développeur.

Pour accompagner cet article, j’ai créé un projet de recherche de base, comme indiqué dans Figure 7, que vous pouvez télécharger pour en savoir plus sur la recherche d’entreprise. Bonne recherche !

Figure 7 exemple de projet de recherche

Xavier Morerapermet aux développeurs de comprendre les Big Data et recherche d’entreprise. Il crée des cours sur Pluralsight et parfois à Cloudera. Il a travaillé pendant de nombreuses années en Technologies de recherche (fait désormais partie intégrante d’Accenture), traitement des implémentations de recherche. Il vit au Costa Rica, et vous trouverez à l’adresse xaviermorera.com.

Merci aux experts techniques suivants d'avoir relu cet article : Jose Arias (Accenture), Jonathan Gonzalez (Accenture)
Jose Arias est passionné de la recherche et de technologies big liées aux données, notamment celles utilisées dans l’analyse de données.  Il est développeur senior chez Accenture recherche & contenu Analytique. https://www.linkedin.com/in/joseariasq/
Jonathan Gonzalez <(j.gonzalez.vindas@accenture.com)>
Jonathan Gonzalez est architecte de la gestion de Senior pour Accenture, avec plus de 18 ans d’expérience dans le développement de logiciels et la conception, la dernière 13 spécialisé dans la récupération d’informations, recherche d’entreprise, traitement des données et contenu analytique. https://www.linkedin.com/in/jonathan-gonzalez-vindas-ba3b1543/