GroupDocs.Search per .NET 26.11 è ora disponibile. Questa versione rende le ricerche ripetute e simultanee molto più veloci, riduce la memoria allocata dall’indicizzazione fino a 4.5 volte e assicura la rete di ricerca con l’autenticazione dei nodi. L’indicizzazione in una rete di ricerca è da 5 a 20 volte più veloce, e il pacchetto GroupDocs.Search NuGet ora include build per .NET Framework 4.8, .NET 6.0, .NET 8.0 e .NET 10.0.

Gli indici creati dalla versione 26.10 si aprono senza conversione. La versione contiene 18 modifiche: 5 nuove funzionalità, 12 miglioramenti e 1 correzione.

Evidenze di prestazioni

Le note complete di rilascio descrivono l’ambiente di test di ogni figura.

Cosa Guadagno in 26.11
Ricerca ripetuta di espressioni regolari Fino a 300 volte più veloce
Ricerca fuzzy ripetuta Da 4 a 30 volte più veloce
Ricerche simultanee di un indice Tempo medio di 8 ricerche simultanee da 5.6 ms a 0.18 ms; dal 4 al 18% più ricerche al secondo
Ricerca fuzzy con un errore 1.8 volte più veloce, 4.5 volte più veloce con 8 thread di ricerca
Ricerca per intervallo di date Fino a 10 volte più veloce, fino a 59 volte più veloce a blocchi; gli intervalli lunghi restituiscono risultati completi
Memoria allocata dall’indicizzazione Fino a 4.5 volte meno
Indicizzazione con testo del documento memorizzato Fino a 2.2 volte più veloce
Recupero del testo del documento memorizzato 3.5 volte più veloce, 11 volte meno memoria
Unione di indici 3.5 volte più veloce, quasi 50 volte meno memoria
Indicizzazione in una rete di ricerca Da 5 a 20 volte più veloce, molto meno segmenti di indice negli shard
Registrazione di 20.000 documenti sul nodo master Da 27.1 s a 0.12 s, 0.8 MB scritti su disco invece di 7.6 GB
Spazio su disco di un indice Può essere ridotto a costo della velocità di caricamento

Novità di questa versione

Chiave Riepilogo Categoria
SEARCHNET-3729 Implementare un’opzione per ridurre lo spazio su disco occupato da un indice a costo della velocità di caricamento Funzionalità
SEARCHNET-3730 Implementare l’autenticazione dei nodi della rete di ricerca Funzionalità
SEARCHNET-3731 Implementare il supporto OCR per l’estrazione dei documenti in un processo separato Funzionalità
SEARCHNET-3732 Implementare la ricerca a blocchi in un repository di indici Funzionalità
SEARCHNET-3733 Implementare l’evidenziazione delle parole prodotte da uno splitter di parole personalizzato Funzionalità
SEARCHNET-3734 Ottimizzare la ricerca a blocchi Miglioramento
SEARCHNET-3735 Implementare un pool di thread condiviso per ricerche concorrenti di un indice Miglioramento
SEARCHNET-3736 Implementare il riutilizzo delle parole corrispondenti nelle ricerche ripetute Miglioramento
SEARCHNET-3737 Implementare l’interfaccia IDisposable nella classe Cancellation Miglioramento
SEARCHNET-3738 Estendere l’alfabeto predefinito con script aggiuntivi Miglioramento
SEARCHNET-3739 Accelerare la ricerca per intervallo di date e garantire risultati completi per intervalli di date lunghi Miglioramento
SEARCHNET-3740 Ridurre il consumo di memoria dell’indicizzazione e delle operazioni con testi di documenti memorizzati Miglioramento
SEARCHNET-3741 Accelerare l’indicizzazione in una rete di ricerca con un gran numero di documenti Miglioramento
SEARCHNET-3742 Implementare l’indicizzazione batch e l’elaborazione parallela delle richieste di shard in una rete di ricerca Miglioramento
SEARCHNET-3743 Implementare il pattern di dispose nelle classi Index, IndexRepository, Cancellation, ExtractionHost e SearchNetworkNode Miglioramento
SEARCHNET-3693 Implementare la strategia di packaging TFM-Split per il pacchetto GroupDocs.Search NuGet Miglioramento
SEARCHNET-3747 Implementare pacchetti NuGet per .NET Framework 4.8, .NET 6.0, .NET 8.0, .NET 10.0 Miglioramento
SEARCHNET-3746 Risolto l’attesa indefinita di una rete di ricerca per nodi persi o non responsivi Correzione

Funzionalità principali

Ricerca

  • Le ricerche ripetute con wildcard, espressioni regolari, intervalli numerici e fuzzy riutilizzano le parole trovate dalle ricerche precedenti con la stessa query finché l’indice non cambia. Le parole conservate occupano fino a 8 MB di memoria per indice.
  • Le ricerche simultanee di un indice condividono i suoi thread di ricerca (IndexSettings.SearchThreads), così le ricerche brevi non attendono più quelle lunghe.
  • La ricerca per intervallo di date legge ogni giorno, mese e anno dall’indice una sola volta invece di cercare ogni data dell’intervallo separatamente. Gli intervalli lunghi non vengono più interrotti al limite di occorrenze, e un intervallo di tutte le date possibili, che prima falliva, ora viene cercato in pochi secondi.
  • La ricerca a blocchi ottiene tutti questi vantaggi, e un repository di indici può ora essere cercato a blocchi: IndexRepository.SearchNext continua la ricerca indice per indice.
  • L’evidenziazione e Index.GetDocumentText possono dividere il testo con lo splitter di parole personalizzato usato per l’indicizzazione, così le parole che lo splitter produce, ad esempio parole di un testo senza spazi, vengono evidenziate.
  • L’alfabeto predefinito dei nuovi indici include lettere e segni diacritici ebraici, Devanagari, georgiani, latino esteso, greco e Hangul. Parole come “Việt” non vengono più suddivise in parti, e le parole coreane ed ebraiche sono indicizzate e trovate intere.

Indicizzazione e archiviazione dell’indice

  • La nuova impostazione IndexSettings.UseFastLoading consente a un indice su disco di eliminare i dati aggiuntivi che rendono il suo caricamento più veloce di più volte: l’indice occupa meno spazio su disco ma si carica più lentamente. L’impostazione può essere modificata in qualsiasi momento, anche per un indice che contiene già documenti.
  • L’indicizzazione allocca fino a 4.5 volte meno memoria per documento e, con il testo del documento memorizzato, è fino a 2.2 volte più veloce. Il recupero del testo memorizzato è 3.5 volte più veloce con 11 volte meno memoria, e l’unione degli indici è 3.5 volte più veloce con quasi 50 volte meno memoria.
  • Il testo delle immagini nei documenti estratto in un processo separato può ora essere riconosciuto: ExtractionHost.OcrConnector imposta il connettore OCR del processo di estrazione. Se il riconoscimento è abilitato ma il processo di estrazione non ha un connettore OCR, l’indice lo segnala tramite l’evento ErrorOccurred.

Rete di ricerca

  • I nodi si autenticano reciprocamente con una chiave segreta condivisa (TcpSettings.NetworkKey), e ogni messaggio è firmato: un computer senza la chiave non può né dare comandi a un nodo né rispondere per esso. La chiave non viene mai inviata sulla rete. Un nodo slave può anche limitare gli indirizzi da cui accetta il nodo master (TcpSettings.AllowedMasterAddresses).
  • L’indicizzazione è da 5 a 20 volte più veloce e crea molti meno segmenti di indice: i documenti che arrivano mentre uno shard è occupato vengono indicizzati in batch fino a 1.000 documenti o 16 MB, e gli shard di un nodo elaborano le loro richieste in parallelo.
  • La registrazione dei documenti indicizzati sul nodo master non rallenta più con l’aumento del loro numero, e l’elenco dei documenti di uno shard viene conservato in modo sicuro quando una scrittura fallisce o il processo si arresta.
  • Il nodo master rileva i nodi persi e non responsivi: un nodo slave segnala ogni 5 secondi, e le chiamate non attendono più indefinitamente un nodo che è scomparso. TcpSettings.ResponseTimeout può anche limitare il tempo di attesa del nodo master per una risposta.

API e packaging

  • Index, IndexRepository, Cancellation, ExtractionHost e SearchNetworkNode implementano il pattern di dispose standard .NET, così le classi derivate possono rilasciare le proprie risorse. Disporre un Cancellation rilascia il timer di una cancellazione programmata da CancelAfter.
  • Il pacchetto GroupDocs.Search NuGet ora include build per .NET Framework 4.8, .NET 6.0, .NET 8.0 e .NET 10.0 oltre a .NET Framework 4.6.2 e .NET Standard 2.1, e seleziona automaticamente la build per il framework di destinazione di un progetto.

Modifiche all’API pubblica

I seguenti membri sono stati aggiunti:

  • GroupDocs.Search.IndexSettings:

    • Boolean UseFastLoading – mantiene i dati aggiuntivi che rendono il caricamento di un indice su disco più veloce di più volte. Abilitato per impostazione predefinita; impostalo a false per risparmiare spazio su disco.
  • GroupDocs.Search.Scaling.Configuring.TcpSettings:

    • String NetworkKey – la chiave segreta della rete di ricerca, lunga almeno 16 caratteri e identica su tutti i nodi.
    • String[] AllowedMasterAddresses – indirizzi IPv4 o nomi host da cui un nodo slave accetta la connessione del nodo master.
    • Int32 ResponseTimeout – il tempo in millisecondi che il nodo master attende per la risposta di un nodo a una richiesta. Nessun limite per impostazione predefinita.
  • GroupDocs.Search.ExtractionHost:

    • IOcrConnector OcrConnector – il connettore OCR del processo di estrazione separato.
  • GroupDocs.Search.IndexRepository:

    • SearchResult SearchNext(ChunkSearchToken) e SearchResult SearchNext(ChunkSearchToken, Cancellation) – continuano una ricerca a blocchi in un repository di indici.
  • GroupDocs.Search.Options.TextOptions:

    • IWordSplitter WordSplitter – lo splitter di parole usato per l’evidenziazione e Index.GetDocumentText; ereditato da HighlightOptions.
  • GroupDocs.Search.Common.Cancellation ora implementa IDisposable:

    • void Dispose() – rilascia il timer di una cancellazione programmata; la cancellazione programmata non è richiesta.
  • Index, IndexRepository, Cancellation, ExtractionHost e SearchNetworkNode:

    • protected virtual void Dispose(Boolean disposing) – il metodo del pattern di dispose per le classi derivate.

I cambiamenti di comportamento che potrebbero richiedere modifiche al tuo codice sono elencati nelle note di aggiornamento qui sotto.

Esempi di codice

Ricerca di un repository di indici a blocchi

Il seguente esempio ricerca due indici di un repository a blocchi, un indice dopo l’altro.

string indexFolder1 = @"c:\MyIndex1\"; // Specify the path to the first index folder
string indexFolder2 = @"c:\MyIndex2\"; // Specify the path to the second index folder
string documentsFolder1 = @"c:\MyDocuments1\"; // Specify the path to a folder containing documents to index
string documentsFolder2 = @"c:\MyDocuments2\"; // Specify the path to another folder containing documents to index

using (IndexRepository repository = new IndexRepository()) // Creating an index repository
{
    Index index1 = repository.Create(indexFolder1); // Creating the first index in the repository
    index1.Add(documentsFolder1); // Indexing documents from the first folder
    Index index2 = repository.Create(indexFolder2); // Creating the second index in the repository
    index2.Add(documentsFolder2); // Indexing documents from the second folder

    SearchOptions options = new SearchOptions();
    options.IsChunkSearch = true; // Enabling search by chunks

    SearchResult result = repository.Search("Einstein", options); // Getting the first chunk of the first index
    Console.WriteLine("Documents: " + result.DocumentCount);
    while (result.NextChunkSearchToken != null)
    {
        result = repository.SearchNext(result.NextChunkSearchToken); // Getting the next chunk, index by index
        Console.WriteLine("Documents: " + result.DocumentCount);
    }
}

Proteggere una rete di ricerca con una chiave condivisa

Ogni nodo di una rete di ricerca ottiene la stessa chiave segreta. Un nodo slave accetta il nodo master solo dal suo indirizzo, e il nodo master limita l’attesa per le risposte dei nodi.

string basePath = @"c:\SearchNetwork\"; // Specify the path to the folder of the search network
string networkKey = Environment.GetEnvironmentVariable("SEARCH_NETWORK_KEY"); // The same key of at least 16 characters on every node

// On the server of slave node 1: the connection of the master node is accepted from 10.0.0.5 only
TcpSettings slaveSettings = new TcpSettings(49101, 10000, 10000, 10000, 1000);
slaveSettings.NetworkKey = networkKey;
slaveSettings.AllowedMasterAddresses = new string[] { "10.0.0.5" };
SearchNetworkNode node1 = SearchNetworkNode.CreateSlaveNode(1, basePath + "Node1", slaveSettings);
node1.Start();

// On the server of the master node (10.0.0.5): the responses of the nodes are awaited no longer than 10 minutes
Configuration configuration = Configuration.Load(basePath + "Configuration.xml"); // Loading the search network configuration
TcpSettings masterSettings = new TcpSettings(49100, 10000, 10000, 10000, 1000);
masterSettings.NetworkKey = networkKey;
masterSettings.ResponseTimeout = 600000;
SearchNetworkNode node0 = SearchNetworkNode.CreateMasterNode(
    0, basePath + "Node0", masterSettings, new FileLogger(basePath + "Log.txt", 4.0), configuration);
node0.ConfigureAllNodes();
node0.Start();

Ridurre lo spazio su disco di un indice

Il seguente esempio crea un indice che occupa meno spazio su disco, e poi lo rende di nuovo veloce da caricare.

string indexFolder = @"c:\MyIndex\"; // Specify the path to the index folder
string documentsFolder = @"c:\MyDocuments\"; // Specify the path to a folder containing documents to index

IndexSettings settings = new IndexSettings();
settings.UseFastLoading = false; // The index takes less disk space but loads longer
using (Index index = new Index(indexFolder, settings, true)) // Creating an index with the settings
{
    index.Add(documentsFolder); // Indexing documents from the specified folder
}

using (Index index = new Index(indexFolder)) // Opening the existing index
{
    index.IndexSettings.UseFastLoading = true; // The data is created the next time the index is loaded
}

Note di aggiornamento

Considera i seguenti cambiamenti quando aggiorni da una versione precedente:

  • Gli indici modificati dalla versione 26.11 non possono essere aperti da versioni precedenti. La versione 26.11 apre gli indici della versione 26.10 senza conversione, ma una volta che crea o modifica un indice (tramite indicizzazione, eliminazione di documenti, ottimizzazione o modifica delle impostazioni), le versioni precedenti non possono più aprirlo. Aggiorna tutte le applicazioni che condividono una cartella di indici contemporaneamente, inclusi i nodi di una rete di ricerca.
  • I progetti .NET Framework usano il pacchetto GroupDocs.Search. Sostituisci GroupDocs.Search.NETFramework con GroupDocs.Search, che ora include le build .NET Framework 4.6.2 e 4.8 e seleziona automaticamente la build corretta. Non esiste la versione 26.11 di GroupDocs.Search.NETFramework.
  • Tutti i nodi di una rete di ricerca vengono aggiornati insieme. I nodi delle versioni 26.10 e 26.11 non si connettono. Per proteggere la rete, imposta la stessa TcpSettings.NetworkKey su ogni nodo: i nodi con chiavi diverse, o un nodo con chiave e un nodo senza, non si connettono, e entrambi scrivono il motivo nei loro log. Un nodo senza chiave funziona come prima e scrive un avviso nel suo log.
  • I messaggi di una rete di ricerca sono firmati ma non crittografati. Mantieni i nodi in una rete fidata o connettili tramite un tunnel crittografato.
  • I nodi persi vengono rilevati. Un nodo che non invia nulla per 15 secondi, ad esempio un processo in pausa in un debugger, è trattato come perso: le chiamate che lo attendono lanciano SearchException, e i suoi documenti vengono inviati ad altri nodi o segnalati dall’evento ErrorOccurred. Per impostazione predefinita il nodo master attende le risposte senza limite; imposta TcpSettings.ResponseTimeout per limitare l’attesa.
  • IndexSettings.SearchThreads è condiviso da tutte le ricerche di un indice. Una ricerca utilizza tanti thread quanto prima, ma K ricerche simultanee ora girano su max(K, SearchThreads) thread invece di K × SearchThreads.
  • Solo i nuovi indici ottengono l’alfabeto esteso. Gli indici delle versioni precedenti, inclusi quelli aggiornati da IndexUpdater, suddividono le parole di questi script come prima, e Index.Merge rifiuta di unire un indice nuovo con uno più vecchio. Per unirli, esporta l’Alphabet e il TokenizationDictionary dell’indice più vecchio con ExportDictionary e importali nel nuovo indice con Clear e ImportDictionary prima di aggiungere i documenti.
  • I limiti di occorrenza contano le parti delle date una sola volta. SearchOptions.MaxTotalOccurrenceCount e MaxOccurrenceCountPerTerm contano ogni occorrenza di un giorno, mese o anno una sola volta per ricerca, o una volta per blocco, invece di una volta per ogni data dell’intervallo. Un intervallo di date che prima raggiungeva un limite ora può trovare tutte le sue date.
  • La ricerca a blocchi in un repository di indici avviene indice per indice. IndexRepository.Search con IsChunkSearch restituisce il primo blocco del primo indice. Continua con IndexRepository.SearchNext finché SearchResult.NextChunkSearchToken non è nullo, o ricerca senza blocchi per ottenere tutti i documenti in un unico risultato.
  • L’OCR in un processo di estrazione separato utilizza ExtractionHost.OcrConnector. Imposta il connettore nel programma del processo di estrazione e compila quel programma con la stessa versione di GroupDocs.Search dell’applicazione. Il connettore OCR delle opzioni di indicizzazione non è usato lì.
  • Il progresso dell’indicizzazione di rete è segnalato per risposta di shard. NodeEventHub.IndexingProgressChanged si verifica una volta per ogni risposta di uno shard, che può segnalare diversi documenti, quindi ProcessedDocuments può aumentare di più di uno.

Come ottenere l’aggiornamento

NuGet

  • NuGet – Installa l’ultimo pacchetto. Funziona nei progetti .NET e .NET Framework e seleziona automaticamente la build per il framework di destinazione: .NET Framework 4.6.2 o 4.8, .NET Standard 2.1, .NET 6.0, .NET 8.0 o .NET 10.0.
# Package Manager
NuGet\Install-Package GroupDocs.Search -Version 26.11.0

# .NET CLI
dotnet add package GroupDocs.Search --version 26.11.0

Download diretto

Risorse