Optimize IndexingContentHandlers perf

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

@@ -77,9 +77,6 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
                 // Only process the last context.
                 var context = ContextsById.Last();
 
-                ContentItem published = null, latest = null;
-                bool publishedLoaded = false, latestLoaded = false;
-
                 foreach (var indexSettings in await luceneIndexSettingsService.GetSettingsAsync())
                 {
                     var cultureAspect = await contentManager.PopulateAspectAsync<CultureAspect>(context.ContentItem);
@@ -88,31 +85,74 @@ 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.StoreDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex });
+                        }
+
+                        if (!indexSettings.IndexLatest)
                         {
-                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            if (context is PublishContentContext publishContext)
+                            {
+                                if (publishContext.Cancel)
+                                {
+                                    continue;
+                                }
+
+                                if (publishContext.IsPublishing == true)
+                                {
+                                    await storeLuceneDocument(publishContext.PublishingItem);
+                                }
+                                else
+                                {
+                                    await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                                }
+                            }
                         }
                         else
                         {
-                            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);
-
-                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemId });
-                            await luceneIndexManager.StoreDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex });
+                            if (context is PublishContentContext publishContext)
+                            {
+                                if (publishContext.Cancel)
+                                {
+                                    continue;
+                                }
+
+                                if (publishContext.IsPublishing == true)
+                                {
+                                    await storeLuceneDocument(publishContext.PublishingItem);
+                                }
+                                else
+                                {
+                                    await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                                }
+                            }
+                            else if (context is UpdateContentContext updateContext)
+                            {
+                                await storeLuceneDocument(updateContext.UpdatingItem);
+                            }
+                            else if(context is CreateContentContext createContext)
+                            {
+                                await storeLuceneDocument(createContext.CreatingItem);
+                            }
                         }
                     }
                 }

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

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/CreateContentContext.cs

@@ -4,6 +4,9 @@ public class CreateContentContext : ContentContextBase
     {
         public CreateContentContext(ContentItem contentItem) : base(contentItem)
         {
+            CreatingItem = contentItem;
         }
+
+        public ContentItem CreatingItem { get; private set; }
     }
 }

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/PublishContentContext.cs

@@ -2,15 +2,18 @@ namespace OrchardCore.ContentManagement.Handlers
 {
     public class PublishContentContext : ContentContextBase
     {
-        public PublishContentContext(ContentItem contentItem, ContentItem previousContentItem) : base(contentItem)
+        public PublishContentContext(ContentItem contentItem, ContentItem previousContentItem, bool? isPublishing = true) : base(contentItem)
         {
-            PublishingItem = contentItem;
+            PublishingItem = isPublishing == true ? contentItem : null;
             PreviousItem = previousContentItem;
+            IsPublishing = isPublishing;
         }
 
-        public ContentItem PublishingItem { get; set; }
-        public ContentItem PreviousItem { get; set; }
+        public ContentItem PublishingItem { get; private set; }
+        public ContentItem PreviousItem { get; private set; }
 
         public bool Cancel { get; set; }
+
+        public bool? IsPublishing { get; private set; } = true;
     }
 }

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/UpdateContentContext.cs

@@ -7,6 +7,6 @@ public UpdateContentContext(ContentItem contentItem) : base(contentItem)
             UpdatingItem = contentItem;
         }
 
-        public ContentItem UpdatingItem { get; set; }
+        public ContentItem UpdatingItem { get; private set; }
     }
 }

src/OrchardCore/OrchardCore.ContentManagement/DefaultContentManager.cs

@@ -476,10 +476,7 @@ public async Task UnpublishAsync(ContentItem contentItem)
             // Create a context for the item. the publishing version is null in this case
             // and the previous version is the one active prior to unpublishing. handlers
             // should take this null check into account
-            var context = new PublishContentContext(contentItem, publishedItem)
-            {
-                PublishingItem = null
-            };
+            var context = new PublishContentContext(contentItem, publishedItem, false);
 
             await Handlers.InvokeAsync((handler, context) => handler.UnpublishingAsync(context), context, _logger);