Bulk content actions

[nikcio]

Bulk content actions

In Umbraco, we already have a content service interface that lets us create, save, publish and delete content but an area that still has room to grow is making changes in bulk. There's already quite a bit of overhead when manipulating content which makes content changes in bulk very expensive. Therefore, I propose making bulk actions for manipulating content where it's easier to optimize a process for editing content in bulk and thereby lowering the overhead needed. I've already made a bit of research on one of the ways the process for saving and publishing as well as deleting could be optimized.

I believe that there are more ways bulk actions could be optimzied which is why it's created here as a discussion.

Table of contents

• Bulk content actions
  - Table of contents
  • Bulk actions setup
    • Delete
      • Original delete
      • Bulk delete
    • Save and publish
      • Original save and publish
      • Bulk save and publish
  • Benchmarks setup
    • ContentController
  • Content lifecycle test
    • Content lifecycle test code
    • Results
      • Thoughts
        • Explanation
  • Content save and publish test
    • Content save and publish test code
    • Results
      • Thoughts
        • Explanation
      • Diagrams
  • POC
  • Discussion comments

Bulk actions setup

So the bulk actions I created were the Delete and SaveAndPublish methods on the ContentService. The optimizations I made were to limit the number of notifications that needed to be sent and the number of scopes that needed to be created.

Delete

Original delete

Umbraco-CMS/src/Umbraco.Core/Services/ContentService.cs

Lines 2217 to 2275 in d0a7522

	public OperationResult Delete(IContent content, int userId = Constants.Security.SuperUserId)
	{
	EventMessages eventMessages = EventMessagesFactory.Get();
	using (ICoreScope scope = ScopeProvider.CreateCoreScope())
	{
	if (scope.Notifications.PublishCancelable(new ContentDeletingNotification(content, eventMessages)))
	{
	scope.Complete();
	return OperationResult.Cancel(eventMessages);
	}
	scope.WriteLock(Constants.Locks.ContentTree);
	// if it's not trashed yet, and published, we should unpublish
	// but... Unpublishing event makes no sense (not going to cancel?) and no need to save
	// just raise the event
	if (content.Trashed == false && content.Published)
	{
	scope.Notifications.Publish(new ContentUnpublishedNotification(content, eventMessages));
	}
	DeleteLocked(scope, content, eventMessages);
	scope.Notifications.Publish(
	new ContentTreeChangeNotification(content, TreeChangeTypes.Remove, eventMessages));
	Audit(AuditType.Delete, userId, content.Id);
	scope.Complete();
	}
	return OperationResult.Succeed(eventMessages);
	}
	private void DeleteLocked(ICoreScope scope, IContent content, EventMessages evtMsgs)
	{
	void DoDelete(IContent c)
	{
	_documentRepository.Delete(c);
	scope.Notifications.Publish(new ContentDeletedNotification(c, evtMsgs));
	// media files deleted by QueuingEventDispatcher
	}
	const int pageSize = 500;
	var total = long.MaxValue;
	while (total > 0)
	{
	//get descendants - ordered from deepest to shallowest
	IEnumerable<IContent> descendants = GetPagedDescendants(content.Id, 0, pageSize, out total,
	ordering: Ordering.By("Path", Direction.Descending));
	foreach (IContent c in descendants)
	{
	DoDelete(c);
	}
	}
	DoDelete(content);
	}

/// <inheritdoc />
public OperationResult Delete(IContent content, int userId = Constants.Security.SuperUserId)
{
    EventMessages eventMessages = EventMessagesFactory.Get();

    using (ICoreScope scope = ScopeProvider.CreateCoreScope())
    {
        if (scope.Notifications.PublishCancelable(new ContentDeletingNotification(content, eventMessages)))
        {
            scope.Complete();
            return OperationResult.Cancel(eventMessages);
        }

        scope.WriteLock(Constants.Locks.ContentTree);

        // if it's not trashed yet, and published, we should unpublish
        // but... Unpublishing event makes no sense (not going to cancel?) and no need to save
        // just raise the event
        if (content.Trashed == false && content.Published)
        {
            scope.Notifications.Publish(new ContentUnpublishedNotification(content, eventMessages));
        }

        DeleteLocked(scope, content, eventMessages);

        scope.Notifications.Publish(
            new ContentTreeChangeNotification(content, TreeChangeTypes.Remove, eventMessages));
        Audit(AuditType.Delete, userId, content.Id);

        scope.Complete();
    }

    return OperationResult.Succeed(eventMessages);
}

private void DeleteLocked(ICoreScope scope, IContent content, EventMessages evtMsgs)
{
    void DoDelete(IContent c)
    {
        _documentRepository.Delete(c);
        scope.Notifications.Publish(new ContentDeletedNotification(c, evtMsgs));

        // media files deleted by QueuingEventDispatcher
    }

    const int pageSize = 500;
    var total = long.MaxValue;
    while (total > 0)
    {
        //get descendants - ordered from deepest to shallowest
        IEnumerable<IContent> descendants = GetPagedDescendants(content.Id, 0, pageSize, out total,
            ordering: Ordering.By("Path", Direction.Descending));
        foreach (IContent c in descendants)
        {
            DoDelete(c);
        }
    }

    DoDelete(content);
}

Bulk delete

The BulkDelete method uses a profiling logger for debug purposes. I wanted to know which part of the process was the most demanding and by how much. The conclusion was that the Deleting content part was the most demanding by far.

Example trace:

• Prepare delete [0ms]
• Deleting content [5834ms]
• Completing delete [180ms]

/// <inheritdoc />
public OperationResult BulkDelete(IEnumerable<IContent> contentItems, int userId = Constants.Security.SuperUserId)
{
    EventMessages eventMessages = EventMessagesFactory.Get();

    using (ICoreScope scope = ScopeProvider.CreateCoreScope())
    {
        using (_profilingLogger.TraceDuration<ContentService>("Prepare delete", "Done prepare delete"))
        {
            if (scope.Notifications.PublishCancelable(new ContentDeletingNotification(contentItems, eventMessages)))
            {
                scope.Complete();
                return OperationResult.Cancel(eventMessages);
            }

            scope.WriteLock(Constants.Locks.ContentTree);

            // if it's not trashed yet, and published, we should unpublish
            // but... Unpublishing event makes no sense (not going to cancel?) and no need to save
            // just raise the event

            var nonTrashedPublishContent = contentItems.Where(content => content.Trashed == false && content.Published);

            if (nonTrashedPublishContent.Any())
            {
                scope.Notifications.Publish(new ContentUnpublishedNotification(nonTrashedPublishContent, eventMessages));
            }
        }

        using(_profilingLogger.TraceDuration<ContentService>("Deleting content", "Done deleting content"))
        {
            foreach (var content in contentItems)
            {
                DeleteLocked(scope, content, eventMessages);
            }
        }

        using(_profilingLogger.TraceDuration<ContentService>("Completing delete", "Done delete completion"))
        {
            scope.Notifications.Publish(
                new ContentTreeChangeNotification(contentItems, TreeChangeTypes.Remove, eventMessages));

            foreach (var content in contentItems)
            {
                Audit(AuditType.Delete, userId, content.Id);
            }
        }

        scope.Complete();
    }

    return OperationResult.Succeed(eventMessages);
}

private void DeleteLocked(ICoreScope scope, IContent content, EventMessages evtMsgs)
{
    void DoDelete(IContent c)
    {
        _documentRepository.Delete(c);
        scope.Notifications.Publish(new ContentDeletedNotification(c, evtMsgs));

        // media files deleted by QueuingEventDispatcher
    }

    const int pageSize = 500;
    var total = long.MaxValue;
    while (total > 0)
    {
        //get descendants - ordered from deepest to shallowest
        IEnumerable<IContent> descendants = GetPagedDescendants(content.Id, 0, pageSize, out total,
            ordering: Ordering.By("Path", Direction.Descending));
        foreach (IContent c in descendants)
        {
            DoDelete(c);
        }
    }

    DoDelete(content);
}

Save and publish

Original save and publish

Umbraco-CMS/src/Umbraco.Core/Services/ContentService.cs

Lines 1087 to 1149 in d0a7522

	public PublishResult SaveAndPublish(IContent content, string culture = "*",
	int userId = Constants.Security.SuperUserId)
	{
	EventMessages evtMsgs = EventMessagesFactory.Get();
	PublishedState publishedState = content.PublishedState;
	if (publishedState != PublishedState.Published && publishedState != PublishedState.Unpublished)
	{
	throw new InvalidOperationException(
	$"Cannot save-and-publish (un)publishing content, use the dedicated {nameof(CommitDocumentChanges)} method.");
	}
	// cannot accept invariant (null or empty) culture for variant content type
	// cannot accept a specific culture for invariant content type (but '*' is ok)
	if (content.ContentType.VariesByCulture())
	{
	if (culture.IsNullOrWhiteSpace())
	{
	throw new NotSupportedException("Invariant culture is not supported by variant content types.");
	}
	}
	else
	{
	if (!culture.IsNullOrWhiteSpace() && culture != "*")
	{
	throw new NotSupportedException(
	$"Culture \"{culture}\" is not supported by invariant content types.");
	}
	}
	if (content.Name != null && content.Name.Length > 255)
	{
	throw new InvalidOperationException("Name cannot be more than 255 characters in length.");
	}
	using (ICoreScope scope = ScopeProvider.CreateCoreScope())
	{
	scope.WriteLock(Constants.Locks.ContentTree);
	var allLangs = _languageRepository.GetMany().ToList();
	var savingNotification = new ContentSavingNotification(content, evtMsgs);
	if (scope.Notifications.PublishCancelable(savingNotification))
	{
	return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
	}
	// if culture is specific, first publish the invariant values, then publish the culture itself.
	// if culture is '*', then publish them all (including variants)
	//this will create the correct culture impact even if culture is * or null
	var impact = CultureImpact.Create(culture, IsDefaultCulture(allLangs, culture), content);
	// publish the culture(s)
	// we don't care about the response here, this response will be rechecked below but we need to set the culture info values now.
	content.PublishCulture(impact);
	PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs,
	savingNotification.State, userId);
	scope.Complete();
	return result;
	}
	}

/// <inheritdoc />
public PublishResult SaveAndPublish(IContent content, string culture = "*",
    int userId = Constants.Security.SuperUserId)
{
    EventMessages evtMsgs = EventMessagesFactory.Get();

    PublishedState publishedState = content.PublishedState;
    if (publishedState != PublishedState.Published && publishedState != PublishedState.Unpublished)
    {
        throw new InvalidOperationException(
            $"Cannot save-and-publish (un)publishing content, use the dedicated {nameof(CommitDocumentChanges)} method.");
    }

    // cannot accept invariant (null or empty) culture for variant content type
    // cannot accept a specific culture for invariant content type (but '*' is ok)
    if (content.ContentType.VariesByCulture())
    {
        if (culture.IsNullOrWhiteSpace())
        {
            throw new NotSupportedException("Invariant culture is not supported by variant content types.");
        }
    }
    else
    {
        if (!culture.IsNullOrWhiteSpace() && culture != "*")
        {
            throw new NotSupportedException(
                $"Culture \"{culture}\" is not supported by invariant content types.");
        }
    }

    if (content.Name != null && content.Name.Length > 255)
    {
        throw new InvalidOperationException("Name cannot be more than 255 characters in length.");
    }

    using (ICoreScope scope = ScopeProvider.CreateCoreScope())
    {
        scope.WriteLock(Constants.Locks.ContentTree);

        var allLangs = _languageRepository.GetMany().ToList();

        var savingNotification = new ContentSavingNotification(content, evtMsgs);
        if (scope.Notifications.PublishCancelable(savingNotification))
        {
            return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
        }

        // if culture is specific, first publish the invariant values, then publish the culture itself.
        // if culture is '*', then publish them all (including variants)

        //this will create the correct culture impact even if culture is * or null
        var impact = CultureImpact.Create(culture, IsDefaultCulture(allLangs, culture), content);

        // publish the culture(s)
        // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now.
        content.PublishCulture(impact);

        PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs,
            savingNotification.State, userId);
        scope.Complete();
        return result;
    }
}

Bulk save and publish

The BulkSaveAndPublish method uses a profiling logger for debug purposes. I wanted to know which part of the process was the most demanding and by how much. The conclusion was that the Publish contentItem part was the most demanding by far.

Example trace:

• Validating content [0ms]
• Prepare publish [0ms]
• Publish contentItems [3344ms]

/// <inheritdoc />
public IEnumerable<PublishResult> BulkSaveAndPublish(IEnumerable<IContent> contentItems, string culture = "*",
    int userId = Constants.Security.SuperUserId)
{
    EventMessages evtMsgs = EventMessagesFactory.Get();

    using(_profilingLogger.TraceDuration<ContentService>("Validating content", "Completed content valid")){
        foreach (var content in contentItems)
        {
            EnsureContentIsValid(content, culture);
        }
    }

    using (ICoreScope scope = ScopeProvider.CreateCoreScope())
    {
        List<ILanguage> allLangs = new();
        ContentSavingNotification? savingNotification = null;
        using(_profilingLogger.TraceDuration<ContentService>("Prepare publish", "Done prepareing publish"))
        {
            scope.WriteLock(Constants.Locks.ContentTree);

            allLangs = _languageRepository.GetMany().ToList();

            savingNotification = new ContentSavingNotification(contentItems, evtMsgs);
            if (scope.Notifications.PublishCancelable(savingNotification))
            {
                return new List<PublishResult> { new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, null) };
            }
        }

        List<PublishResult> results = new();

        using(_profilingLogger.TraceDuration<ContentService>("Publish contentItems", "Done publishing contentItems"))
        {
            foreach (var content in contentItems)
            {
                results.Add(Publish(content, culture, userId, evtMsgs, scope, allLangs, savingNotification));
            }
        }

        scope.Complete();
        return results;
    }
}

private PublishResult Publish(IContent content, string culture, int userId, EventMessages evtMsgs, ICoreScope scope, List<ILanguage> allLangs, ContentSavingNotification savingNotification)
{
    // if culture is specific, first publish the invariant values, then publish the culture itself.
    // if culture is '*', then publish them all (including variants)

    //this will create the correct culture impact even if culture is * or null
    var impact = CultureImpact.Create(culture, IsDefaultCulture(allLangs, culture), content);

    // publish the culture(s)
    // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now.
    content.PublishCulture(impact);

    return CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, savingNotification.State, userId);
}

private static void EnsureContentIsValid(IContent content, string culture)
{
    PublishedState publishedState = content.PublishedState;
    if (publishedState != PublishedState.Published && publishedState != PublishedState.Unpublished)
    {
        throw new InvalidOperationException(
            $"Cannot save-and-publish (un)publishing content, use the dedicated {nameof(CommitDocumentChanges)} method.");
    }

    // cannot accept invariant (null or empty) culture for variant content type
    // cannot accept a specific culture for invariant content type (but '*' is ok)
    if (content.ContentType.VariesByCulture())
    {
        if (culture.IsNullOrWhiteSpace())
        {
            throw new NotSupportedException("Invariant culture is not supported by variant content types.");
        }
    }
    else
    {
        if (!culture.IsNullOrWhiteSpace() && culture != "*")
        {
            throw new NotSupportedException(
                $"Culture \"{culture}\" is not supported by invariant content types.");
        }
    }

    if (content.Name != null && content.Name.Length > 255)
    {
        throw new InvalidOperationException("Name cannot be more than 255 characters in length.");
    }
}

Benchmarks setup

Note: I'm in no way an expert benchmarker

To figure out if my changes were any improvement I created a simple Benchmarking setup to test the creation process against the existing one.

The setup included a clean Umbraco install straight from source code hooked up to a Docker MSSQL server running on my local machine. In the Umbraco instance, I created one document type called Test with the alias test. This document type included no properties and was allowed as a root element. Besides that, I created a controller ContentController:

ContentController

using Microsoft.AspNetCore.Mvc;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Web.Common.Controllers;

namespace Umbraco.Cms.Web.UI.Benchmarks
{
    public class ContentController : UmbracoApiController
    {
        private readonly IContentService _contentService;

        public ContentController(IContentService contentService) => _contentService = contentService;

        [HttpGet]
        public bool ContentLifecycleSingle()
        {
            var content = _contentService.Create("Benchmark", -1, "test");
            _ = _contentService.SaveAndPublish(content);
            return true;
        }

        [HttpGet]
        public bool ContentLifecycleMulti(int count)
        {
            var contentItems = new List<IContent>();
            for (int i = 0; i < count; i++)
            {
                contentItems.Add(_contentService.Create("Benchmark", -1, "test"));
            }
            foreach (var content in contentItems)
            {
                _ = _contentService.SaveAndPublish(content);
            }
            return true;
        }

        [HttpGet]
        public bool BulkContentLifecycleSingle()
        {
            var content = _contentService.Create("Benchmark", -1, "test");
            _ = _contentService.SaveAndPublish(content);
            return true;
        }

        [HttpGet]
        public bool BulkContentLifecycleMulti(int count)
        {
            var contentItems = new List<IContent>();
            for (int i = 0; i < count; i++)
            {
                contentItems.Add(_contentService.Create("Benchmark", -1, "test"));
            }
            _ = _contentService.BulkSaveAndPublish(contentItems);
            return true;
        }

        [HttpGet]
        public string Clean()
        {
            var contentNodes = _contentService.GetRootContent();
            foreach (var node in contentNodes)
            {
                _contentService.Delete(node);
            }
            return "done";
        }

        [HttpGet]
        public string BulkClean()
        {
            var contentNodes = _contentService.GetRootContent();
            _contentService.BulkDelete(contentNodes);
            return "done";
        }
    }
}

This controller has actions for creating a single or creating multiple content nodes in the root as well as cleaning the root for content nodes.

Note: The Lifecycle naming was just bad naming on my part. The methods only create content nodes

Content lifecycle test

The first test I ran was a lifecycle test where I first created several nodes before deleting all content nodes. Before and after a benchmark the content tree is cleaned to make sure that every test had a clean starting point even if one clean failed, which I did not experience.

Content lifecycle test code

using BenchmarkDotNet.Attributes;

namespace Umbraco.Benchmarking
{
    public class ContentTests
    {
        [GlobalSetup]
        public async Task Setup()
        {
            await BulkClean();
        }

        [GlobalCleanup]
        public async Task Cleanup()
        {
            await BulkClean();
        }

        private static async Task Clean()
        {
            var client = new HttpClient
            {
                Timeout = TimeSpan.FromDays(10),
            };
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/Clean");
        }

        private static async Task BulkClean()
        {
            var client = new HttpClient
            {
                Timeout = TimeSpan.FromDays(10),
            };
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkClean");
        }
        
        [Benchmark]
        public async Task ContentLifeCycleSingle()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleSingle");
           await Clean();
        }

        [Benchmark]
        public async Task BulkContentLifeCycleSingle()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleSingle");
           await BulkClean();
        }

        [Benchmark]
        public async Task ContentLifeCycleTen()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=10");
           await Clean();
        }

        [Benchmark]
        public async Task BulkContentLifeCycleTen()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleMulti?count=10");
           await BulkClean();
        }

        [Benchmark]
        public async Task ContentLifeCycleTwenty()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=20");
           await Clean();
        }

        [Benchmark]
        public async Task BulkContentLifeCycleTwenty()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleMulti?count=20");
           await BulkClean();
        }

        [Benchmark]
        public async Task ContentLifeCycleFifty()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=50");
           await Clean();
        }

        [Benchmark]
        public async Task BulkContentLifeCycleFifty()
        {
           using var client = new HttpClient();
           client.Timeout = TimeSpan.FromDays(10);
           _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleMulti?count=50");
           await BulkClean();
        }
    }
}

Results

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1706 (21H1/May2021Update)
AMD FX(tm)-8350, 1 CPU, 8 logical and 4 physical cores
.NET SDK=6.0.202
  [Host]     : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
  DefaultJob : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT

Method	Mean	Error	StdDev
ContentLifeCycleSingle	262.6 ms	5.40 ms	15.67 ms
BulkContentLifeCycleSingle	265.0 ms	5.27 ms	13.33 ms
ContentLifeCycleTen	2,221.9 ms	43.75 ms	55.32 ms
BulkContentLifeCycleTen	1,828.1 ms	36.49 ms	94.19 ms
ContentLifeCycleTwenty	4,496.2 ms	88.43 ms	121.04 ms
BulkContentLifeCycleTwenty	3,497.3 ms	69.61 ms	123.73 ms
ContentLifeCycleFifty	10,979.0 ms	197.44 ms	175.02 ms
BulkContentLifeCycleFifty	8,635.4 ms	167.80 ms	218.19 ms

Thoughts

The results in this test show that the decrease in scopes and notifications does improve performance when working with bulk operations.

Note: This is the time to create and delete

Explanation

Method
ContentLifeCycleSingle	Create and delete 1
BulkContentLifeCycleSingle	Create and delete 1
ContentLifeCycleTen	Create and delete 10
BulkContentLifeCycleTen	Create and delete 10
ContentLifeCycleTwenty	Create and delete 20
BulkContentLifeCycleTwenty	Create and delete 20
ContentLifeCycleFifty	Create and delete 50
BulkContentLifeCycleFifty	Create and delete 50

Content save and publish test

The second test was based on a more real-world use case where the content nodes were not deleted between every run. This means that the number of nodes was higher the more tests was run. The content tree was cleaned from all content nodes between benchmarks, meaning that every benchmark would start from a clean content tree.

Content save and publish test code

using BenchmarkDotNet.Attributes;

namespace Umbraco.Benchmarking
{
    public class ContentTests
    {
        [GlobalSetup]
        public async Task Setup()
        {
            await BulkClean();
        }

        [GlobalCleanup]
        public async Task Cleanup()
        {
            await BulkClean();
        }

        private static async Task BulkClean()
        {
            var client = new HttpClient
            {
                Timeout = TimeSpan.FromDays(10),
            };
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkClean");
        }

        [Benchmark]
        public async Task ContentSaveAndPublishSingle()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleSingle");
        }

        [Benchmark]
        public async Task BulkContentSaveAndPublishSingle()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleSingle");
        }

        [Benchmark]
        public async Task ContentSaveAndPublishTen()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=10");
        }

        [Benchmark]
        public async Task BulkContentSaveAndPublishTen()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=10");
        }


        [Benchmark]
        public async Task ContentSaveAndPublishTwenty()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=20");
        }

        [Benchmark]
        public async Task BulkContenSaveAndPublishTwenty()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleMulti?count=20");
        }

        [Benchmark]
        public async Task ContentSaveAndPublishFifty()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/ContentLifecycleMulti?count=50");
        }

        [Benchmark]
        public async Task BulkContentSaveAndPublishFifty()
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromDays(10);
            _ = await client.GetAsync("https://localhost:44331/umbraco/api/Content/BulkContentLifecycleMulti?count=50");
        }
    }
}

Results

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1706 (21H1/May2021Update)
AMD FX(tm)-8350, 1 CPU, 8 logical and 4 physical cores
.NET SDK=6.0.202
  [Host]     : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
  DefaultJob : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT

Method	Mean	Error	StdDev
ContentSaveAndPublishSingle	142.7 ms	2.83 ms	7.80 ms
BulkContentSaveAndPublishSingle	140.2 ms	2.79 ms	7.14 ms
ContentSaveAndPublishTen	1,265.5 ms	25.08 ms	49.50 ms
BulkContentSaveAndPublishTen	1,239.9 ms	24.52 ms	46.06 ms
ContentSaveAndPublishTwenty	2,810.7 ms	88.46 ms	260.82 ms
BulkContenSaveAndPublishTwenty	2,532.6 ms	70.60 ms	208.17 ms
ContentSaveAndPublishFifty	8,508.8 ms	412.43 ms	1,216.05 ms
BulkContentSaveAndPublishFifty	7,576.4 ms	389.91 ms	1,149.67 ms

Thoughts

The results in this test show that the decrease in scopes and notifications does improve performance when working with bulk operations. But the difference is not as noticeable as in the first test.

This might be due to the gradual increase in operation time that the test encountered. The test data showed that the more content nodes created in the content tree the longer it took to create new ones. See diagrams.

Explanation

Method
ContentSaveAndPublishSingle	Create 1 each run
BulkContentSaveAndPublishSingle	Create 1 each run
ContentSaveAndPublishTen	Create 10 each run
BulkContentSaveAndPublishTen	Create 10 each run
ContentSaveAndPublishTwenty	Create 20 each run
BulkContenSaveAndPublishTwenty	Create 20 each run
ContentSaveAndPublishFifty	Create 50 each run
BulkContentSaveAndPublishFifty	Create 50 each run

Note: This is the time to only create a content node

Diagrams

https://docs.google.com/spreadsheets/d/1reKIUMoJMdI-f-WYLuUwXz6C28fsUAkhUkz4WjbrzDw/edit?usp=sharing

POC

The code used to create this can be found here: nikcio@95a8f5d

Discussion comments