---

Aprile 2019

Volume 34 Numero 4

[.NET]

Implementazione della ricerca aziendale personalizzata

Dal Morera a a

Ricerca probabilmente danno per scontate. È utilizzato quotidianamente per eseguire tutti i tipi di attività, da una chat room per la corsa successivo, per l'individuazione delle informazioni che necessarie per il processo di individuazione. Una ricerca implementata correttamente consentono di risparmiare denaro, o guadagnare. E anche in un'applicazione eccezionale, una ricerca non valida verrà comunque creato un'esperienza insoddisfacente

Il problema è che nonostante l'importanza, ricerca è una delle funzionalità più frainteso in IT, notato solo quando mancante o danneggiato. Ricerca e non necessariamente essere una funzionalità poco chiaro che è difficile da implementare. In questo articolo intende spiegano come sviluppare un'API di ricerca enterprise nel C#.

Per altre informazioni su ricerca, è necessario un motore di ricerca. Sono disponibili molte opzioni, da open source a scopo di lucro e qualsiasi combinazione intermedia, molti dei quali sfruttare internamente Lucene, ovvero la libreria di recupero delle informazioni di scelta. Sono inclusi ricerca di Azure, ElasticSearch e Solr. Utilizzare oggi Solr. Perché? È stata intorno a lungo, ha documentazione utile, una vivace community, molti utenti rilevanti e ho utilizzato personale, per implementare la ricerca in molte applicazioni, dai siti di piccole dimensioni per le aziende di grandi dimensioni.

Recupero di Solr

Installazione di un motore di ricerca può sembrare un'attività complessa e, in effetti, se si sta configurando un'istanza di Solr produzione che deve supportare un numero elevato di query al secondo (QPS), quindi Sì, che può diventare complicato. (Valore QPS è una metrica comune usata per fare riferimento al carico di lavoro di ricerca).

Questi passaggi sono illustrati in dettaglio nella sezione "Installazione di Solr" della documentazione di Solr (lucene.apache.org/solr), come anche come "L'istanza di Solr Well-Configured" sezione "Apache Solr Reference Guide" (bit.ly/2IK7mqY). Ma ho bisogno solo di un'istanza di Solr, sviluppo, in modo passare semplicemente alla bit.ly/2tEXqoo e ottenere una versione binaria; solr 7.7.0.zip funzionerà.

Scaricare il file con estensione zip, decomprimere, aprire il prompt dei comandi e passare alla directory radice della cartella in cui è stato decompresso il file. Quindi eseguire il comando seguente:

> bin\solr.cmd start

Niente altro. Devo solo passare a http://localhost:8983, in cui viene accolti da Solr Admin UI, illustrato nella figura 1.

Esecuzione e il motore di ricerca figura 1 backup

Recupero dei dati

Successivamente, ho bisogno di dati. Sono disponibili una vasta gamma di set di dati con dati interessanti, ma ogni giorno migliaia di sviluppatori finire in StackOverflow perché sono ancora non si ricorda come scrivere in un file. è possibile uscire VIM; oppure è necessario un C# frammento di codice che risolve un problema specifico. La buona notizia è che i dati di StackOverflow sono disponibili come un dump XML che contiene il badge di domande e risposte, tag, circa 10 milioni, le informazioni utente anonimi e molto altro (bit.ly/1GsHll6).

Ancora meglio, è possibile selezionare un set di dati con lo stesso formato da un sito StackExchange più piccolo contenente Pochi domande delle migliaia. Posso testare prima di tutto con il set di dati più piccolo e più potenti in un secondo momento l'infrastruttura per lavorare con più dati.

Inizierò con i dati dal datascience.stackexchange.com, che contiene i post di circa 25 mille. Il file è denominato datascience.stackexchange.com.7z. Scaricarlo ed estrarre Posts.xml.

Alcuni concetti necessari

Disporre di un motore di ricerca e i dati, pertanto è opportuno rivedere alcuni dei concetti importanti. Se si è abituati a lavorare con i database relazionali, probabilmente sarà familiare.

L'indice è in cui un motore di ricerca archivia tutti i dati raccolti per la ricerca. A livello generale, Solr archivia i dati in ciò che viene definito un indice invertito. In un indice inverso, parole (o token) puntano a documenti specifici. Quando esegue una ricerca per una determinata parola, che è una query. Se viene trovata la parola (un riscontro o una corrispondenza), l'indice indicherà documenti che contengono tale parola e dove.

Lo schema è come si specifica la struttura dei dati. Ogni record viene chiamato un documento, e come si definirebbe le colonne di un database, specificare i campi di un documento in un motore di ricerca.

Lo schema è costruire modificando un file XML denominato schema. XML, che definisce i campi con i relativi tipi. Tuttavia, è possibile utilizzare anche campi dinamici, in cui un nuovo campo viene creato automaticamente quando si aggiunge un campo sconosciuto. Ciò può essere utile per quando non si è assolutamente certi di tutti i campi presenti nei dati.

Sono già verificati per l'utente che Solr è abbastanza simile a un archivio di documenti NoSQL, come può contenere documenti con i campi che possono essere denormalizzati e non necessariamente coerente attraverso la raccolta di documenti.

La modalità senza schema è un altro modo per modellare i dati all'interno dell'indice. In questo caso, non indicare in modo esplicito Solr campi a cui sarà da indicizzare. In alternativa, sufficiente aggiungere i dati e Solr costruisce uno schema in base al tipo di dati da aggiungere all'indice. Per usare la modalità senza schema, è necessario disporre di uno schema gestito, che significa che non è possibile modificare manualmente i campi. Ciò è particolarmente utile per una fase di esplorazione dei dati o proof-of-concept.

Userà uno schema modificato manualmente, che è l'approccio consigliato per la produzione, perché restituisce un controllo maggiore.

L'indicizzazione è il processo di aggiunta dei dati nell'indice. Durante l'indicizzazione, un'applicazione legge da origini diverse e prepara i dati per l'inserimento. Che corrisponde alla parola utilizzata per l'aggiunta di documenti. si potrebbe anche ascoltare i termini di alimentazione.

Una volta che i documenti vengono indicizzati, è possibile eseguire la ricerca, si spera restituendo i documenti più pertinenti per una specifica ricerca nelle prime posizioni. 

Classificazione per pertinenza è la modalità in cui vengono restituiti i risultati più appropriati nella parte superiore. Questo è un concetto semplice da spiegare. Nella situazione ideale, si esegue una query e il motore di ricerca "legge" idea, restituire esattamente i documenti desiderati.

Precisione e richiamo: Per precisione si intende il numero dei risultati rilevanti (la qualità dei risultati), mentre richiamo significa che il numero del totale restituito i risultati sono rilevanti (quantità o la completezza dei risultati). 

Gli analizzatori, tokenizer e filtri: Quando i dati vengono indicizzati o eseguire la ricerca, un analizzatore esamina il testo e genera un flusso di token. Le trasformazioni vengono quindi applicate tramite i filtri per cercare una corrispondenza query con i dati indicizzati. È necessario comprendere questi se si desidera. é quindi più approfondita della tecnologia del motore di ricerca. Per fortuna, è possibile avviare la creazione di un'applicazione con una panoramica di alto livello.

Informazioni sui dati

È necessario comprendere i dati per l'indice del modello. A tale scopo, aprire Posts.xml e analizzarlo. 

Ecco l'aspetto dei dati. Il nodo post contiene numerosi nodi figlio di riga. Ogni nodo figlio corrispondente a un record, con ogni campo esportata come un attributo in ogni nodo figlio. I dati sono molto puliti per l'inserimento in motore di ricerca, che è consigliabile:

<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>

In modo immediato, rapidamente è possibile osservare come esistono diversi tipi di campi. C'è un identificatore univoco, alcune date, un paio di campi numerici, alcuni campi di testo lunghi e corti alcuni e alcuni campi di metadati. Per brevità, modificato il corpo, che è un campo di testo di grandi dimensioni, ma tutti gli altri utenti si trovano nello stato originale.

Configurazione di Solr, usare uno Schema classico

Esistono diversi modi per specificare la struttura dei dati per l'indice. Per impostazione predefinita, Solr usa uno schema gestito, che significa che usa la modalità senza schema. Ma si vuole creare manualmente lo schema, ovvero ciò che viene definito uno schema classico, dunque è necessario apportare alcune modifiche alla configurazione. In primo luogo, creerà una cartella per contenere la configurazione dell'indice, che verrà denominato msdnarticledemo. La cartella è \server\solr\ si trova in < solr >, dove < solr > è la cartella in cui è stato decompresso Solr.

Successivamente, creare un file di testo nella radice di questa cartella denominata core.properties, che richiede solo il seguente codice aggiunto: nome = msdnarticledemo. Questo file viene usato per creare un core di Solr, ovvero solo un'istanza in esecuzione di un indice di Lucene. Si potrebbe ascoltare la parola insieme troppo, che può avere un significato diverso a seconda del contesto. My ai fini di finalità corrente, un core è l'equivalente di un indice.

È ora necessario copiare il contenuto di un indice parziale di esempio da usare come base. Solr include un elemento in < solr > \server\solr\configsets\_default. Copiare la cartella conf in msdnarticledemo.

Nel passaggio successivo molto importante stabilire Solr che desidero utilizzare uno schema classico. vale a dire che modificherà manualmente lo schema. A tale scopo, aprire solrconfig.xml e aggiungere la riga seguente:

<schemaFactory class=”ClassicIndexSchemaFactory”/>

Inoltre, comunque all'interno di questo file, impostare come commento due nodi, il updateRequestProcessorChain con:

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

Queste due funzionalità sono consentono a Solr aggiungere nuovi campi durante l'indicizzazione dei dati in modalità senza schema. Inoltre, è possibile rimuovere il commento all'interno di questo nodo xml, dato che ":" non è consentita all'interno di commenti in formato xml.

Infine, rinominare schema gestito in schema. Xml. In modo analogo, Solr è pronto per l'uso di uno schema creato manualmente.

Creazione dello Schema

Il passaggio successivo consiste nel definire i campi nello schema, quindi aprire Schema. XML e scorrere verso il basso fino a quando non si trova la definizione dell'id e _text_ _root_.

Si tratta di come viene definito ogni campo, come un nodo xml < campo > che contiene:

• name: Il nome per ogni campo.
• Tipo: Il tipo del campo. è possibile modificare la modalità di gestione da ogni tipo all'interno di schema. Xml.
• indicizzazione: True indica che questo campo può essere usato per la ricerca.
• archiviati: True indica che questo campo può essere restituito per la visualizzazione.
• Obbligatorio: True indica che questo campo deve essere indicizzato, altrimenti viene generato un errore.
• Multivalore: True indica che questo campo può contenere più di un valore.

Può trattarsi di confusione, inizialmente, ma alcuni campi possono essere visualizzati ma non eseguire la ricerca e alcune possono essere cercata, ma potrebbe non essere in grado di essere recuperate dopo l'indicizzazione. Sono disponibili altri attributi avanzati, ma otterranno i relativi dettagli a questo punto.

Figura 2 viene illustrato come definire i campi nello schema per i post. Per i tipi di testo ho diverse, tra cui stringa text_get_sort e text_general. Ricerca di testo è degli obiettivi principali della ricerca, di conseguenza i diversi tipi che supportano testo. Ho anche una data, un integer, float e un campo che contiene più di un valore, i tag.

Figura 2 campi nel file 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” />

Operazioni successive potrà variare a seconda dell'implementazione. Al momento, includono numerosi campi e specificare quella che vuole eseguire la ricerca di accensione e sull'importanza di tale campo è relativo agli altri campi.

Tuttavia, per iniziare, è possibile usare _text_ il campo di catch-all per eseguire una ricerca su tutti i campi. Ho semplicemente creare un copyField e indicare Solr che i dati da tutti i campi devono essere copiati nella mio campo predefinito:

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

A questo punto, quando esegue una ricerca, Solr sarà all'interno di questo campo e restituire qualsiasi documento che corrisponde alla query.

Successivamente, si riavvia Solr per caricare i core e applicare le modifiche, eseguendo questo comando:

> bin\solr.cmd restart

A questo punto sono pronto a iniziare a creare un C# dell'applicazione.                 

Recupero SolrNet e modellazione dei dati

Solr offre un'API REST-like che è possibile usare facilmente da qualsiasi applicazione. Ancora meglio, è una libreria denominata SolrNet (bit.ly/2XwkROA) che fornisce un'astrazione di Solr, consentendo di usare facilmente oggetti fortemente tipizzati, con una vasta gamma di funzionalità per rendere lo sviluppo di applicazioni di ricerca più velocemente.

Il modo più semplice per ottenere SolrNet consiste nell'installare il pacchetto SolrNet da NuGet. La libreria includerò nella nuova applicazione Console è stato creato con Visual Studio 2017. È anche possibile scaricare pacchetti aggiuntivi, ad esempio SolrCloud, necessari per l'uso di altri meccanismi di controllo di inversione e per fornire funzionalità aggiuntive.

All'interno dell'applicazione console, è necessario modellare i dati nell'indice. Ciò è abbastanza semplice: È sufficiente creare un nuovo file di classe denominato Post.cs, come illustrato nella figura 3.

Figura 3 modello di documento 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; }
}

Si tratta nient'altro che un normale precedente CLR object (POCO che rappresenta ogni singolo documento nella mio indice, ma con un attributo che indica a SolrNet a un campo esegue il mapping di ogni proprietà).

Creazione di un'applicazione di ricerca

Quando si crea un'applicazione di ricerca, si crea in genere due funzionalità separate:

L'indicizzatore: Si tratta dell'applicazione che è necessario creare prima di tutto. In parole povere, affinché i dati per la ricerca, è necessario che i dati del feed di Solr. Questa operazione potrebbe comportare la lettura dei dati da più origini, convertirlo da vari formati e così via, fino a quando non è finalmente pronta per la ricerca.

L'applicazione di ricerca: Una volta ottenuto i dati nella mio indice, è possibile iniziare a utilizzare l'applicazione di ricerca.

Con entrambi, è necessario innanzitutto l'inizializzazione SolrNet, ed è possibile farlo usando la riga seguente nell'applicazione console (assicurarsi che sia in esecuzione Solr)!:

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

Creare una classe per ogni funzionalità nell'applicazione.

Creazione dell'indicizzatore

Per indicizzare i documenti, iniziare ottenendo l'istanza del servizio SolrNet che mi consente di avviare le operazioni supportate:

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

Successivamente, è necessario leggere il contenuto di Posts.xml in un XMLDocument, che implica l'iterazione su ogni nodo, creando un nuovo oggetto Post, l'estrazione di ogni attributo da XMLNode e assegnarlo alla proprietà corrispondente.

Si noti che all'interno del campo di dati, il recupero delle informazioni o ricerca, viene archiviato denormalizzato. Al contrario, quando si lavora con i database, in genere normalizzare i dati per evitare la duplicazione. Anziché aggiungere il nome del proprietario per una richiesta post, aggiungere un Id integer e creare una tabella separata in modo da corrispondere l'Id a un nome. Nella ricerca, tuttavia, si aggiungere il nome come parte del post, la duplicazione dei dati. Perché? Perché quando i dati sono stati normalizzati, è necessario eseguire join per il recupero, che sono alquanto costose. Ma uno degli obiettivi principali di un motore di ricerca è velocità. Gli utenti si aspettano di premere un pulsante e ottenere i risultati desiderati immediatamente.

A questo punto eseguire il backup per la creazione dell'oggetto del post. Nelle figura 4, voglio mostrare solo tre campi come l'aggiunta di altri utenti è piuttosto semplice. Si noti come tag sono multivalore e che sta verifica dei valori null evitare eccezioni.  

Figura 4 campi popolamento

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

Una volta ho compilato l'oggetto, è possibile aggiungere ogni istanza utilizzando il metodo Add:

solr.Add(post);

In alternativa, è possibile creare una raccolta di post e aggiungere gli invii in batch utilizzando AddRange:

solr.AddRange(post_list);

Entrambi gli approcci va bene, ma è stato rilevato in molte distribuzioni di produzione che l'aggiunta di documenti in batch di 100 tende a migliorare le prestazioni. Si noti che l'aggiunta di un documento non rendono disponibili per la ricerca. È necessario eseguire il commit:

solr.Commit();

Ora eseguo e, a seconda della quantità di dati in corso l'indicizzazione e la macchina in cui è in esecuzione, potrebbe richiedere da alcuni secondi a qualche minuto.

Una volta completato il processo, posso passare all'interfaccia utente di amministrazione di Solr, cercare un elenco a discesa nella parte centrale sinistra che dice Selector Core e selezionare il core (msdnarticledemo). Nella scheda Panoramica posso visualizzare le statistiche, quali informazioni quanti documenti che appena indicizzato.

Nel mio dump dati avessi 25,488 post, che corrisponde a ciò che viene visualizzato:

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

Ora che ho i dati nella mio indice, sono pronto a iniziare a lavorare sul lato di ricerca.

La ricerca in Solr

Prima di passare nuovamente a Visual Studio, desidero illustrare una ricerca rapida dalla Admin UI di Solr e spiegazione di alcuni dei parametri disponibili.

Nel nucleo della msdnarticledemo verrà fare clic su Query e premere il pulsante blu in basso con la dicitura Esegui Query. Viene visualizzato nuovamente tutti i documenti in formato JSON, come illustrato nella figura 5.

Figura 5 Query in Solr tramite l'interfaccia utente di amministrazione

Quindi, cosa esattamente semplicemente fare, perché viene visualizzato nuovamente tutti i documenti nell'indice? La risposta è semplice. Esaminare i parametri, ovvero la colonna con gestore di richieste (qt) nella parte superiore. Come può notare, un parametro è denominato q e assume un valore di *: *.  Che è ciò che accede tutti i documenti. In effetti, la query che è stato eseguito era per cercare tutti i campi per tutti i valori, utilizzando una coppia chiave-valore. Se invece volessi solo per la ricerca Solr nel titolo, il valore di q sarebbe titolo: Solr. 

Ciò è molto utile per la compilazione di query più complessa che offrono diversi pesi per ogni campo, che è utile. Una parola o una frase che si trova in un titolo è più importante rispetto a uno nel contenuto. Ad esempio, se un documento con servizi di ricerca nel titolo, è molto probabile che l'intero documento sta per essere sui servizi di ricerca. Ma se trova la frase in qualsiasi parte del corpo di un documento, potrebbe essere semplicemente un riferimento a un elemento poco correlate.

Il parametro q è probabilmente quello più importante, poiché recupera i documenti in ordine di pertinenza per calcolare un punteggio. Ma esistono numerosi altri parametri che è possibile usare tramite il gestore di richieste per configurare la modalità di elaborazione delle richieste da Solr, tra cui (fq) query di filtro, ordinamento, elenco di campi (fl) e molte informazioni che è possibile trovare nella documentazione di Solr al bit.ly/2GVmYGl. Con questi parametri è possibile avviare la creazione di query più complesse. Sono necessari alcuni minuti nel ramo principale, ma per apprendere, le classificazioni di rilevanza migliorate ti verrà offerta.

Tenere presente che è Admin UI non come un'applicazione funziona con Solr. A tale scopo, viene usata l'interfaccia REST. Se si osserva immediatamente sopra i risultati, è presente un collegamento in una casella grigia contenente la chiamata per questa particolare query. Facendo clic su di esso, viene aperta una nuova finestra, che contiene la risposta.

Si tratta della query:

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

SolrNet effettua chiamate simile al seguente dietro le quinte, ma sono presenti oggetti che dall'applicazione .NET è possibile usare. Ora creerà un'applicazione di ricerca di base.

Compilazione dell'applicazione di ricerca

In questo caso specifico, devo cercare le domande nel set di dati, tutti i campi. Dato che i dati contengono sia domande e risposte, è possibile filtrare in base PostTypeId, con "1", che significa che è una domanda.  A tale scopo usare una query di filtro, ovvero il parametro fq.

Inoltre, imposterà alcune opzioni di query per restituire una pagina di risultati alla volta, vale a dire le righe, per indicare il numero di risultati e StartOrCursor, specificare l'offset (avvio). E, naturalmente, imposto la query.

Figura 6 Mostra il codice necessario per eseguire una ricerca di base, con query in corso il testo per il quale sto eseguendo una ricerca.

Figura 6 che esegue una ricerca di base

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);

Dopo aver eseguito la query, viene visualizzato post, che è un oggetto SolrQueryResults. Contiene una raccolta di risultati, nonché molte proprietà con più oggetti che forniscono funzionalità aggiuntive. Ora che ho tali risultati, è possibile visualizzare all'utente.

Limitare i risultati

In molti casi, i risultati originali possono essere positivi, ma l'utente desidera restringere in base a un campo di metadati particolare. È possibile eseguire il drill-da un campo con facet. In un facet, ottenere un elenco di coppie chiave-valore. Ad esempio, con i tag viene visualizzato ogni tag e quante volte ciascuno di essi si verifica. I facet vengono comunemente usati con i campi numerici, date o stringa. I campi di testo sono difficili.

Per abilitare i facet, devo aggiungere un nuovo QueryOption, Facet:  

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

Ora è possibile recuperare il facet da post. Si verifica FacetFields ["tags"], che è una raccolta di coppie chiave-valore contenente ogni tag specifico, e quante volte ogni tag nel set di risultati.

Quindi è possibile consentire all'utente di selezionare i tag per approfondire, riducendo il numero di risultati con una query di filtro, in teoria restituire documenti rilevanti. 

Migliorare la ricerca, quali sono le novità?

Finora, ho illustrato i passaggi fondamentali dell'implementazione della ricerca di base in C# con Solr e SolrNet usando le domande da uno dei siti di StackExchange. Tuttavia, questo è solo l'inizio di un nuovo percorso in cui è possibile approfondire l'arte della restituzione di risultati pertinenti usando Solr.

Alcuni dei passaggi successivi includono la ricerca per i singoli campi con i pesi diversi; che fornisce l'evidenziazione in risultati da visualizzare risultati corrispondenti nel contenuto. applicazione di sinonimi per restituire i risultati che sono correlati ma non possono contenere parole esatte che sono state cercate; lo stemming, ossia ciò che riduce le parole di base per aumentare il richiamo; ricerca fonetica, che consente agli utenti internazionali; e altro ancora.

Tutto sommato, imparare a implementare la ricerca è una competenza utile che potenzialmente possa produrre preziose restituisce nel tuo futuro come sviluppatore.

Per seguire questo articolo, ho creato un progetto di ricerca di base, come illustrato nella figura 7, che è possibile scaricare per altre informazioni su servizi di ricerca. La ricerca felici.

Figura 7 esempio cerca progetto

---

Xavier Moreraconsente agli sviluppatori di comprendere ricerca contenuti organizzazione e Big Data. Crea i corsi Pluralsight e a volte a Cloudera. Ha lavorato per molti anni per le tecnologie di ricerca (ora parte di Accenture), trattano le implementazioni di ricerca. Vive a Costa Rica, ed è possibile trovare contattarlo xaviermorera.com.

Si ringraziano i seguenti esperti tecnici per la revisione dell'articolo: Jose Arias (Accenture), Jonathan Gonzalez (Accenture)
Jose Arias è passione per la ricerca e big data tecnologie correlate ai dati, in particolare quelli utilizzati nell'analisi dei dati.  È uno sviluppatore senior presso Accenture ricerca & contenuto Analitica. https://www.linkedin.com/in/joseariasq/
Jonathan Gonzalez <(j.gonzalez.vindas@accenture.com)>
Jonathan Gonzalez è Senior Architect di gestione per Accenture, con oltre 18 anni di esperienza di sviluppo software e progettazione, l'ultimo 13 specializzato in recupero delle informazioni, ricerca contenuti organizzazione, l'elaborazione dati e contenuto analitica. https://www.linkedin.com/in/jonathan-gonzalez-vindas-ba3b1543/