Shaunebu.Common.TaskSequenceManager 1.0.0

🚀 Shaunebu.Common.TaskSequenceManager

TaskSequenceManager is a lightweight, flexible, and cross-platform .NET library for managing sequences of asynchronous tasks with dependencies, priorities, phases, retries, and live dashboard reporting.

It works with .NET Core 3.1+ and .NET 8, without requiring MAUI, making it usable in Console, Web, or Desktop applications.

🌟 Features

🧩 Getting Started

Quick guide to integrate the library in a new project. For example:

• Create a console or .NET app.

• Add the NuGet package or project reference.

• Instantiate TaskSequenceManager and define tasks.

• Run tasks asynchronously with RunAsync.

🔧 Configuration Options

Describe configurable properties of the manager:

• MaxDegreeOfParallelism – control concurrency.

• GlobalTimeout – set a maximum duration for the entire task sequence.

• TaskItem.Timeout – set individual task timeouts.

• TaskItem.MaxRetries – retries per task.

• TaskItem.Priority – execution order when multiple tasks are ready.

• TaskItem.Phase – logical grouping for reporting and dashboards.

🛡 Error Handling

Explain how failures are handled:

• Tasks that throw exceptions can be retried automatically.

• Failed tasks trigger the TaskFailed event.

• Tasks depending on failed tasks won’t run until dependencies succeed.

• Optional OnTaskRetry callback provides granular control per retry attempt.

📊 Dashboard & Reporting

Guide to create live dashboards:

• Subscribe to TaskStarted, TaskCompleted, TaskFailed, ProgressChanged.

• Console output or custom UI can reflect live progress.

• Tasks can be grouped by Phase and sorted by Priority.

• Export task progress as JSON for further reporting.

💾 Persistence

Explain task sequence serialization:

• ToJson() – serialize current task states.

• LoadFromJson() – reload task sequences for resuming.

• DependencyGraphDot() – generate DOT graph for Graphviz visualization.

🧪 Testing & Debugging

Tips for testing task sequences:

• Create tasks with mock actions.

• Simulate failures to test retries and recovery.

• Validate correct execution order respecting dependencies and priorities.

• Use console dashboards for debugging.

⚡ Advanced Usage

• Dynamic task generation at runtime.

• Parallel execution with controlled concurrency.

• Conditional task execution based on previous task results.

• Integration with logging frameworks (ILogger).

📚 Example Scenarios

🛠 Installation

Install via NuGet:

dotnet add package Shaunebu.Common.TaskSequenceManager

⚙ Usage Example (Console App)

using Shaunebu.Common.TaskSequenceManager;
using Shaunebu.Common.TaskSequenceManager.Models;
using System;
using System.Threading;
using System.Threading.Tasks;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("🚀 TaskSequenceManager Dashboard Demo\n");

// Create the task manager
var taskManager = new TaskSequenceManager()
{
    MaxDegreeOfParallelism = 2,
    GlobalTimeout = TimeSpan.FromSeconds(30)
};

// Subscribe to events
taskManager.TaskStarted += t => DrawDashboard(taskManager.Tasks);
taskManager.TaskCompleted += t => DrawDashboard(taskManager.Tasks);
taskManager.TaskFailed += (t, ex) => DrawDashboard(taskManager.Tasks);
taskManager.ProgressChanged += p => DrawProgressBar(p);

// Progress bar
void DrawProgressBar(double progress)
{
    const int barWidth = 40;
    int filled = (int)(progress / 100 * barWidth);
    Console.CursorVisible = false;
    Console.Write("[");
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.Write(new string('█', filled));
    Console.ResetColor();
    Console.Write(new string('-', barWidth - filled));
    Console.Write($"] {progress:0.##}%\r");
    if (progress >= 100) Console.WriteLine();
}

// Dashboard display
void DrawDashboard(IReadOnlyList<TaskItem> tasks)
{
    Console.Clear();
    Console.WriteLine("=== Task Dashboard ===\n");
    foreach (var t in tasks.OrderBy(t => t.Phase).ThenByDescending(t => t.Priority))
    {
        var status = t.IsCompleted
            ? t.IsSuccessful ? "✅ Success" : "❌ Failed"
            : "⏳ Running / Pending";
        Console.WriteLine($"[{t.Phase ?? "General"} | Priority {t.Priority}] {t.Name} - {status}");
    }
    Console.WriteLine("\n=====================");
}

// Add tasks
taskManager.AddTask(async token =>
{
    await Task.Delay(1000, token);
    Console.WriteLine("Task A executed!");
}, name: "Task A", phase: "Initialization", priority: 2);

var taskB = taskManager.AddTask(async token =>
{
    await Task.Delay(1500, token);
    Console.WriteLine("Task B executed!");
}, name: "Task B", phase: "Processing", priority: 1, dependencies: new[] { "Task A" });

var taskC = taskManager.AddTask(async token =>
{
    await Task.Delay(500, token);
    Console.WriteLine("Task C executed!");
    throw new InvalidOperationException("Simulated failure");
}, name: "Task C", phase: "Processing", priority: 2, maxRetries: 2, dependencies: new[] { "Task A" });

// Retry event
taskC.OnTaskRetry = (t, attempt, ex) =>
{
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.WriteLine($"⚠️ {t.Name} retry {attempt} due to: {ex.Message}");
    Console.ResetColor();
};

taskManager.AddTask(async token =>
{
    await Task.Delay(700, token);
    Console.WriteLine("Task D executed!");
}, name: "Task D", phase: "Finalization", priority: 1, dependencies: new[] { "Task B", "Task C" });

// Run all tasks
using var cts = new CancellationTokenSource();
await taskManager.RunAsync(cts.Token);

// Final dashboard
DrawDashboard(taskManager.Tasks);

// Export tasks JSON
var json = taskManager.ToJson();
Console.WriteLine("\n📄 Task sequence JSON:");
Console.WriteLine(json);

// Export dependency graph
var dotGraph = taskManager.DependencyGraphDot();
Console.WriteLine("\n🗂 Dependency Graph DOT:");
Console.WriteLine(dotGraph);

📌 Notes

• Designed for cross-platform use without MAUI dependencies.

• Supports parallel execution via MaxDegreeOfParallelism.

• Handles task failures, timeouts, and automatic retries.

• Use Phases and Priorities for building dashboards and reporting.