OrcaFlow.Core 0.2.0

Orca

A lightweight, generic task orchestration library for .NET.
Define tasks, chain them into pipelines, run them sequentially or in parallel, and add conditions – all with a minimal API.

✨ Features

• Generic context – pass any type as shared state across tasks
• Fluent builder – chain steps with .AddStep<T>() or .AddStep(instance)
• Conditional execution – skip steps dynamically with Func<TContext, bool>
• Parallel execution – group tasks and run them concurrently with ParallelGroupTask
• Lifecycle hooks – OnStepStarted, OnStepCompleted, OnStepFailed
• Error handling strategies – StopOnError or SkipFailed
• Cancellation support – via CancellationToken
• Dependency Injection support with IServiceCollection

🚀 Getting Started

1. Install

NuGet\Install-Package OrcaFlow.Core -Version 0.1.0

2. Define a task

Tasks implement the ITask<TContext> interface:

public sealed class AppendTask : ITask<List<string>>
{
    public string Name { get; }
    private readonly string _msg;

    public AppendTask(string name, string msg)
    {
        Name = name;
        _msg = msg;
    }

    public Task ExecuteAsync(List<string> context, CancellationToken token = default)
    {
        context.Add(_msg);
        return Task.CompletedTask;
    }
}

3. Build an orchestrator

Create a pipeline with sequential and parallel steps:

var builder = new OrchestratorBuilder<List<string>>()
    .AddStep(new AppendTask("A", "one"))
    .AddStep(new AppendTask("B", "two"))
    .AddStep<AppendTask>(ctx => ctx.Count < 5) // conditional with generic new()
    .AddStep(
        new ParallelGroupTask<List<string>>(
            "ParallelGroup",
            new ITask<List<string>>[]
            {
                new AppendTask("P1", "parallel-1"),
                new AppendTask("P2", "parallel-2")
            }))
    .Configure(options =>
    {
        options.ErrorStrategy = ErrorHandlingStrategy.ContinueOnError;
        options.OnStepStarted = async (task, ctx) =>
            Console.WriteLine($"Starting {task.Name}...");
        options.OnStepCompleted = async (task, ctx) =>
            Console.WriteLine($"Completed {task.Name}");
        options.OnStepFailed = async (task, ex, ctx) =>
            Console.WriteLine($"Step {task.Name} failed: {ex.Message}");
        // Middleware
        options.Use(async (task, ctx, next, token) =>
        {
            await next();
        });
    });

var orchestrator = builder.Build();

Or via DependencyInjection

public void ConfigureServices(IServiceCollection services)
{
    // Register services + tasks
    services.AddSingleton<MyService>();
    services.AddTransient<ServiceBackedTask>();
    services.AddTransient<OtherTask>();

    // Register orchestrator via extension
    services.AddOrchestrator<TestContext>(builder =>
    {
        builder.AddStep<ServiceBackedTask>()
               .AddStep<OtherTask>()
               .Configure(o =>
               {
                   o.OnStepStarted = async (task, ctx) =>
                       Console.WriteLine($"Starting {task.Name}...");
               });
    });
}

4. Run the pipeline

var context = new List<string>();

await orchestrator.RunAsync(context);

Console.WriteLine("Items: " + string.Join(", ", context));

Or inject the Orchestrator

public class MyController
{
    private readonly Orchestrator<TestContext> _orchestrator;

    public MyController(Orchestrator<TestContext> orchestrator)
    {
        _orchestrator = orchestrator;
    }

    public async Task<IActionResult> Run()
    {
        var ctx = new TestContext();
        await _orchestrator.RunAsync(ctx);
        return new OkObjectResult(ctx.Log);
    }
}

Example Output:

Starting A...
Completed A
Starting B...
Completed B
Starting AppendTask...
Completed AppendTask
Starting ParallelGroup...
Completed ParallelGroup
Items: one, two, conditional, parallel-1, parallel-2

Roadmap

• Retry policies (with backoff)

Project Structure

/Orca          → library code
/Orca.Tests  → unit tests