0_Program.cs

services.AddScoped<CommitStateHandler>();

// Add Elsa services to the container.
services.AddElsa(elsa =>
{
    elsa.UseWorkflows(workflows =>
    {
        workflows.CommitStateHandler = sp => sp.GetRequiredService<CommitStateHandler>();

        workflows.WithWorkflowExecutionPipeline(pipeline => pipeline
            .Reset()
            .UseEngineExceptionHandling()
            .UseExceptionHandling()
            .UseDefaultActivityScheduler());

        workflows.UseCommitStrategies(strategies =>
        {
            strategies.Add("ExecutedActivityStrategy", new ExecutedActivityStrategy());
        });
    });

    elsa.UseWorkflowRuntime(runtime =>
    {
        runtime.DistributedLockProvider = _ => new FileDistributedSynchronizationProvider(
            new DirectoryInfo(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString(), "App_Data", "locks")));
    });
});

1_Example.cs

using Azure.Storage.Blobs;
using Elsa.Extensions;
using Elsa.Workflows;
using Elsa.Workflows.Activities;
using Elsa.Workflows.CommitStates;

namespace ElsaConsole
{
    public class ExampleCommitStates
    {
        public static async Task Run_Example(
             IWorkflowBuilderFactory workflowBuilderFactory,
             IWorkflowRunner workflowRunner)
        {
            var workflowBuilder = workflowBuilderFactory.CreateBuilder();
            // workflowBuilder.WorkflowOptions.CommitStrategyName = "WorkflowExecutedWorkflowStrategy";

            var activity1 = new Inline(() =>
            {
                Console.WriteLine("Inline 1");
            })
            {
                CommitStrategy = "ExecutedActivityStrategy"
            };

            var activity2 = new CustomActivity()
            {
                CommitStrategy = "ExecutedActivityStrategy"
            };

            workflowBuilder.Root = new Sequence
            {
                Activities = [
                    activity1,
                    activity2,
                ],
            };

            var workflow = await workflowBuilder.BuildWorkflowAsync();
            var output = await workflowRunner.RunAsync(workflow);
        }
    }

    public class CustomActivity : CodeActivity<string>
    {
        public CustomActivity()
        {
        }

        protected override async ValueTask ExecuteAsync(ActivityExecutionContext context)
        {
            Console.WriteLine("Inline 2");
            context.SetResult("Hello");
            await Task.CompletedTask;
        }
    }
}

2_CommitStateHandler.cs

using Elsa.Workflows;
using Elsa.Workflows.CommitStates;
using Elsa.Workflows.Management;
using Elsa.Workflows.Runtime;
using Elsa.Workflows.Runtime.Entities;
using Elsa.Workflows.Runtime.Requests;
using Elsa.Workflows.State;

public class CommitStateHandler(
    IWorkflowInstanceManager workflowInstanceManager,
    IBookmarksPersister bookmarkPersister,
    IVariablePersistenceManager variablePersistenceManager,
    ILogRecordSink<ActivityExecutionRecord> activityExecutionLogRecordSink,
    ILogRecordSink<WorkflowExecutionLogRecord> workflowExecutionLogRecordSink) : ICommitStateHandler
{
    public async Task CommitAsync(WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken = default)
    {
        var workflowState = workflowInstanceManager.ExtractWorkflowState(workflowExecutionContext);
        await CommitAsync(workflowExecutionContext, workflowState, cancellationToken);
    }

    public async Task CommitAsync(WorkflowExecutionContext workflowExecutionContext, WorkflowState workflowState, CancellationToken cancellationToken = default)
    {
        // var updateBookmarksRequest = new UpdateBookmarksRequest(workflowExecutionContext, workflowExecutionContext.BookmarksDiff, workflowExecutionContext.CorrelationId);
        // await bookmarkPersister.PersistBookmarksAsync(updateBookmarksRequest);
        // await activityExecutionLogRecordSink.PersistExecutionLogsAsync(workflowExecutionContext, cancellationToken);
        // await workflowExecutionLogRecordSink.PersistExecutionLogsAsync(workflowExecutionContext, cancellationToken);
        // await variablePersistenceManager.SaveVariablesAsync(workflowExecutionContext);
        await workflowInstanceManager.SaveAsync(workflowState, cancellationToken);
        workflowExecutionContext.ExecutionLog.Clear();
        workflowExecutionContext.ClearCompletedActivityExecutionContexts();
        await workflowExecutionContext.ExecuteDeferredTasksAsync();
    }
}