GroupDocs.Search for .NET 26.11 est maintenant disponible. Cette version rend les recherches répétées et simultanées beaucoup plus rapides, réduit la mémoire allouée par l’indexation jusqu’à 4,5 fois et sécurise le réseau de recherche grâce à l’authentification des nœuds. L’indexation dans un réseau de recherche est de 5 à 20 fois plus rapide, et le package NuGet GroupDocs.Search inclut désormais des builds pour .NET Framework 4.8, .NET 6.0, .NET 8.0 et .NET 10.0.

Les index créés par la version 26.10 s’ouvrent sans conversion. La version contient 18 changements : 5 nouvelles fonctionnalités, 12 améliorations et 1 correctif.

Points forts de performance

Les notes de version complètes décrivent la configuration des tests de chaque figure.

Quoi Gain dans la version 26.11
Recherche d’expression régulière répétée Jusqu’à 300 fois plus rapide
Recherche floue répétée De 4 à 30 fois plus rapide
Recherches simultanées d’un index Temps médian de 8 recherches simultanées de 5,6 ms à 0,18 ms ; 4 à 18 % de recherches supplémentaires par seconde
Recherche floue avec une erreur 1,8 fois plus rapide, 4,5 fois plus rapide avec 8 threads de recherche
Recherche par intervalle de dates Jusqu’à 10 fois plus rapide, jusqu’à 59 fois plus rapide par morceaux ; les intervalles longs renvoient des résultats complets
Mémoire allouée par l’indexation Jusqu’à 4,5 fois moins
Indexation avec texte de document stocké Jusqu’à 2,2 fois plus rapide
Récupération du texte de document stocké 3,5 fois plus rapide, 11 fois moins de mémoire
Fusion d’index 3,5 fois plus rapide, presque 50 fois moins de mémoire
Indexation dans un réseau de recherche De 5 à 20 fois plus rapide, beaucoup moins de segments d’index dans les fragments
Enregistrement de 20 000 documents sur le nœud maître De 27,1 s à 0,12 s, 0,8 Mo écrits sur le disque au lieu de 7,6 Go
Espace disque d’un index Peut être réduit au prix d’une vitesse de chargement

Nouveautés de cette version

Clé Résumé Catégorie
SEARCHNET-3729 Implémenter une option pour réduire l’espace disque occupé par un index au prix d’une vitesse de chargement Fonctionnalité
SEARCHNET-3730 Implémenter l’authentification des nœuds du réseau de recherche Fonctionnalité
SEARCHNET-3731 Implémenter la prise en charge de l’OCR pour l’extraction de documents dans un processus séparé Fonctionnalité
SEARCHNET-3732 Implémenter la recherche par morceaux dans un référentiel d’index Fonctionnalité
SEARCHNET-3733 Implémenter la mise en évidence des mots produits par un séparateur de mots personnalisé Fonctionnalité
SEARCHNET-3734 Optimiser la recherche par morceaux Amélioration
SEARCHNET-3735 Implémenter un pool de threads partagé pour les recherches concurrentes d’un index Amélioration
SEARCHNET-3736 Implémenter la réutilisation des mots correspondants dans les recherches répétées Amélioration
SEARCHNET-3737 Implémenter l’interface IDisposable dans la classe Cancellation Amélioration
SEARCHNET-3738 Étendre l’alphabet par défaut avec des scripts supplémentaires Amélioration
SEARCHNET-3739 Accélérer la recherche par intervalle de dates et garantir des résultats complets pour les intervalles longs Amélioration
SEARCHNET-3740 Réduire la consommation de mémoire de l’indexation et des opérations avec les textes de documents stockés Amélioration
SEARCHNET-3741 Accélérer l’indexation dans un réseau de recherche avec un grand nombre de documents Amélioration
SEARCHNET-3742 Implémenter l’indexation par lots et le traitement parallèle des requêtes de fragments dans un réseau de recherche Amélioration
SEARCHNET-3743 Implémenter le modèle de libération (dispose) dans les classes Index, IndexRepository, Cancellation, ExtractionHost et SearchNetworkNode Amélioration
SEARCHNET-3693 Implémenter la stratégie d’emballage TFM-Split pour le package NuGet GroupDocs.Search Amélioration
SEARCHNET-3747 Implémenter les packages NuGet pour .NET Framework 4.8, .NET 6.0, .NET 8.0, .NET 10.0 Amélioration
SEARCHNET-3746 Correction des attentes indéfinies d’un réseau de recherche pour les nœuds perdus ou non réactifs Correctif

Fonctionnalités majeures

Recherche

  • Les recherches répétées avec caractères génériques, expressions régulières, plages numériques et floues réutilisent les mots trouvés par les recherches antérieures avec la même requête tant que l’index ne change pas. Les mots conservés occupent jusqu’à 8 Mo de mémoire par index.
  • Les recherches simultanées d’un index partagent ses threads de recherche (IndexSettings.SearchThreads), de sorte que les recherches courtes n’attendent plus les longues.
  • La recherche par intervalle de dates lit chaque jour, mois et année de l’index une seule fois au lieu de rechercher chaque date de l’intervalle séparément. Les intervalles longs ne sont plus tronqués à la limite d’occurrences, et un intervalle de toutes les dates possibles, qui échouait auparavant, est maintenant recherché en quelques secondes.
  • La recherche par morceaux bénéficie de tous ces gains, et un référentiel d’index peut désormais être recherché par morceaux également : IndexRepository.SearchNext poursuit la recherche index par index.
  • La mise en évidence et Index.GetDocumentText peuvent diviser le texte avec le séparateur de mots personnalisé utilisé pour l’indexation, de sorte que les mots que le séparateur produit, par exemple les mots d’un texte sans espaces, sont également mis en évidence.
  • L’alphabet par défaut des nouveaux index comprend l’hébreu, le devanagari, le géorgien, le latin étendu, le grec et les lettres Hangul ainsi que les signes diacritiques combinés. Les mots tels que « Việt » ne sont plus divisés en parties, et les mots coréens et hébreux sont indexés et trouvés en entier.

Indexation et stockage d’index

  • Le nouveau paramètre IndexSettings.UseFastLoading permet à un index sur disque de supprimer les données supplémentaires qui rendent son chargement plusieurs fois plus rapide : l’index occupe moins d’espace disque mais se charge plus lentement. Le paramètre peut être modifié à tout moment, même pour un index contenant déjà des documents.
  • L’indexation alloue jusqu’à 4,5 fois moins de mémoire par document et, avec le texte de document stocké, s’exécute jusqu’à 2,2 fois plus rapidement. La récupération du texte stocké est 3,5 fois plus rapide avec 11 fois moins de mémoire, et la fusion d’index est 3,5 fois plus rapide avec presque 50 fois moins de mémoire.
  • Le texte des images dans les documents extrait dans un processus séparé peut désormais être reconnu : ExtractionHost.OcrConnector définit le connecteur OCR du processus d’extraction. Si la reconnaissance est activée mais que le processus d’extraction n’a pas de connecteur OCR, l’index le signale via l’événement ErrorOccurred.

Réseau de recherche

  • Les nœuds s’authentifient mutuellement avec une clé secrète partagée (TcpSettings.NetworkKey), et chaque message est signé : un ordinateur sans la clé ne peut ni donner des commandes à un nœud ni répondre pour un nœud. La clé n’est jamais envoyée sur le réseau. Un nœud esclave peut également restreindre les adresses dont il accepte le nœud maître (TcpSettings.AllowedMasterAddresses).
  • L’indexation est de 5 à 20 fois plus rapide et crée beaucoup moins de segments d’index : les documents qui arrivent pendant qu’un fragment est occupé sont indexés par lots de jusqu’à 1 000 documents ou 16 Mo, et les fragments d’un nœud traitent leurs requêtes en parallèle.
  • L’enregistrement des documents indexés sur le nœud maître ne ralentit plus à mesure que leur nombre augmente, et la liste des documents d’un fragment est conservée en toute sécurité lorsqu’une écriture échoue ou que le processus plante.
  • Le nœud maître détecte les nœuds perdus et non réactifs : un nœud esclave signale toutes les 5 secondes, et les appels n’attendent plus indéfiniment un nœud disparu. TcpSettings.ResponseTimeout peut également limiter la durée d’attente du nœud maître pour une réponse.

API et empaquetage

  • Index, IndexRepository, Cancellation, ExtractionHost et SearchNetworkNode implémentent le modèle de libération (dispose) standard de .NET, de sorte que les classes dérivées puissent libérer leurs propres ressources. La libération d’un Cancellation libère le minuteur d’une annulation planifiée par CancelAfter.
  • Le package NuGet GroupDocs.Search inclut désormais des builds pour .NET Framework 4.8, .NET 6.0, .NET 8.0 et .NET 10.0 en plus de .NET Framework 4.6.2 et .NET Standard 2.1, et sélectionne automatiquement le build correspondant au framework cible d’un projet.

Modifications de l’API publique

Les membres suivants ont été ajoutés :

  • GroupDocs.Search.IndexSettings:
    • Boolean UseFastLoading – conserve les données supplémentaires qui permettent à un index sur disque de se charger plusieurs fois plus rapidement. Activé par défaut ; définissez-le sur false pour économiser de l’espace disque.
  • GroupDocs.Search.Scaling.Configuring.TcpSettings:
    • String NetworkKey – la clé secrète du réseau de recherche, d’au moins 16 caractères et identique sur tous les nœuds.
    • String[] AllowedMasterAddresses – adresses IPv4 ou noms d’hôte depuis lesquels un nœud esclave accepte la connexion du nœud maître.
    • Int32 ResponseTimeout – le temps en millisecondes que le nœud maître attend pour la réponse d’un nœud à une requête. Aucun délai par défaut.
  • GroupDocs.Search.ExtractionHost:
    • IOcrConnector OcrConnector – le connecteur OCR du processus d’extraction séparé.
  • GroupDocs.Search.IndexRepository:
    • SearchResult SearchNext(ChunkSearchToken) et SearchResult SearchNext(ChunkSearchToken, Cancellation) – poursuivent une recherche par morceaux dans un référentiel d’index.
  • GroupDocs.Search.Options.TextOptions:
    • IWordSplitter WordSplitter – le séparateur de mots utilisé par la mise en évidence et Index.GetDocumentText ; hérité par HighlightOptions.
  • GroupDocs.Search.Common.Cancellation now implements IDisposable:
    • void Dispose() – libère le minuteur d’une annulation planifiée ; l’annulation planifiée n’est pas demandée.
  • Index, IndexRepository, Cancellation, ExtractionHost and SearchNetworkNode:
    • protected virtual void Dispose(Boolean disposing) – la méthode du modèle de libération pour les classes dérivées.

Les changements de comportement pouvant nécessiter des modifications de votre code sont répertoriés dans les notes de mise à jour ci-dessous.

Exemples de code

Rechercher un référentiel d’index par morceaux

L’exemple suivant recherche deux index d’un référentiel morceau par morceau, un index après l’autre.

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

Protéger un réseau de recherche avec une clé partagée

Chaque nœud d’un réseau de recherche reçoit la même clé secrète. Un nœud esclave accepte le nœud maître uniquement depuis son adresse, et le nœud maître limite l’attente des réponses des nœuds.

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

Réduire l’espace disque d’un index

L’exemple suivant crée un index qui occupe moins d’espace disque, puis le rend à nouveau chargé rapidement.

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
}

Notes de mise à jour

Prenez en compte les changements suivants lors de la mise à jour depuis une version précédente :

  • Les index modifiés par la version 26.11 ne peuvent pas être ouverts par des versions antérieures. La version 26.11 ouvre les index de la version 26.10 sans conversion, mais dès qu’elle crée ou modifie un index (par indexation, suppression de documents, optimisation ou changement de paramètres), les versions antérieures ne peuvent plus l’ouvrir. Mettez à jour toutes les applications qui partagent un dossier d’index en même temps, y compris les nœuds d’un réseau de recherche.
  • Les projets .NET Framework utilisent le package GroupDocs.Search. Remplacez GroupDocs.Search.NETFramework par GroupDocs.Search, qui inclut désormais les builds .NET Framework 4.6.2 et 4.8 et sélectionne automatiquement le bon build. Il n’existe pas de version 26.11 de GroupDocs.Search.NETFramework.
  • Tous les nœuds d’un réseau de recherche sont mis à jour ensemble. Les nœuds des versions 26.10 et 26.11 ne se connectent pas. Pour protéger le réseau, définissez la même TcpSettings.NetworkKey sur chaque nœud : les nœuds avec des clés différentes, ou un nœud avec une clé et un nœud sans, ne se connectent pas, et les deux écrivent la raison dans leurs journaux. Un nœud sans clé fonctionne comme auparavant et écrit un avertissement dans son journal.
  • Les messages d’un réseau de recherche sont signés mais non chiffrés. Gardez les nœuds dans un réseau de confiance ou connectez-les via un tunnel chiffré.
  • Les nœuds perdus sont détectés. Un nœud qui n’envoie rien pendant 15 secondes, par exemple un processus mis en pause dans un débogueur, est considéré comme perdu : les appels qui attendent ce nœud lèvent SearchException, et ses documents sont envoyés à d’autres nœuds ou signalés par l’événement ErrorOccurred. Par défaut le nœud maître attend les réponses sans limite ; définissez TcpSettings.ResponseTimeout pour limiter l’attente.
  • IndexSettings.SearchThreads est partagé par toutes les recherches d’un index. Une recherche utilise autant de threads qu’auparavant, mais K recherches simultanées s’exécutent maintenant sur max(K, SearchThreads) threads au lieu de K × SearchThreads.
  • Seuls les nouveaux index bénéficient de l’alphabet étendu. Les index des versions antérieures, y compris ceux mis à jour par IndexUpdater, divisent les mots de ces scripts comme auparavant, et Index.Merge refuse de fusionner un nouvel index avec un plus ancien. Pour les fusionner, exportez l’Alphabet et le TokenizationDictionary de l’index plus ancien avec ExportDictionary et importez-les dans le nouvel index avec Clear et ImportDictionary avant d’ajouter des documents.
  • Les limites d’occurrences comptent les parties des dates une fois. SearchOptions.MaxTotalOccurrenceCount et MaxOccurrenceCountPerTerm comptent chaque occurrence d’un jour, mois ou année une fois par recherche, ou une fois par morceau, au lieu d’une fois pour chaque date de l’intervalle. Un intervalle de dates qui atteignait une limite auparavant peut maintenant trouver toutes ses dates.
  • La recherche par morceaux dans un référentiel d’index se fait index par index. IndexRepository.Search avec IsChunkSearch renvoie le premier morceau du premier index. Continuez avec IndexRepository.SearchNext tant que SearchResult.NextChunkSearchToken n’est pas nul, ou effectuez une recherche sans morceaux pour obtenir tous les documents en un seul résultat.
  • L’OCR dans un processus d’extraction séparé utilise ExtractionHost.OcrConnector. Définissez le connecteur dans le programme du processus d’extraction et compilez ce programme avec la même version de GroupDocs.Search que l’application. Le connecteur OCR des options d’indexation n’est pas utilisé ici.
  • Le progrès de l’indexation réseau est signalé par réponse de fragment. NodeEventHub.IndexingProgressChanged se produit une fois pour chaque réponse d’un fragment, qui peut signaler plusieurs documents, ainsi ProcessedDocuments peut augmenter de plus d’un.

Comment obtenir la mise à jour

NuGet

  • NuGet – Installez le dernier package. Il fonctionne dans les projets .NET et .NET Framework et sélectionne automatiquement le build pour le framework cible : .NET Framework 4.6.2 ou 4.8, .NET Standard 2.1, .NET 6.0, .NET 8.0 ou .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

Téléchargement direct

Ressources