C# SDK

TaskDaemon C# SDK guide

C# SDK

The C# SDK for writing TaskDaemon handlers.

Installation

Install the published TaskDaemon.Handler 0.1.2 package in a .NET 8 console application:

dotnet new console --name Handler --framework net8.0 --output Handler
cd Handler
dotnet add package TaskDaemon.Handler --version 0.1.2

Save a handler example below as Program.cs. The Dockerfiles below assume this application project is named Handler.csproj; build from the Handler/ directory.

Source installation

To use the release source instead, replace the package reference with a project reference:

git clone --branch v0.1.2 --depth 1 https://github.com/jona62/TaskDaemon-Handlers.git taskdaemon-handlers
dotnet remove package TaskDaemon.Handler
dotnet add reference taskdaemon-handlers/csharp/TaskDaemon/TaskDaemon.Handler.csproj

If the checkout is nested inside the application directory, exclude its source from the application’s default compile glob (the project reference compiles it separately):

<ItemGroup>
  <Compile Remove="taskdaemon-handlers/**/*.cs" />
</ItemGroup>

Keep this SDK directory in the Docker build context when using the source installation.

Use a reviewed SDK revision or release for deployment. Keep diagnostic logs on stderr; the handler protocol uses stdout for one response per task. A request starts with attempt: 1; retries require a valid retryable error and remaining stored budget.

Basic Usage

using System;
using System.Collections.Generic;
using TaskDaemon;

Handler.Run(task => {
    var name = task.task_data.GetValueOrDefault("name", "World");
    return new Success(new { message = $"Hello, {name}!" });
});

Task Record

public record Task(
    string task_id,
    string task_type,
    Dictionary<string, object> task_data,
    int attempt  // Current attempt (starts at 1)
);

Result Types

// Abstract base
public abstract record Result;

// Success with result
public record Success(object result) : Result;

// Error with message and optional retryable flag
public record Error(string error, bool retryable = false) : Result;

Usage:

// Success
return new Success(new { processed = true });

// Non-retryable error (default)
return new Error("Invalid input");

// Retryable error
return new Error("Service unavailable", retryable: true);

Complete Example

using System;
using System.Collections.Generic;
using TaskDaemon;
using System.Linq;
using System.Text.RegularExpressions;

Handler.Run(task => {
    var text = task.task_data.GetValueOrDefault("text", "")?.ToString() ?? "";

    // Count words
    var words = Regex.Matches(text, @"\S+").Count;

    // Count characters (excluding spaces)
    var chars = text.Count(c => !char.IsWhiteSpace(c));

    // Count lines
    var lines = text.Split('\n').Length;

    return new Success(new {
        words,
        characters = chars,
        lines
    });
});

Error Handling

Exceptions are automatically caught and converted to non-retryable errors:

Handler.Run(task => {
    // If this throws, it becomes Error(exception.Message)
    var required = task.task_data["required"];
    return new Success(new { value = required });
});

For explicit error handling:

Handler.Run(task => {
    if (!task.task_data.ContainsKey("required"))
        return new Error("Missing required field");

    try {
        var result = ExternalApiCall();
        return new Success(result);
    } catch (HttpRequestException e) {
        return new Error($"API unavailable: {e.Message}", retryable: true);
    }
});

HTTP Calls

The SDK exposes a synchronous Handler.Run callback. If you use an asynchronous client inside it, wait for that operation before returning one response:

using System;
using System.Collections.Generic;
using System.Net.Http;
using TaskDaemon;

Handler.Run(task => {
    var url = task.task_data["url"]?.ToString();

    using var client = new HttpClient();
    var response = client.GetStringAsync(url!).GetAwaiter().GetResult();

    return new Success(new { data = response });
});

Dockerfile

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS builder
WORKDIR /app
COPY . ./
RUN dotnet restore Handler.csproj
RUN dotnet publish Handler.csproj -c Release -o out

FROM mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR /app
COPY --from=builder /app/out ./
CMD ["dotnet", "Handler.dll"]

For a self-contained single-file deployment:

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS builder
WORKDIR /app
COPY . ./
RUN dotnet publish Handler.csproj -c Release -r linux-x64 --self-contained true -p:PublishSingleFile=true -o out

FROM mcr.microsoft.com/dotnet/runtime-deps:8.0
COPY --from=builder /app/out/Handler /handler
CMD ["/handler"]

Handler Configuration

[handlers.process]
image = "csharp-handler:latest"
instances = 4
timeout = 30

Requirements

• .NET 8.0+ (the published package targets net8.0)
• System.Text.Json for serialization (built-in)