найбільш зрозуміле.невичерпнеM SK1повне ; дивна послідовна модель системи в LRU-каші.
Це була моя одержимість протягом минулого тижня. попередні частини і що призвело до цьогоЩо якби 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] та послуги.Додавати
Це, скоріш за все, тема мого блогу, яка рухається вперед.
Найяскравіший.ЕфемеральнийM SK1Довершений
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 SK1Bot(),Human(),Info(),VerifiedBot(),VerifiedGoodBot()CategoryScore.TotalWeightнерухомість ( переименована зWeight)
Прослідження поширення сигналу - Виявление циклу та обмеження глибини сигналів
Ссылка на джерело - Відладка в вихідних умовах бібліотеки прямо з вашого IDE
Подивіться Docs/Taxonomy.md для спільного словника навколо субстрату, лінзи, атомиM SK2 молекулиМSK3 і ескалація.
Стосунок
- Швидкий старт
- Центральні координатори
- Konfiguracja
- Сигнал
- Атоми
- Патерни
- СигналBasedCircuitBreaker
- Сигнал керований зворотним тиском
- Контролований вентилятор
- АдаптивнаRateService
- Демонстрація динамічної конкуренції
- KeyedPriorityFanOut
- РеактивнийFanOutPipeline
- Сигнал-аномалічний детектор
- СигнальнийКоординованийЧитання
- СигналуванняHttpClient
- Сенглог-навігатор
- Оператор сигналів телеметрії
- ДовгийWindowDemo
- Сигналреакцію
- ПростаSignalWindow
- Інгекція залежності
Швидкий старт
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");
Атоми таксономії
Пакети:
- База контракти: найбільш яскраво зрозумілий.фемемернийM SK1атоми.таксиномі ( включає
MultiTaxonomyAtom)- Різовики атомів:
mostlylucid.ephemeral.atoms.taxonomy.sensor,.extractor,.embedder,.retriever,.proposer,
.constrainer,.ranker,.renderer,.coordinator,.feedback,.guard
Геніальні види атомів, які підпорядковуються таксономії (сенсор М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