Hello Nicholas,

Can you please post an example of your solution. I would really appreciate it as when attempting to do so myself I ran into routing, umbraco null reference exceptions, and publish issues (e.g. the virtual media folder in iis was being ignored and a default path used instead).

First, I created this class:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Web;
using Umbraco.Core;
using Umbraco.Core.Logging;

namespace MyNamespace
{
    public class TaskManager
    {

        #region Variables

        private static readonly string TaskKey = Guid.NewGuid().ToString("N");

        #endregion

        #region Properties

        private static object TasksLock { get; set; }
        private static Queue<Action> Tasks { get; set; }

        #endregion

        #region Constructors

        /// <summary>
        /// Static constructor.
        /// </summary>
        static TaskManager()
        {
            TasksLock = new object();
            Tasks = new Queue<Action>();
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Processes any queued tasks in an Umbraco context.
        /// </summary>
        /// <param name="request">
        /// The current HTTP request.
        /// </param>
        /// <returns>
        /// True, if this request is one intended to process requests; otherwise, false.
        /// </returns>
        /// <remarks>
        /// To avoid blocking the thread, this method will make an extra web request in a
        /// new thread and specify a query string to indicate to that request that the tasks
        /// should be processed.
        /// </remarks>
        public static bool ProcessTasksInUmbracoContext(HttpRequestBase request)
        {

            // Variables.
            var processMode = false;

            // Check for special query string.
            if (TaskKey.InvariantEquals(request.QueryString["TaskKey"]))
            {

                // Process tasks.
                processMode = true;
                lock (TasksLock)
                {
                    if (Tasks.Any())
                    {
                        while (Tasks.Any())
                        {
                            try
                            {
                                var task = Tasks.Dequeue();
                                task();
                            }
                            catch (Exception ex)
                            {
                                LogHelper.Error<TaskManager>("Error while processing task in Umbraco context.", ex);
                            }
                        }
                    }
                }

            }
            else
            {

                // Call tasks from homepage (to ensure a valid Umbraco Context).
                lock (TasksLock)
                {
                    if (Tasks.Any())
                    {
                        var uri = request.Url;
                        var builder = new UriBuilder(uri) {Path = null, Query = "TaskKey=" + TaskKey};
                        var url = builder.Uri.AbsoluteUri;
                        ActionUtility.SafeThread(() => (new WebClient()).DownloadString(url));
                    }
                }

            }

            // Was in process mode?
            return processMode;

        }

        /// <summary>
        /// Adds a task to the queue.
        /// </summary>
        /// <param name="action">
        /// The action to execute in an Umbraco context.
        /// </param>
        public static void AddTask(Action action)
        {
            lock (TasksLock)
            {
                Tasks.Enqueue(action);
            }
        }

        #endregion

    }
}

Then in my main CSHTML file, I called a function on that class:

if (TaskManager.ProcessTasksInUmbracoContext(Request))
{
    return;
}

Anywhere I need a task to run on a different thread, I just call the AddTask function shown above to queue it up. Then, when somebody hits any page, all the tasks in the queue are processed on a different thread.

It does that by making a request back to the site with a special query string that normal visitors don't add. When it sees that query string, it just processes the tasks.

FYI, ActionUtility.SafeThread is just a function I created to ensure any exceptions are caught and suppressed. This is because threads that throw exceptions can cause problems for websites (i.e., IIS will restart the application pool if enough of them occur, based on whatever you have configured in IIS).

Note that this is an ugly workaround, but it works.

For good measure, here's the implementation of SafeThread:

/// <summary>
/// Runs an action in a thread an ensures no exceptions escape the thread.
/// </summary>
/// <param name="action">The action to run in the thread.</param>
/// <param name="errorHandler">The action to call if an exception is caught. Optional.</param>
/// <returns>The thread (already started).</returns>
public static Thread SafeThread(Action action, Action<Exception> errorHandler = null)
{
    var thread = new Thread(() =>
    {
        try {
            action();
        }
        catch (ThreadAbortException ex) {
            Thread.ResetAbort();
            if (errorHandler != null) {
                errorHandler(ex);
            }
        }
        catch (Exception ex) {
            if (errorHandler != null) {
                errorHandler(ex);
            }
        }
        catch {
            if (errorHandler != null) {
                errorHandler(null);
            }
        }
    });
    thread.Start();
    return thread;
}

I had some different use cases, from the sound of it. Mine related to asynchronously handling long running tasks (e.g., extracting data from a few hundred content nodes) and doing things with published content in a new thread (e.g., when a file system watcher indicated an import file was written to the file system).

setup nodes, pre-population of fields with dynamic data, automatic creation of child nodes when the site is interacted with etc

If you are talking about creating child nodes when a parent node of a particular doctype is created (for example), it sounds like you want to respond to the ContentService.Saved event: https://our.umbraco.org/documentation/reference/events/contentservice-events

From that point, you should be able to use the content service to create child nodes (and do a few other things, like pre-populate fields and such).