Mostlylucid.Ephemeral.Patterns.SignalReactionShowcase 2.3.2

Mostlylucid.Ephemeral.Patterns.SignalReactionShowcase

Demonstrates signal emission, async dispatch, and sink polling patterns.

dotnet add package mostlylucid.ephemeral.patterns.signalreactionshowcase

Quick Start

using Mostlylucid.Ephemeral.Patterns.SignalReactionShowcase;

var result = await SignalReactionShowcase.RunAsync(itemCount: 100);

Console.WriteLine($"Dispatched: {result.DispatchedHits}");
Console.WriteLine($"Polled: {result.PolledHits}");
Console.WriteLine($"Total signals: {result.Signals.Count}");

All Options

SignalReactionShowcase.RunAsync(
    // Number of work items to process
    // Default: 8
    itemCount: 8,

    // Optional cancellation token
    ct: cancellationToken
)

API Reference

// Run the showcase demo
Task<Result> SignalReactionShowcase.RunAsync(
    int itemCount = 8,
    CancellationToken ct = default);

// Result record
public sealed record Result(
    int DispatchedHits,      // Signals handled by dispatcher
    int PolledHits,          // Signals found by polling
    IReadOnlyList<string> Signals);  // All signal names

Key Concepts

1. Signal Emission

Work items raise signals synchronously (fast, non-blocking):

var signal = new SignalEvent($"stage.start:{item}", id, null, DateTimeOffset.UtcNow);
sink.Raise(signal);

2. Async Dispatch

SignalDispatcher processes signals in background:

dispatcher.Register("stage.done:*", async evt =>
{
    // Handle signal asynchronously
    await LogCompletionAsync(evt);
});

dispatcher.Dispatch(signal);

3. Sink Polling

Query signals by pattern after work completes:

var completed = sink.Sense(s => s.Signal.StartsWith("stage.done"));

How It Works

Work Item Processing:
┌─────────────────────────────────────────────────────────────┐
│ [start] ─> emit "stage.start:N" ─> [work] ─> emit "stage.done:N" │
└─────────────────────────────────────────────────────────────┘
                    │                              │
                    ▼                              ▼
              SignalSink                    SignalDispatcher
              (for polling)                 (async handlers)

Example: Custom Signal Handling

var sink = new SignalSink(maxCapacity: 200, maxAge: TimeSpan.FromSeconds(10));
var dispatched = 0;

await using var dispatcher = new SignalDispatcher(
    new EphemeralOptions { MaxTrackedOperations = 200, MaxConcurrency = 4 });

dispatcher.Register("stage.done:*", evt =>
{
    Interlocked.Increment(ref dispatched);
    Console.WriteLine($"Completed: {evt.Signal}");
    return Task.CompletedTask;
});

await using var coordinator = new EphemeralWorkCoordinator<int>(
    async (item, ct) =>
    {
        var start = new SignalEvent($"stage.start:{item}", item, null, DateTimeOffset.UtcNow);
        sink.Raise(start);
        dispatcher.Dispatch(start);

        await Task.Delay(10, ct);  // Simulate work

        var done = new SignalEvent($"stage.done:{item}", item, null, DateTimeOffset.UtcNow);
        sink.Raise(done);
        dispatcher.Dispatch(done);
    },
    new EphemeralOptions { MaxConcurrency = 8 });

for (int i = 0; i < 50; i++)
    await coordinator.EnqueueAsync(i);

coordinator.Complete();
await coordinator.DrainAsync();
await dispatcher.FlushAsync();

// Poll results
var startSignals = sink.Sense(s => s.Signal.StartsWith("stage.start")).Count;
var doneSignals = sink.Sense(s => s.Signal.StartsWith("stage.done")).Count;

Console.WriteLine($"Started: {startSignals}, Done: {doneSignals}, Dispatched: {dispatched}");

Example: Comparing Dispatch vs Polling

var result = await SignalReactionShowcase.RunAsync(itemCount: 100);

// DispatchedHits: Real-time processing via SignalDispatcher
// PolledHits: Batch query via SignalSink.Sense()

// Both should equal itemCount when all work completes
Assert.Equal(result.DispatchedHits, result.PolledHits);
Assert.Equal(100, result.DispatchedHits);

Related Packages

License

Unlicense (public domain)