Back to "найбільш зрозуміле.невичерпнеM SK1повне ; дивна послідовна модель системи в LRU-каші."

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

mostlylucid-ephemeral

найбільш зрозуміле.невичерпнеM SK1повне ; дивна послідовна модель системи в LRU-каші.

Sunday, 14 December 2025

Це була моя одержимість протягом минулого тижня. попередні частини і що призвело до цьогоЩо якби LRU був контекстом виконання.'. Тепер це ' це набір пакетів Nuget МSK2 , що охоплюють більшість основних одночасних шаблонів виконання \ ( \ в TINY \ МSK4 \ лінійних пакетах ). \ Получите дивовижні адаптивні здібності за допомогою SIMPLE синтаксису

Найти джерело тут: httpsMSC1github.comM SK3scottgalMST4mostlylucidMSL5atomsMSR6blobMsl7mainM SL8Mostly LucidМSL9ephemeralMСЛ10srcM SR11mostslylucideMLS12efemeral M SSL13complete

Прайор

Прочитайте попередній розділ про сигнали для певного розуміння цього'застосункиM SK1 Тут представлено Readme.md з найбільш зрозумілихMSC3необновлюванихМSK4довершеного пакету, який містить як ядро найбільш зрозмілих.незновлювні пакети, так і всі шаблони , MST7атомиM ST8 \MST9координатори і т.д.Mst10 пакетів в одному зручному DLLM st11

Коріння

Або використати ядро більш-менш яскравий.нефемеральний TINY (літературно МSK1 класи МSK2 що дає вам всю сирову функцію .

Attributes & DI

Або якщо ви хочете, щоб повний атрибут базувався на асинкному маршруті з простим [EphemeralJob] та послуги.ДодаватиКоординатор` запис стилю використовує пакет mostlylucid.ephemeral.attributes.

Це, скоріш за все, тема мого блогу, яка рухається вперед.

Найяскравіший.ЕфемеральнийM SK1Довершений

NuGet

Meta-пакет, який відноситься до всіх Mostlylucid.Ефемерних пакетів - обмежена асинхічна виконання з сигналом -орієнтована координація МSK2

dotnet add package mostlylucid.ephemeral.complete

Це мета-пакедж, який містить всі ядраM SK1 атоми , і шаблонні пакети в якості zależności. Ви можете легко змішати це з індивідуальні відмітки пакетів - NuGet розв 'язує проблему в одній версії без зіткнення Namespaceсів

Що нового в 2.0

Зрушення змін

Модель abonamentу SignalSink змінилася:

// OLD (1.x) - Event-based
sink.SignalRaised += handler;

// NEW (2.0) - Lock-free Subscribe() returning IDisposable
using var sub = sink.Subscribe(handler);

Полний пакет тепер - мета-пакет:

  • До того ж, всі вихідні коди були компільовані в один DLL. (ризиковані зіткнення namespacesM SK1
  • Тепер відносить окремі пакети до залежності
  • Безпека для змішування з окремими описами пакетів у тому ж рішення

Нові характеристики

  • Система ledger для виявлення (Mostlylucid.Ephemeral.Atoms.Taxonomy.Ledger)

    • DetectionLedger - Об 'єднує вклади детекторів з сигмоїдною агрегацією
    • DetectionContribution - Фабрикові методиM SK1 Bot(), Human(), Info(), VerifiedBot(), VerifiedGoodBot()
    • CategoryScore.TotalWeight нерухомість ( переименована з Weight)
  • Прослідження поширення сигналу - Виявление циклу та обмеження глибини сигналів

  • Ссылка на джерело - Відладка в вихідних умовах бібліотеки прямо з вашого IDE

Подивіться Docs/Taxonomy.md для спільного словника навколо субстрату, лінзи, атомиM SK2 молекулиМSK3 і ескалація.


Стосунок


Швидкий старт

using Mostlylucid.Ephemeral;

// Long-lived work coordinator
await using var coordinator = new EphemeralWorkCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8 });

await coordinator.EnqueueAsync(new WorkItem("data"));

// One-shot parallel processing
await items.EphemeralForEachAsync(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8 });

Регистрация послуг

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8, MaxTrackedOperations = 128 });

builder.Services.AddEphemeralSignalJobRunner<LogWatcherJobs>();

var app = builder.Build();
app.MapPost("/", async ([FromServices] IEphemeralCoordinatorFactory<WorkItem> factory, WorkItem item) =>
{
    var coordinator = factory.CreateCoordinator();
    await coordinator.EnqueueAsync(item);
    return Results.Accepted();
});

await app.RunAsync();

Знайомий services.AddCoordinator<T>() помічників та AddEphemeralSignalJobRunner<T>() підтримувати registraciю послуг стисло кажучи, дозволити Ді володіти раковиною / бігачем МSK2 і зробити нову відповідальність

Attribute-задібні роботи

mostlylucid.ephemeral.complete пакети mostlylucid.ephemeral.attributes, так що атрибути труб є частиною ядро поверхня. ставтеся до бігача як до першого споживача сигналу Class 1 : оздоблені методи об 'єднуються в одну і ту ж камеру і кожен атрибут може заявити Priority, робота MaxConcurrency, Lane, Key джерело, сигнал викиди, pinM SK1expire overrides , and retries.

Клініці атрибуту:

  • Заказуванняเลน &: Використовувати Priority, MaxConcurrency, і Lane зберігати роботу в детерміністичній послідовності, поки гарячі шляхи залишатися окремо.
  • Навігання &: OperationKey, KeyFromSignal, KeyFromPayload, і [KeySource] допомогти вам працювати в групі значні ключі для журналізації, справедливого плануванняM SK1 та діагностики.
  • Pinning & повторює: Pin, ExpireAfterMs, AwaitSignals, MaxRetries, і RetryDelayMs дозволити операторам розширити їх видимість, введення ворот, доки не прийде залежність , і не зцілиться відхиленням, випромінюючи сигнали невдачі МSK2
  • Сигнальна хореографія: Emit EmitOnStart, EmitOnComplete, і EmitOnFailure для сигналізації наступних етапів, журнал годинники, або інші координатори без ручного підключенняM SK1
var sink = new SignalSink();
await using var runner = new EphemeralSignalJobRunner(sink, new[] { new LogWatcherJobs(sink) });

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
    builder.AddProvider(new SignalLoggerProvider(new TypedSignalSink<SignalLogPayload>(sink)));
});

var logger = loggerFactory.CreateLogger("orders");
logger.LogError(new EventId(1001, "DbFailure"), "Order store failed");

// Later tasks or other services can also raise watcher-friendly signals directly:
sink.Raise("log.error.orders.dbfailure", key: "orders");
public sealed class LogWatcherJobs
{
    private readonly SignalSink _sink;

    public LogWatcherJobs(SignalSink sink) => _sink = sink;

    [EphemeralJob("log.error.*", Priority = 1, MaxConcurrency = 2, Lane = "hot:4", EmitOnComplete = new[] { "incident.created" })]
    public Task EscalateAsync(SignalEvent signal)
    {
        Console.WriteLine($"escalating {signal.Signal} for {signal.Key}");
        _sink.Raise("incident.created", key: signal.Key);
        return Task.CompletedTask;
    }

    [EphemeralJob("incident.created", EmitOnStart = new[] { "incident.monitor.start" })]
    public Task NotifyAsync(SignalEvent signal)
    {
        Console.WriteLine($"notified incident for {signal.Key}");
        return Task.CompletedTask;
    }
}

Ця атлетка сидить на старті і реагує, коли log.error.* або будь-який випущений сигнал потрапляє в раковину. Attribute обладначі можуть читати ключі від сигналів/заряди payloads, pin до зворотнього потоку, доки не закінчується випромінювання сигналів розміщування на лінії для замовлення. Для DIM SK1перві встановлення services.AddEphemeralSignalJobRunner<T>() ( або масштабований варіант) так, що бігač і сховище керуються контейнеромM SK1

[НевичерпніРаботи(Звіснопосадка M SK1 МSK2 стадія", По замовчуванню публічний склеєний клас StageJobs { [Невичерпна робота(" найчастіша ", EmitOnComplete = нова[МSK0 МSK1 " стадія . найкращий мSK4 завершений M" МСК6 публічна задача IngestAsync(SignalEvent evt) M SK2 Консола .OutMSC4WriteLineAsynCMska5evtM Ska6SignaleMска7

[EphemeralJob("finalize")]
public Task FinalizeAsync(SignalEvent evt) => Console.Out.WriteLineAsync("final stage");

}

var StageSink = новий SignalSinkM SK1 чекати, використовуючи var stageRunner = новий EphemeralSignalJobRunnerM SK1stageSink, новий[МSK0 { нові etaпні робочі місця StageSink.Raise ("stageM SK2ingest");

Pin-важкі роботи можуть залежати від ResponsibilitySignalManager.PinUntilQueried (លំនាំដើម responsibility.ack.*) до зберігати їхні операції видимими, доки нижній читач не дістається вантажу,, поки OperationEchoMaker/ OperationEchoAtom продовжувати кінцевий потік сигналу, так що аудитори чи молекули можуть все ще “тастиM SK1 останній стан навіть після атом помре.

Заплановані завдання

mostlylucid.ephemeral.complete також містить mostlylucid.ephemeral.atoms.scheduledtasks. Визначати cron або JSON календарі через ScheduledTaskDefinition (кронM SK1 сигнал, опціональний key, payload, description, timeZone, format, runOnStartup, і т.д. ScheduledTasksAtom продовжувати тривалий цикл роботи DurableTaskAtom. Кожна запланована робота підвищує конфігурований сигнал у вікні координатора, таким чином він успадкує зачіпленняM SK1 журналування, і семантику відповідальності тоді як ваші молекули чи атрибути трубок реагують на випущену хвилю сигналу.

Кожного DurableTask веде календар Name, Signal, опціонально Key, навіть надрукований Payload, і Description, так слухачі зворотнього потоку негайно знають, яка робота була проведена і які метаданні (імені файлівM SK1 URLs, і т.д. DurableTaskAtom.WaitForIdleAsync() коли ви просто хочете чекати, щоб теперішній вибух запланованої роботи закінчився без закінчення атому, зберігаючи регулятор готовий до наступного cron tick.

Записywanie сигналів &

mostlylucid.ephemeral.logging дзеркала Microsoft.ПоширенняM SK1Вход в сигнали і навпаки. Почнемо з прив 'язування SignalLoggerProvider до вашої фабрики логера, так що події журналу піднімаються log.* сигнали, і Hak SignalToLoggerAdapter якщо ви хочете, щоб сигнали повертались до стандартної логової трубки.

var sink = new SignalSink();
var typedSink = new TypedSignalSink<SignalLogPayload>(sink);

using var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
    builder.AddProvider(new SignalLoggerProvider(typedSink));
});

using var watcher = new EphemeralSignalJobRunner(sink, new[] { new LogWatcherJobs(sink) });

var logger = loggerFactory.CreateLogger("orders");
logger.LogError(new EventId(1001, "DbFailure"), "Order store failed");
public sealed class LogWatcherJobs
{
    private readonly SignalSink _sink;

    public LogWatcherJobs(SignalSink sink) => _sink = sink;

    [EphemeralJob("log.error.*")]
    public Task EscalateAsync(SignalEvent signal)
    {
        _sink.Raise("incident.created", key: signal.Key);
        return Task.CompletedTask;
    }

    [EphemeralJob("incident.created")]
    public Task NotifyAsync(SignalEvent signal)
    {
        Console.WriteLine($"Incident for {signal.Key}");
        return Task.CompletedTask;
    }
}

Використовувати SignalToLoggerAdapter для відображання результатів сигналів назад у стандартні журнали, щоб ваш стег спостережень бачив обидві боки мосту.


Центральні координатори

Пакет: більш-менш яскравий.нефемеральний

Ефемеральний координатор роботи<Т>

Довгий-жива робоча черга з обмеженим співпадінням і видимим вікном

await using var coordinator = new EphemeralWorkCoordinator<Request>(
    async (req, ct) => await HandleAsync(req, ct),
    new EphemeralOptions
    {
        MaxConcurrency = 8,
        MaxTrackedOperations = 200,
        MaxOperationLifetime = TimeSpan.FromMinutes(5)
    });

await coordinator.EnqueueAsync(request);

// Observe state
var running = coordinator.GetRunning();
var failed = coordinator.GetFailed();
var pending = coordinator.PendingCount;

// Graceful shutdown
coordinator.Complete();
await coordinator.DrainAsync();

Ефемеральний координатор роботи з ключем<TKey, T>

Per-key sequential processing - items with same key processed in orderM SK2

await using var coordinator = new EphemeralKeyedWorkCoordinator<Order, string>(
    order => order.CustomerId,  // Key selector
    async (order, ct) => await ProcessOrder(order, ct),
    new EphemeralOptions
    {
        MaxConcurrency = 16,      // Total parallel
        MaxConcurrencyPerKey = 1  // Sequential per customer
    });

await coordinator.EnqueueAsync(order);

Ефемеральний координатор результату<Результат>

Результати захоплення від асинхічних операцій.

await using var coordinator = new EphemeralResultCoordinator<Request, Response>(
    async (req, ct) => await FetchAsync(req, ct),
    new EphemeralOptions { MaxConcurrency = 4 });

var id = await coordinator.EnqueueAsync(request);
var snapshot = await coordinator.WaitForResult(id);
if (snapshot.HasResult)
    Console.WriteLine(snapshot.Result);

Рабочий координатор пріоритетів<Т>

Багато priorytetних смуг з конфігурованим співпадінням на each lane.

var coordinator = new PriorityWorkCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new PriorityWorkCoordinatorOptions<WorkItem>(
        Lanes: new[] { new PriorityLane("high"), new PriorityLane("normal"), new PriorityLane("low") }
    ));

await coordinator.EnqueueAsync(item, "high");

Konfiguracja (ЕфемерніOptionsM SK1

new EphemeralOptions
{
    // Concurrency
    MaxConcurrency = 8,                    // Max parallel operations
    MaxConcurrencyPerKey = 1,              // For keyed coordinators
    EnableDynamicConcurrency = false,      // Allow runtime adjustment

    // Memory
    MaxTrackedOperations = 200,            // Window size (LRU eviction)
    MaxOperationLifetime = TimeSpan.FromMinutes(5),

    // Fair scheduling (keyed only)
    EnableFairScheduling = false,          // Prevent hot key starvation
    FairSchedulingThreshold = 10,

    // Signals
    Signals = sharedSink,                  // Shared signal sink
    OnSignal = evt => { },                 // Sync callback
    OnSignalAsync = async (evt, ct) => { }, // Async callback
    CancelOnSignals = new HashSet<string> { "circuit-open" },
    DeferOnSignals = new HashSet<string> { "backpressure" },
    DeferCheckInterval = TimeSpan.FromMilliseconds(100),
    MaxDeferAttempts = 50,

    // Signal handler limits
    MaxConcurrentSignalHandlers = 4,
    MaxQueuedSignals = 1000
}

Сигнал

Операції emitують сигнали для креслення-видатливості розрізуM SK1

// Query signals
bool hasError = coordinator.HasSignal("error");
int count = coordinator.CountSignals("error");
var errors = coordinator.GetSignalsByPattern("error.*");

// Shared sink across coordinators
var sink = new SignalSink();
var c1 = new EphemeralWorkCoordinator<A>(body, new EphemeralOptions { Signals = sink });
var c2 = new EphemeralWorkCoordinator<B>(body, new EphemeralOptions { Signals = sink });
sink.Raise("system.busy");  // Both see it

Сигнали відповідальності & Завершення

Потрібно, щоб результати були помітні досить довго для споживачів на зворотньому шляху? ResponsibilitySignalManager дозволяє вам закріпити операцій, доки сигнал ack не прийде (поганий шаблон responsibility.ack.* з ключем=operationId). Додайте опціонально description щоб операція могла описати свою відповідальність, і визначити maxPinDuration граційно себе-розбірливо, якщо споживач ніколи не з 'явиться

var manager = new ResponsibilitySignalManager(coordinator, sink, maxPinDuration: TimeSpan.FromMinutes(5));
if (manager.PinUntilQueried(operationId, "file.ready", ackKey: fileId, description: "Awaiting fetch"))
{
    sink.Raise("file.ready", key: fileId);
}
// Consumer acknowledges the work
sink.Raise("file.ready.ack", key: fileId);
using Mostlylucid.Ephemeral.Patterns;

var notes = new LastWordsNoteAtom(async note => await noteRepository.SaveAsync(note));
coordinator.OperationFinalized += snapshot =>
{
    var note = new LastWordsNote(
        OperationId: snapshot.OperationId,
        Key: snapshot.Key,
        Signal: snapshot.Signals?.FirstOrDefault(),
        Timestamp: DateTimeOffset.UtcNow);

    _ = notes.EnqueueAsync(note);
};

LastWordsNote залишається крихітним (ID оператора МSK1 ключ МSK2 сигнал , тайм-станп \ ), так, що ви можете записувати будь-який мінімальний стан, який вам до вподоби перед тим, як операція збирається.

Координатор також зберігає короткий -живий ехо кінцевих сигналів (, що доступний через EnableOperationEcho), що ви можете перевіряти з GetEchoes() коли вам потрібно відтворити зрізану хвилю сигналу, не зберігаючи повної взаємодії навколо.

var recentErrors = coordinator.GetEchoes(pattern: "error.*")
    .Where(e => e.Timestamp > DateTimeOffset.UtcNow - TimeSpan.FromMinutes(1))
    .ToList();

if (recentErrors.Any())
    logger.LogWarning("Trimmed errors: {Count}", recentErrors.Count);

OperationEchoRetention і OperationEchoCapacity дозвольте балансувати, скільки ехо ви зберігаєте і скільки вони тривають так, що ви можете відтворити “ останні слова ” досить довго для поверхневого діагностування

Менеджер автоматично відчиняє ручку, коли з 'являється гума,, але ви можете зателефонувати CompleteResponsibility(operationId) щоб закінчити відповідальність на ранній стадії (eM SK1g., на відпустках ). Операції досі зростають OperationFinalized коли вікно вирізає їх, то або зареєструйтесь, якщо ви хочете видалити кінцевий сигнал


Атоми (Збудові блокиM SK1

Фиксований Атом

**Пакет: ** більш-менш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2встановлений

Фиксований робочий фонд з статистикою. Minimal API wrapper around EphemeralWorkCoordinator.

using Mostlylucid.Ephemeral.Atoms.FixedWork;

await using var atom = new FixedWorkAtom<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    maxConcurrency: 4,
    maxTracked: 200);

await atom.EnqueueAsync(item);

// Get stats
var (pending, active, completed, failed) = atom.Stats();
Console.WriteLine($"Completed: {completed}, Failed: {failed}");

// Get recent operations
var snapshot = atom.Snapshot();

// Graceful shutdown
await atom.DrainAsync();

KeyedSequentialAtom

**Пакет: ** найбільш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2відмінний

Per-последовательне оброблення ключів з опціональною справедливою програмою

using Mostlylucid.Ephemeral.Atoms.KeyedSequential;

await using var atom = new KeyedSequentialAtom<Order, string>(
    keySelector: order => order.CustomerId,
    body: async (order, ct) => await ProcessOrder(order, ct),
    maxConcurrency: 16,
    perKeyConcurrency: 1,           // Sequential per key
    enableFairScheduling: true);    // Prevent hot key starvation

await atom.EnqueueAsync(order1);  // Customer A
await atom.EnqueueAsync(order2);  // Customer A - waits for order1
await atom.EnqueueAsync(order3);  // Customer B - parallel with A

var (pending, active, completed, failed) = atom.Stats();
await atom.DrainAsync();

Сигнальний Атом

**Пакет: ** найбільш яскраво зрозуміле.нефемеричнеM SK1атомні.signalaware

Зупинити або anulувати прийом на основі сигналів довкілля.

using Mostlylucid.Ephemeral.Atoms.SignalAware;

var sink = new SignalSink();

await using var atom = new SignalAwareAtom<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    cancelOn: new HashSet<string> { "shutdown", "circuit-open" },
    deferOn: new HashSet<string> { "backpressure.*" },
    deferInterval: TimeSpan.FromMilliseconds(100),
    maxDeferAttempts: 50,
    signals: sink,
    maxConcurrency: 8);

// Enqueue work
await atom.EnqueueAsync(item);

// Raise ambient signals
atom.Raise("backpressure.downstream");  // New items defer
sink.Raise("shutdown");                  // New items rejected (returns -1)

await atom.DrainAsync();

Атом-заряд

**Пакет: ** більш-менш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2перебор

Збирати товари в партії за розміром або відрізком часу.

using Mostlylucid.Ephemeral.Atoms.Batching;

await using var atom = new BatchingAtom<LogEntry>(
    onBatch: async (batch, ct) =>
    {
        Console.WriteLine($"Flushing {batch.Count} entries");
        await FlushToDatabase(batch, ct);
    },
    maxBatchSize: 100,
    flushInterval: TimeSpan.FromSeconds(5));

// Items are batched automatically
atom.Enqueue(new LogEntry("User logged in"));
atom.Enqueue(new LogEntry("Request received"));
// ... batch flushes when full OR after 5 seconds

Знову спробувати

Пакет: найбільш яскраво зрозумілий.нефемеральнийM SK1атомиМSK2ретри

Екпоненційний зворотній відворот ретри упаковувач.

using Mostlylucid.Ephemeral.Atoms.Retry;

await using var atom = new RetryAtom<ApiRequest>(
    async (req, ct) => await CallExternalApi(req, ct),
    maxAttempts: 3,
    backoff: attempt => TimeSpan.FromMilliseconds(100 * Math.Pow(2, attempt)),
    maxConcurrency: 4);

// Automatically retries on failure with exponential backoff
// Attempt 1: immediate
// Attempt 2: 200ms delay
// Attempt 3: 400ms delay
await atom.EnqueueAsync(new ApiRequest("https://api.example.com"));

await atom.DrainAsync();

Атоми зберігання даних

Пакет: найбільш яскраві дані

Поширена конфігурація для зберігання атомів (DataStorageConfig, IDataStorageAtom<TKey, TValue>) плюс сигнал звичаї, що приводять файли, SQLite , та адаптери PostgreSQL.

using Mostlylucid.Ephemeral.Atoms.Data;
using Mostlylucid.Ephemeral.Atoms.Data.File;

var sink = new SignalSink();
var config = new DataStorageConfig
{
    DatabaseName = "orders",
    SignalPrefix = "save.data",
    LoadSignalPrefix = "load.data",
    DeleteSignalPrefix = "delete.data",
    MaxConcurrency = 1
};

await using var storage = new FileDataStorageAtom<string, Order>(sink, config, "./orders");

storage.EnqueueSave("order-123", new Order { Id = "order-123", Total = 42.00m });
var loaded = await storage.LoadAsync("order-123");

Використовуйте те ж саме DataStorageConfig з Mostlylucid.Ephemeral.Atoms.Data.Sqlite або Mostlylucid.Ephemeral.Atoms.Data.Postgres implements for durable, signal-driven persistence powered by SQLite saved.data.{dbname} сигнали, щоб розпочати роботу вниз, поки load.data.{dbname} спричиняє накопичення hydratу.


Маршрутизатор молекул & AtomTrigger

**Пакет: ** найбільш яскраві молекули

Плани, створені MoleculeBlueprintBuilder дозвольте визначити атоми повідомлення), яке має запускатися, коли order.placed приходить. MoleculeRunner слухає триггер шаблон, створює спільний MoleculeContext, і запускає кожен крок, поки ви подписуєтесь на запуск AtomTrigger коли один атом, сигнал ', повинен запускати інший координатор або молекулу

var sink = new SignalSink();
var blueprint = new MoleculeBlueprintBuilder("order", "order.placed")
    .AddAtom(async (ctx, ct) => await paymentCoordinator.EnqueueAsync(ctx.TriggerSignal.Key!, ct))
    .AddAtom(async (ctx, ct) =>
    {
        ctx.Raise("order.payment.complete", ctx.TriggerSignal.Key);
        await inventoryCoordinator.EnqueueAsync(ctx.TriggerSignal.Key!, ct);
    })
    .Build();

await using var runner = new MoleculeRunner(sink, new[] { blueprint }, serviceProvider);
using var trigger = new AtomTrigger(sink, "order.payment.complete", async (signal, ct) =>
{
    await notificationCoordinator.EnqueueAsync(signal.Key!, ct);
});

sink.Raise("order.placed", key: "order-42");

Молекульні кроки можуть викликати додаткові сигнали (ctx.Raise("order.shipping.start")) так, що решта системи сприймає паличка.


SlidingCacheAtom

**Пакет: ** більш-менш яскравий.нефемеральнийM SK1атомиМSK2похибка

Кэш з знижуванням терміну закінчування -, доступ до результату, відтворює його TTLM SK1

using Mostlylucid.Ephemeral.Atoms.SlidingCache;

await using var cache = new SlidingCacheAtom<string, UserProfile>(
    async (userId, ct) => await LoadUserProfileAsync(userId, ct),
    slidingExpiration: TimeSpan.FromMinutes(5),
    absoluteExpiration: TimeSpan.FromHours(1),
    maxSize: 1000);

// First call: computes and caches
var profile = await cache.GetOrComputeAsync("user-123");

// Second call within 5 minutes: returns cached, resets TTL
var cached = await cache.GetOrComputeAsync("user-123");

// Try get without computation (still resets TTL on hit)
if (cache.TryGet("user-123", out var profile))
    Console.WriteLine(profile.Name);

// Get stats
var stats = cache.GetStats();
Console.WriteLine($"Entries: {stats.TotalEntries}, Hot: {stats.HotEntries}");

Волатильна операція Атом

**Пакет: ** переважно яскраві.нефемерніM SK1атомиМSK2вивільні

Викидати операції, коли вони видають сигнал вбивства , так що вікно залишається легким навіть під дуже високою пропускною здатністю. атом слухає налаштування шаблону (default kill.*) на спільному SignalSinkЗапроси , IOperationEvictor.TryKill з зафіксованою операцією ID, і все ж дозволяє координатору реагувати на його ехоM SK1 підключення до входу зникає.

var sink = new SignalSink();
await using var coordinator = new EphemeralWorkCoordinator<JobItem>(
    async (job, ct) => await QuickProcessAsync(job, ct),
    new EphemeralOptions
    {
        Signals = sink,
        EnableOperationEcho = true,
        OperationEchoRetention = TimeSpan.FromSeconds(30)
    });

using var volatileAtom = new VolatileOperationAtom(sink, coordinator);

// inside the job: emitter.Emit("kill.job");

Порівняйте атом з OperationEchoMaker/OperationEchoAtom так надруковано *.echo.* сигнали переживають вбивство як крихітний TTL’d запис.

Ефемеральний LruCache

Пакет: ядро (mostlylucid.ephemeral) — self МSK2 оптимізувати кэш з рухомим TTL на кожному ударі і розширеним ТТЛ для гарячі ключі.

using Mostlylucid.Ephemeral;

var cache = new EphemeralLruCache<string, Widget>(new EphemeralLruCacheOptions
{
    DefaultTtl = TimeSpan.FromMinutes(5),
    HotKeyExtension = TimeSpan.FromMinutes(30),
    HotAccessThreshold = 3,
    MaxSize = 10_000,
    SampleRate = 5 // emit 1 in 5 signals
});

var widget = await cache.GetOrAddAsync("widget:42", async key =>
{
    var data = await LoadWidgetAsync(key);
    return data!;
});

// Stats and signals to see how the cache self-focuses on hot keys
var stats = cache.GetStats();              // hot/expired counts, size
var signals = cache.GetSignals("cache.*"); // cache.hot/evict/miss/hit

Напис: MemoryCache може бути конфігурований для скольження вичерпування,, але він ніколи не випускає гарячихM SK1холодних сигналів або розширює TTL для гарячих ключів. EphemeralLruCache є автоoptimізуючою початковою функцією в ядром пакету ( і SqliteSingleWriter) коли ви хочете, щоб кэш зосередився на активному робочому наборі.

Атом розміру вікна

**Пакет: ** найбільш яскраво зрозуміле.нефемеричнеM SK1атомніМSK2windowsize

Атом слухає window.size.* або window.time.* накази, закріплює запрошену пропускну спроможність SignalSink.UpdateWindowSize тож ви можете розширити або зменшити розділене вікно від іншого координатора чи спостерігача сигналів.

var sink = new SignalSink(maxCapacity: 250);
await using var atom = new WindowSizeAtom(sink);

sink.Raise("window.size.decrease:50");
sink.Raise("window.time.set:00:02:00");

Атоми таксономії

Пакети:

Геніальні види атомів, які підпорядковуються таксономії (сенсор МSK1 экстрактор МSK2 вміщувач , ретривер рендерер, координаторM SK1 зворотній зв 'язок, охоронаMSC3 Кожен атом випускає надрукований сигнал при завершенні і несає AtomContract для детермінізм та метадані про тривалість. Установити конкретний атомний пакет, який вам потрібен M SK1у прикладі, що зображено, Використовувати MultiTaxonomyAtom з базового пакету, коли вам потрібно об 'єднати кілька видів в один контракт.

using Mostlylucid.Ephemeral;
using Mostlylucid.Ephemeral.Atoms.Taxonomy;

public sealed record Proposal(string Text, double Confidence);

var sink = new SignalSink();
var proposer = new ProposerAtom<string, Proposal>(
    sink,
    async (prompt, ct) => new Proposal($"Echo: {prompt}", 0.42),
    outputSignal: "proposal.created",
    keySelector: prompt => prompt);

await proposer.EnqueueAsync("hello");

ЕскалаторАтом

**Пакет: ** більш-менш яскраво зрозумілий.фемемернийM SK1атоми.ескалатор

Пропонувати встромлені, efeмерні сигнали у міцні раковиниM SK1 ЕскалаторАтоми - це найкращий спосіб короткі-живі координаториM SK1

using Mostlylucid.Ephemeral;
using Mostlylucid.Ephemeral.Atoms.Data.File;
using Mostlylucid.Ephemeral.Atoms.Escalator;

public sealed record EscalationPayload(string Kind, string? EvidenceId, double Confidence);

var sink = new SignalSink();
var typed = new TypedSignalSink<EscalationPayload>(sink);

await using var storage = new FileDataStorageAtom<string, EscalationPayload>(
    sink,
    new FileDataStorageConfig { DatabaseName = "signals" });

Func<SignalEvent<EscalationPayload>, CancellationToken, Task> audit = (evt, ct) =>
{
    Console.WriteLine($"audit: {evt.Signal} {evt.Key}");
    return Task.CompletedTask;
};

var targets = new[]
{
    new EscalationTarget<EscalationPayload>(
        "store",
        (evt, ct) => storage.SaveAsync(evt.Key ?? evt.OperationId.ToString(), evt.Payload, ct)),
    new EscalationTarget<EscalationPayload>("audit", audit)
};

await using var escalator = new EscalatorAtom<EscalationPayload>(
    sink,
    typed,
    targets,
    new EscalatorAtomOptions<EscalationPayload>
    {
        EscalateSignalPattern = "escalate.*",
        EmitOnSuccess = "escalation.persisted",
        EmitOnFailure = "escalation.failed"
    });

typed.Raise("escalate.signal", new EscalationPayload("risk", "file-42", 0.81), key: "order-123");

Керівник ехо

Пакет: більш-менш яскраво зрозумілий.фемемернийM SK1атомиМSK2ехо

Зафіксувати задрукований “ останні слова ”, що операція випромінює перед тим, як її зрізатиM SK2 Атом зберігає обмежене вікно сигналу вантажі (сбіг ActivationSignalPattern / CaptureSignalPattern) і коли OperationFinalized спалахи, які він виробляє OperationEchoEntry<TPayload> записи, які можна зберігати за допомогою OperationEchoAtom<TPayload>.

var sink = new SignalSink();
var typedSink = new TypedSignalSink<EchoPayload>(sink);
var echoAtom = new OperationEchoAtom<EchoPayload>(async echo => await repository.AppendAsync(echo));

await using var coordinator = new EphemeralWorkCoordinator<JobItem>(ProcessAsync);
using var maker = coordinator.EnableOperationEchoing(
    typedSink,
    echoAtom,
    new OperationEchoMakerOptions<EchoPayload>
    {
        ActivationSignalPattern = "echo.capture",
        CaptureSignalPattern = "echo.*",
        MaxTrackedOperations = 128
    });

typedSink.Raise("echo.capture", new EchoPayload("order-1", "archived"), key: "order-1");

Роботи з атрибутами просто піднімають надрукований сигнал в будь-якому стані, який вони вважають критичним,, і творець зберігає робочий набір обмежені, поки ви продовжуєте ехо.


Patterns (Ready -toM SK2Use)

СигналBasedCircuitBreaker

**Пакет: ** переважно яскраві

Стаціонарний блокатор, що використовує вікно історії сигналу.

using Mostlylucid.Ephemeral.Patterns.CircuitBreaker;

var breaker = new SignalBasedCircuitBreaker(
    failureSignal: "api.failure",
    threshold: 5,
    windowSize: TimeSpan.FromSeconds(30));

// Check before making calls
if (breaker.IsOpen(coordinator))
{
    var retryAfter = breaker.GetTimeUntilClose(coordinator);
    throw new CircuitOpenException("Too many failures", retryAfter);
}

// Pattern matching variant
if (breaker.IsOpenMatching(coordinator, "error.*"))
    throw new CircuitOpenException("Error pattern detected");

// Get current failure count
int failures = breaker.GetFailureCount(coordinator);

Сигнал керований зворотним тиском

**Пакет: ** переважно яскраві.нефемеральніM SK1patternи.задувний тиск

Менеджмент глибини черги з автоматичним відкладанням сигналів зворотнього тиску.

using Mostlylucid.Ephemeral.Patterns.Backpressure;

var sink = new SignalSink();

await using var coordinator = SignalDrivenBackpressure.Create<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    sink,
    maxConcurrency: 4);

// Enqueue work
await coordinator.EnqueueAsync(item);

// When downstream is slow
sink.Raise("backpressure.downstream");  // New work auto-defers

// When recovered
sink.Retract("backpressure.downstream"); // Work resumes

Контролований вентилятор

**Пакет: ** переважно яскраві patternи

Глобальна + на -похибка ключів для контрольованого паралелізмуM SK2

using Mostlylucid.Ephemeral.Patterns.ControlledFanOut;

await using var fanout = new ControlledFanOut<string, Request>(
    keySelector: req => req.TenantId,
    body: async (req, ct) => await ProcessAsync(req, ct),
    maxGlobalConcurrency: 100,  // Total parallel across all tenants
    perKeyConcurrency: 5);      // Max 5 parallel per tenant

// Items for same tenant processed with limit
await fanout.EnqueueAsync(requestA);  // Tenant1
await fanout.EnqueueAsync(requestB);  // Tenant1 - waits if 5 already running
await fanout.EnqueueAsync(requestC);  // Tenant2 - parallel with Tenant1

await fanout.DrainAsync();

АдаптивнаRateService

**Пакет: ** переважно яскраві patternи

Сигнал-limitering швидкості руху з автоматичним відхиленнямM SK1

using Mostlylucid.Ephemeral.Patterns.AdaptiveRate;

await using var service = new AdaptiveRateService<ApiRequest>(
    async (req, ct) => await CallApiAsync(req, ct),
    maxConcurrency: 8);

// Process with automatic rate limit handling
await service.ProcessAsync(request);

// When API returns 429, emit signal with retry-after
// Signal: "rate-limit:500ms"
// Service auto-parses and delays

Console.WriteLine($"Pending: {service.PendingCount}, Active: {service.ActiveCount}");

Демонстрація динамічної конкуренції

**Пакет: ** переважно яскраві.нефемеральніM SK1patternи.динамічнаконкуренція

Скалування співпадіння в часі запуску на основі сигналів завантаження.

using Mostlylucid.Ephemeral.Patterns.DynamicConcurrency;

var sink = new SignalSink();

await using var demo = new DynamicConcurrencyDemo<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    sink,
    minConcurrency: 2,
    maxConcurrency: 32,
    scaleUpPattern: "load.high",
    scaleDownPattern: "load.low");

await demo.EnqueueAsync(item);

// Concurrency adjusts automatically based on signals
sink.Raise("load.high");  // Concurrency doubles (up to max)
sink.Raise("load.low");   // Concurrency halves (down to min)

Console.WriteLine($"Current concurrency: {demo.CurrentMaxConcurrency}");

await demo.DrainAsync();

KeyedPriorityFanOut

**Пакет: ** найбільш зрозумілий.нефемеральнийM SK1patternи.похибка до відміну пріоритетів

Приорієнтовані смуги з пер-при zachowaні ключові замовленняM SK1

using Mostlylucid.Ephemeral.Patterns.KeyedPriorityFanOut;

await using var fanout = new KeyedPriorityFanOut<string, UserCommand>(
    keySelector: cmd => cmd.UserId,
    body: async (cmd, ct) => await HandleCommand(cmd, ct),
    maxConcurrency: 32,
    perKeyConcurrency: 1,  // Sequential per user
    maxPriorityDepth: 100);

// Normal lane
await fanout.EnqueueAsync(normalCommand);

// Priority lane - jumps the queue for that user
bool accepted = await fanout.EnqueuePriorityAsync(urgentCommand);

// Check lane depths
var counts = fanout.PendingCounts;
Console.WriteLine($"Priority: {counts.Priority}, Normal: {counts.Normal}");

await fanout.DrainAsync();

РеактивнийFanOutPipeline

**Пакет: ** переважно яскраві. efeмерніM SK1 шаблони.реактивний спалах

Двоє-ступенча трубка з автоматичним підштовхуваннямM SK1

using Mostlylucid.Ephemeral.Patterns.ReactiveFanOut;

await using var pipeline = new ReactiveFanOutPipeline<WorkItem>(
    stage2Work: async (item, ct) => await SlowProcessing(item, ct),
    preStageWork: async (item, ct) => await FastPreprocessing(item, ct),
    stage1MaxConcurrency: 8,
    stage1MinConcurrency: 1,
    stage2MaxConcurrency: 4,
    backpressureThreshold: 32,  // Throttle when stage2 has 32+ pending
    reliefThreshold: 8);        // Resume when stage2 drops below 8

await pipeline.EnqueueAsync(item);

// Stage1 auto-throttles when stage2 backs up
Console.WriteLine($"Stage1 concurrency: {pipeline.Stage1CurrentMaxConcurrency}");
Console.WriteLine($"Stage2 pending: {pipeline.Stage2Pending}");

await pipeline.DrainAsync();

Сигнал-аномалічний детектор

**Пакет: ** переважно яскраві.нефемеральніM SK1patternи.аномалічний детектор

Переміщення-викриття аномали вікнаM SK1

using Mostlylucid.Ephemeral.Patterns.AnomalyDetector;

var sink = new SignalSink();

var detector = new SignalAnomalyDetector(
    sink,
    pattern: "error.*",
    threshold: 5,
    window: TimeSpan.FromSeconds(10));

// Check for anomalies
if (detector.IsAnomalous())
{
    Console.WriteLine("Anomaly detected! Too many errors.");
    TriggerAlert();
}

// Get current match count
int errorCount = detector.GetMatchCount();
Console.WriteLine($"Errors in window: {errorCount}");

СигнальнийКоординованийЧитання

**Пакет: ** більш-менш яскраві.нефемеральніM SK1patterns.signalcoordinatedreads

Промовка читається під час оновлень без жорстких замків.

using Mostlylucid.Ephemeral.Patterns.SignalCoordinatedReads;

// Run demo: readers pause when update signal is present
var result = await SignalCoordinatedReads.RunAsync(
    readCount: 10,
    updateCount: 1);

Console.WriteLine($"Reads: {result.ReadsCompleted}, Updates: {result.UpdatesCompleted}");
Console.WriteLine($"Signals: {string.Join(", ", result.Signals)}");

// Manual implementation:
var sink = new SignalSink();

await using var readers = new EphemeralWorkCoordinator<Query>(
    body,
    new EphemeralOptions
    {
        DeferOnSignals = new HashSet<string> { "update.in-progress" },
        Signals = sink
    });

// Readers auto-defer when update is running
sink.Raise("update.in-progress");  // Readers wait
sink.Raise("update.done");         // Readers resume

СигналуванняHttpClient

**Пакет: ** більш-менш яскраво.нефемеральноM SK1patterns.signalinghttp

HTTP-клиент з сигналами прогресу.

using Mostlylucid.Ephemeral.Patterns.SignalingHttp;

var httpClient = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://example.com/large-file");

// Create an emitter from your coordinator
// (emitter is any ISignalEmitter - operations implement this)

byte[] data = await SignalingHttpClient.DownloadWithSignalsAsync(
    httpClient,
    request,
    emitter);

// Signals emitted during download:
// - stage.starting
// - progress:0
// - stage.request
// - stage.headers
// - stage.reading
// - progress:25, progress:50, progress:75, progress:100
// - stage.completed

Сенглог-навігатор

**Пакет: ** найбільш зрозуміле.нефемеричнеM SK1patterns.signallogwatcher

Дивіться на вікно сигналу для шаблонів та викидів дзвінків.

using Mostlylucid.Ephemeral.Patterns.SignalLogWatcher;

var sink = new SignalSink();

await using var watcher = new SignalLogWatcher(
    sink,
    onMatch: evt =>
    {
        Console.WriteLine($"Error detected: {evt.Signal} at {evt.Timestamp}");
        AlertOps(evt);
    },
    pattern: "error.*",
    pollInterval: TimeSpan.FromMilliseconds(200));

// Watcher runs in background, calling onMatch for each new error signal
sink.Raise("error.database");    // -> onMatch called
sink.Raise("error.timeout");     // -> onMatch called
sink.Raise("info.started");      // -> ignored (doesn't match pattern)

Оператор сигналів телеметрії

**Пакет: ** переважно яскраві.нефемеральніM SK1patтерини.телеметрія

OpenTelemetry/ Інтеграція з інтегією aplikacjiM SK1

using Mostlylucid.Ephemeral.Patterns.Telemetry;

// Use in-memory for testing, or implement ITelemetryClient for real telemetry
var telemetry = new InMemoryTelemetryClient();

await using var handler = new TelemetrySignalHandler(telemetry);

// Wire up to coordinator
var options = new EphemeralOptions
{
    OnSignal = signal => handler.OnSignal(signal)
};

// Signals are processed asynchronously
// - "error.*" signals -> TrackExceptionAsync
// - "perf.*" signals -> TrackMetricAsync
// - all signals -> TrackEventAsync

Console.WriteLine($"Queued: {handler.QueuedCount}");
Console.WriteLine($"Processed: {handler.ProcessedCount}");
Console.WriteLine($"Dropped: {handler.DroppedCount}");

// Check recorded events
var events = telemetry.GetEvents();

ДовгийWindowDemo

**Пакет: ** найбільш зрозуміле.нефемеричнеM SK1patterns.longwindowdemo

Демонструє велику конфігурацію вікна для слідів аудиту.

using Mostlylucid.Ephemeral.Patterns.LongWindowDemo;

// Configure coordinator with large tracking window
var options = new EphemeralOptions
{
    MaxTrackedOperations = 10000,
    MaxOperationLifetime = TimeSpan.FromHours(24)
};

Сигналреакцію

**Пакет: ** переважно яскраві. efeмерні . візерунки МSK2signalreactionshowcase

Демонструє шаблони передачі сигналів та зворотньі зв 'язки.

using Mostlylucid.Ephemeral.Patterns.SignalReactionShowcase;

// See source for signal dispatch examples
// Demonstrates OnSignal, OnSignalAsync, CancelOnSignals, DeferOnSignals

ПростаSignalWindow

**Пакет: ** переважно яскраві patternи

Сигнальний вікно з тривалістю SQLite - виживає від розпочинку процесу .

using Mostlylucid.Ephemeral.Patterns.PersistentWindow;

await using var window = new PersistentSignalWindow(
    "Data Source=signals.db",
    flushInterval: TimeSpan.FromSeconds(30));

// On startup: restore previous signals
await window.LoadFromDiskAsync(maxAge: TimeSpan.FromHours(24));

// Raise signals as normal
window.Raise("order.completed", key: "order-service");
window.Raise("payment.processed", key: "payment-service");

// Query signals
var recentOrders = window.Sense("order.*");

// Signals automatically flush every 30 seconds
// Also flushes on dispose

// Get stats
var stats = window.GetStats();
Console.WriteLine($"In memory: {stats.InMemoryCount}, Flushed: {stats.LastFlushedId}");

Інгекція залежності

// Register in Startup/Program.cs
services.AddEphemeralWorkCoordinator<WorkItem>(
    async (item, ct) => await ProcessAsync(item, ct),
    new EphemeralOptions { MaxConcurrency = 8 });

// Named coordinators
services.AddEphemeralWorkCoordinator<WorkItem>("priority",
    async (item, ct) => await ProcessPriorityAsync(item, ct));

// Inject and use
public class MyService(IEphemeralCoordinatorFactory<WorkItem> factory)
{
    public async Task DoWork()
    {
        var coordinator = factory.CreateCoordinator();
        await coordinator.EnqueueAsync(new WorkItem());
    }
}

Сучасні коріння DI можуть використовувати кращі помічники, такі як services.AddCoordinator<T>(...), services.AddScopedCoordinator<T>(...), або services.AddKeyedCoordinator<T, TKey>(...) тому що вони читають як нормальні AddX rejestracji; вони просто делегують ЕфемеральнійМSK1конкретним помічникам під капюшономM SK2

Лінія + Конфигурація ключів МSK1Проста конфігурація МSK2 приховані потужності )

mostlylucid.ephemeral.complete пакети PriorityWorkCoordinator і зашифровані варіанти, так само M SK1AddCoordinator” поверхня, яку ви використовуєте на старті, може надіслати роботу через названі лінії. Konfigurувати декілька імен лініюM SK1 дати їм опцію MaxDepth, і покладатися на координатора, щоб виділити “горячі МSK1 траси перед “повільні МSK3 трасами, поки він не спостерігає за будь-якими ключами для запитів

var sink = new SignalSink();
var lanes = new[]
{
    new PriorityLane("hot:4", CancelOnSignals: new HashSet<string> { "maintenance" }),
    new PriorityLane("normal"),
    new PriorityLane("slow:2")
};

await using var coordinator = new PriorityWorkCoordinator<WorkItem>(
    new PriorityWorkCoordinatorOptions<WorkItem>(
        async (item, ct) => await processor.ProcessAsync(item, ct),
        lanes,
        new EphemeralOptions { Signals = sink }));

await coordinator.EnqueueAsync(new WorkItem("order-42"), laneName: "hot");
await coordinator.EnqueueAsync(new WorkItem("order-43"), laneName: "slow");

Використовувати PriorityKeyedWorkCoordinator якщо вам також потрібно за замовленням на ключі-,—,рішунки маршруту все ще відбуваються в насосі ,, але збудований- вбірник ключів зберігає кожен відрізок послідовним

var keyed = new PriorityKeyedWorkCoordinator<WorkItem, string>(
    new PriorityKeyedWorkCoordinatorOptions<WorkItem, string>(
        order => order.CustomerId,
        async (order, ct) => await processor.ProcessPerCustomerAsync(order, ct),
        lanes,
        new EphemeralOptions { Signals = sink }));

await keyed.EnqueueAsync(new WorkItem("order-42") { CustomerId = "A" }, laneName: "hot");
await keyed.EnqueueAsync(new WorkItem("order-44") { CustomerId = "B" }, laneName: "normal");

Подумайте про координатора як про шеф-повара, як про ланцюги, як bowls, ,, і ключі, як ложки, які зберігають замовлення кожного клієнта. послідовний— прихована сила, яка зберігає роботу на замовленняM SK1 зруйнована , і сигналом- свідомим без додаткової церемоніїМSK4


Цілові рамки

  • МSK0NET 6.0, 7.0, \8.0, |

Ліцензія

Неlicencjum (публікова доменаM SK1

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.