Optimize IndexingContentHandlers perf

src/OrchardCore.Modules/OrchardCore.Search.Lucene/Handler/LuceneIndexingContentHandler.cs

@@ -76,9 +76,20 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
             {
                 // Only process the last context.
                 var context = ContextsById.Last();
+                ContentItem published = null;
 
-                ContentItem published = null, latest = null;
-                bool publishedLoaded = false, latestLoaded = false;
+                if (context is PublishContentContext publishContext)
+                {
+                    if (publishContext.Cancel)
+                    {
+                        continue;
+                    }
+
+                    if (publishContext.PreviousItem != null)
+                    {
+                        published = publishContext.PreviousItem;
+                    }
+                }
 
                 foreach (var indexSettings in await luceneIndexSettingsService.GetSettingsAsync())
                 {
@@ -88,35 +99,46 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
 
                     if (indexSettings.IndexedContentTypes.Contains(context.ContentItem.ContentType) && !ignoreIndexedCulture)
                     {
-                        if (!indexSettings.IndexLatest && !publishedLoaded)
+                        if (context is RemoveContentContext)
                         {
-                            publishedLoaded = true;
-                            published = await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Published);
+                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            continue;
                         }
 
-                        if (indexSettings.IndexLatest && !latestLoaded)
+                        async Task storeLuceneDocument(ContentItem contentItem)
                         {
-                            latestLoaded = true;
-                            latest = await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Latest);
-                        }
+                            var buildIndexContext = new BuildIndexContext(new DocumentIndex(contentItem.ContentItemId, contentItem.ContentItemVersionId), contentItem, new string[] { contentItem.ContentType }, new LuceneContentIndexSettings());
+                            await contentItemIndexHandlers.InvokeAsync(x => x.BuildIndexAsync(buildIndexContext), logger);
 
-                        var contentItem = !indexSettings.IndexLatest ? published : latest;
+                            if (!indexSettings.IndexLatest)
+                            {
+                                await luceneIndexManager.DeleteDocumentsByVersionIdAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemVersionId });
+                            }
+                            else
+                            {
+                                await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemId });
+                            }
 
-                        if (contentItem == null)
-                        {
-                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            await luceneIndexManager.StoreDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex });
                         }
-                        else
+
+                        if (!indexSettings.IndexLatest)
                         {
-                            var buildIndexContext = new BuildIndexContext(new DocumentIndex(contentItem.ContentItemId, contentItem.ContentItemVersionId), contentItem, new string[] { contentItem.ContentType }, new LuceneContentIndexSettings());
-                            await contentItemIndexHandlers.InvokeAsync(x => x.BuildIndexAsync(buildIndexContext), logger);
+                            published ??= await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Published);
 
-                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemId });
-                            await luceneIndexManager.StoreDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex });
+                            if (published is not null)
+                            {
+                                await storeLuceneDocument(published);
+                            }
                         }
+
+                        await storeLuceneDocument(context.ContentItem);
                     }
                 }
             }
         }
+
+
+
     }
 }

src/OrchardCore.Modules/OrchardCore.Search.Lucene/Services/LuceneIndexManager.cs

@@ -95,6 +95,21 @@ await WriteAsync(indexName, writer =>
                 }
             });
         }
+        public async Task DeleteDocumentsByVersionIdAsync(string indexName, IEnumerable<string> ContentItemVersionIds)
+        {
+            await WriteAsync(indexName, writer =>
+            {
+                writer.DeleteDocuments(ContentItemVersionIds.Select(x => new Term("ContentItemVersionId", x)).ToArray());
+
+                writer.Commit();
+
+                if (_indexPools.TryRemove(indexName, out var pool))
+                {
+                    pool.MakeDirty();
+                    pool.Release();
+                }
+            });
+        }
 
         public void DeleteIndex(string indexName)
         {