# في الغالب lucyd. ephimmeral. كملت؛ نظام نمط نظم متزامن غريب في مخبأ LRU.

<!--category-- mostlylucid-ephemeral -->
<datetime class="hidden">2025-12-14T13:35</datetime>

حسناً هذا كان هوسي للأسبوع الماضي. انظر الأجزاء السابقة وما الذي أدى إلى هذا ؛ "ماذا لو كان LRU هو سياق تنفيذي.'. الآن هو مجموعة من 30 حزمة Nuget تغطي معظم أنماط التنفيذ المتزامنة الرئيسية (في حزم خط TINY 5-10). احصل على قدرات تكيفية مذهلة مع SIPLE syendas!

اعثر على المصدر هنا: https://gigethub.com/scottagal/forestlylucid.atoms/blob/main/moslylucid.ephimmeral/src/mostlylucid.ephimmeral.

[TOC]

# منفق

الـ الـ [الجزء السابق من ]لبعض التعمق في استخداماته. يعرض هنا هو adme.md من معظم liuslucid. ephimmeral. الكامل pacakage الذي يحتوي على كل من اللب lislucid. ephimmeral الحزمة و كل الأنماط، 'athoms' (ملحقات etc) الحزم في واحد مريح DLLL.

## المجموعة الأساسية

أو استخدام النواة [CFC CFC CFC CF](https://github.com/scottgal/mostlylucid.atoms/tree/main/mostlylucid.ephemeral/src/mostlylucid.ephemeral) (أ) TINY (عشرة فصول حرفيًا) مما يعطيك جميع الوظائف الأولية.

## & & & & & & & & & & & & & & & & & & & & & & & & & & & &DD

أو إذا كنت تريد دالة كاملة مستنداً على أساس و مع بسيط `[EphemeralJob]` الأمم المتحدة<x>(أ) استخدام أسلوب تسجيل [- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -](https://github.com/scottgal/mostlylucid.atoms/tree/main/mostlylucid.ephemeral/src/mostlylucid.ephemeral.attributes).

من المرجح أن هذا هو موضوع مدونتي للمضي قدماً... لقد تم تحذيرك

# في الغالب الأعمــس إلــس سـسـيـد فـي الـن

[![](https://img.shields.io/nuget/v/mostlylucid.ephemeral.complete.svg)](https://www.nuget.org/packages/mostlylucid.ephemeral.complete)

**كل ما في اغلب الاغلبية cicicid.** - التنفيذ المقيد مع التنسيق القائم على الإشارة.

```bash
dotnet add package mostlylucid.ephemeral.complete
```

هذه الحزمة تجمع كل النواة والذرة ورمز النمط في تجميع واحد. لفرادى الحزم، انظر الروابط في كل منها.
() انظر الجزء الوارد أدناه.

---


## المحتويات (تابع)

- [بدءQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ](#quick-start)
- [المنسقون](#core-coordinators)
- [](#configuration-ephemeraloptions)
- [الوصلس](#signals)
- [](#atoms-building-blocks)
  - [كل يوم العمل](#fixedworkatom)
  - [مُهَيّد متتاليAتوم](#keyedsequentialatom)
  - [الإشارة Areare Astom](#signalawareatom)
  - [مُتْم](#batchingatom)
  - [م إعادة](#retryatom)
  - [ذرات حفظ البيانات](#data-storage-atoms)
  - [& ذرة المُنتجِر](#moleculerunner--atomtrigger)
  - [مُسَلِدCAtom](#slidingcacheatom)
  - [محفوظات](#ephemerallrucache)
  - [المُصدِِِِِِِِِِِْ مُجْْْْْ مِْ مِْ مِْ مِْ مِْ مِمْ مِ](#echo-maker)
- [الأنماط](#patterns-ready-to-use)
  - [شُكّر](#signalbasedcircuitbreaker)
  - [باء باء باء باء -](#signaldrivenbackpressure)
  - [المُسَطر المُسَطر](#controlledfanout)
  - [](#adaptiverateservice)
  - [المحركات المحركات](#dynamicconcurrencydemo)
  - [الأولوية الرئيسية](#keyedpriorityfanout)
  - [& نشطFanoutoutPPPelin](#reactivefanoutpipeline)
  - [معمِم إشارة معمِم معلِم](#signalanomalydetector)
  - [مُسند مُسند](#signalcoordinatedreads)
  - [](#signalinghttpclient)
  - [2 مُحُسِس](#signallogwatcher)
  - [تقر الاتصالاتSSS](#telemetrysignalhandler)
  - [DIMS](#longwindowdemo)
  - [عرض](#signalreactionshowcase)
  - [SSINSINSL Windindow](#persistentsignalwindow)
- [حقــوق](#dependency-injection)

---


## بدءQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

```csharp
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 });
```

### دائرة التسجيل

```csharp
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>()` (ب) أن يكون تسجيل الخدمة موجزاً، وأن يسمح DI بامتلاك المغسلة/المدارة، وأن يجعل القصص الجديدة المتعلقة بالمسؤولية/المهبل/التشغيل على بعد نقرة واحدة.

### وظائف مدفوعة بالحرف

`mostlylucid.ephemeral.complete` `mostlylucid.ephemeral.attributes`لذلك فإن خطوط الأنابيب هي جزء من النواة
عامل العدائي كمستهلك إشارة من الدرجة الأولى: الطرق المزيَّنة تنضم إلى نفس الكاتشين، وقطع الأشجار، و
تلميح القصص، وكل وصفة يمكن أن تعلن `Priority`رُبْع الوظائف `MaxConcurrency`, `Lane`, `Key` المصدر، الإشارة
والانبعاثات والانبعاثات والتجاوزات الثابتة/المؤقتة والاعتراضات.

الدالة الدالة الدالة الدالة

- ****الاستخدام: الاستخدام: `Priority`, `MaxConcurrency`، و ، ، ، ، ، ، ، ، ، ، ، `Lane` للإبقاء على العمل في نظام محدد في الوقت الذي يجري فيه
  منفصلة عن بعضها البعض.
- **مفتاح & & و و و و و و و و و و و و و و و و و و و و و و و و و و و و و و و و و مفتاح و و و و و و و و و و و و و و و و و و و و و و و و و و**: `OperationKey`, `KeyFromSignal`, `KeyFromPayload`، و ، ، ، ، ، ، ، ، ، ، ، `[KeySource]` تساعدك في العمل الجماعي مع
  مفاتيح ذات معنى لقطع الأشجار، جدول زمني عادل، والتشخيص.
- **جاري تنفيذ**: `Pin`, `ExpireAfterMs`, `AwaitSignals`, `MaxRetries`، و ، ، ، ، ، ، ، ، ، ، ، `RetryDelayMs` مُمَدّد
  رؤيتهم، تنفيذ البوابات حتى وصول المعتمدات، والشفاء مع إعادة التلقيمات في الوقت الذي تصدر فيه إشارات الفشل.
- **معرِف معرِف مِنْدِلْرِسِلِ**: تمّت `EmitOnStart`, `EmitOnComplete`، و ، ، ، ، ، ، ، ، ، ، ، `EmitOnFailure` لـ إشارة إلى المراحل المُنتِجَة،
  أو منسقين آخرين بدون أسلاك يدوية.

```csharp
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");
```

```csharp
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.*` أو أي إشارة تنبثق أو أي إشارة تصل إلى المغسلة.
ويمكن للمعالجين أن يقرأوا أيضاً مفاتيح من الإشارات/الحمولات، وأشغال الدبوس إلى أن تصل إلى أكوام المصب، وإشارات الانبعاث/الإكمال/الإبطال، و
لـ لـ استخدام `services.AddEphemeralSignalJobRunner<T>()` (أو (أو
(ب) إذا كانت الحاوية هي التي تدير العيار والمغسلة.

[Ephemaral Jobs(SSignalPrefix = "مراحل" ، افتراضي Lan = "Pipline")]
الصنف المختمة
{
[Ephphemmeral Job( "نين فيست", Emitwwwwof = جديد[} { "المسرحية. النـزعة. Ddone" }
المهمّة العامة: %gestAsync(SignalEvent evt)=> Console. out. WriteLineAsync(evt. signal);

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

}

Var stateSink = جديد إشارةSink()؛
ينتظر انتظار استخدام مفار مرحلةRunner = جديد جديد EphphemaralSINASINABRunner( مرحلةSinك ، جديد جديد[{وظائف جديدة ()})؛
(ب) أو ("النظرية. نِعْم")؛

يمكن أن تعتمد الوظائف الثقيلة على `ResponsibilitySignalManager.PinUntilQueried` (النمط `responsibility.ack.*` إلى
وتُبقي عملياتها مرئية إلى أن يقوم قارئ أسفل النهر بإحضار الحمولة، بينما `OperationEchoMaker`/
`OperationEchoAtom` إذاً لا يزال بإمكان مراجعي الحسابات أو الجزيئات أن "تتذوق" آخر حالة حتى بعد
إنّ الذرّة تَمُوتُ.

### المهام المدرجة

`mostlylucid.ephemeral.complete` يحتوي أيضاً على ما يلي: `mostlylucid.ephemeral.atoms.scheduledtasks`تعريف cron أو JJON
& عبر الجداول `ScheduledTaskDefinition` (مهر، إشارة، إشارة، اختيارية) `key`, `payload`, `description`, `timeZone`, `format`,
`runOnStartup`)، وما إلى ذلك)، وما إلى ذلك، وما إلى ذلك) `ScheduledTasksAtom` العمل الدائم من خلال `DurableTaskAtom`كل عمل مقرر
يُمْزِز الإشارة المُهيأة داخل نافذة منسّق، لذا يرث الدّين، قطع الأشجار، ومسؤولية الدلالات.
في حين أن جزيئاتك أو حالات خطوط الأنابيب تستجيب إلى موجة الإشارة المنبعثة.

ألف - كل `DurableTask` جاري تنفيذ جدول `Name`, `Signal`)الاختياريـة والاختياريـة `Key`« ولو كان كتابا » من نوعه . `Payload`، و ، ، ، ، ، ، ، ، ، ، ، `Description`إذاً فإن المستمعين في المراحل النهائية يعرفون مباشرةً أي وظيفة يتم شغلها وما هي البيانات الفوقية (الاسم، العنوان، الخ) التي يجب استهلاكها. `DurableTaskAtom.WaitForIdleAsync()` عندما تريد فقط الانتظار للانفجار الحالي من العمل المقرر لإنهاء دون إكمال ذرة، إبقاء الجدول جاهزا لـ التالي كود.

### & & الدالة

`mostlylucid.ephemeral.logging` مرآة ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو ميكرو extensions. توغل في الإشارات والعكس بالعكس. ابدأ عن طريق إلحاق
`SignalLoggerProvider` إلى مصنع سجلّ سجلّك لذا سجلّ الأحداث `log.*` دال - الإشارة، والإنجاز `SignalToLoggerAdapter` مضافاً إليه:
تريد إشارات لتدفقها مرة أخرى إلى خط الأساس القياسي.

```csharp
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");
```

```csharp
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` إلى مرآة الاشارات الناتجة عن العودة إلى اللوغاريتمات القياسية لذا ركام الرصد الخاص بك يرى كلا
جانبان من الجسر.

---


## المنسقون

> **الحزم:** [CFC CFC CFC CF](https://www.nuget.org/packages/mostlylucid.ephemeral)

### لجنة الأمم المتحدة&lt;1 م أ م&gt;

وتصطف الأعمال الطويلة الأجل مع نافذة متزامنة ومرتبطة.

```csharp
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();
```

### الفريق العامل المعني بدور الفريق العامل&lt;تاسع، ت&gt;

التجهيز التعاقبي على أساس كل حالة على حدة - أصناف ذات مفتاح تجهيز واحد حسب الطلب.

```csharp
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);
```

### منسق للخبير الاستشاري&lt;TInpent, Treegult&gt;

النتائج الملتقطة من عمليات Async.

```csharp
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);
```

### أولاً- مقدمة&lt;1 م أ م&gt;

ممرات ذات أولوية متعددة مع conronicable concerning لكل ممر.

```csharp
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");
```

---


## (الخيارات المبكـرة)

```csharp
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
}
```

---


## الوصلس

(ج) العمليات التي تطلق إشارات من أجل قابلية الرصد الشامل لعدة قطاعات.

```csharp
// 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` يَتْركُك تُدْبِسُ
إلى حين وصول إشارة (نمط افتراضي) `responsibility.ack.*` مع المفتاح`operationId`... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
مقرر `description` يمكن للعملية أن تصف مسؤوليتها وأن تحدد `maxPinDuration` إلى مُنَح
إن لم يظهر المستهلك أبداً

```csharp
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);
```

```csharp
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` تبقى صغيرة (أيد التشغيل، مفتاح، مفتاح، إشارة، وقت الوقت tumttamp)، بحيث يمكنك تسجيل أي حالة صغيرة تهتم بها
قبل أن يتم جمع العملية

ويحافظ المنسق أيضاً على صدى قصير الأجل للإشارات النهائية (يتم عن طريق `EnableOperationEcho`أنك قادر على
التفقد مع: `GetEchoes()` عندما تحتاج إلى إعادة تشغيل موجة الإشارة المقلدة دون إبقاء العملية الكاملة حولها.

```csharp
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)` بإنهاء
(على سبيل المثال، فيما يتعلق بالريات). `OperationFinalized` عندما تقصها النافذة، لذا
الاشتراك إذا كنت ترغب في إطلاق إشارة نهائية، أو تشخيصات سجلية، أو تشغيل "الكلمات الأخيرة" تنظيف.

---


## الذرت (بلوك المباني)

### كل يوم العمل

> **الحزم:
> ** [في معظم الأحيان ICL CFC. ephmermeral. atoms. abd](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.fixedwork)

مجموعة من العمال الثابتين مع إحصائيات، ولوح الحد الأدنى من API حول منسق العمل الفجائي.

```csharp
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();
```

---


### مُهَيّد متتاليAتوم

> **الحزم:
> ** [(أ) الأجنومات (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ) (أ)](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.keyedsequential)

التجهيز الأساسي والتعاقبي مع جدولة اختيارية عادلة.

```csharp
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();
```

---


### الإشارة Areare Astom

> **الحزم:
> ** [حامـد النـواصـات](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.signalaware)

(ب) الإيقاف المؤقت أو الإلغاء استناداً إلى الإشارات المحيطة.

```csharp
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();
```

---


### مُتْم

> **الحزم:
> ** [في الغالب III CFC CFC CFC IV CFC](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.batching)

جمع العناصر إلى دفعات حسب الحجم أو الفترة الزمنية.

```csharp
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
```

---


### م إعادة

> **الحزم:** [ICL CF IC CF IC IC CF](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.retry)

-ملف إستعراضي خلفي

```csharp
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();
```

---


### ذرات حفظ البيانات

> **الحزم:** [ICL CFC III CFC CFC IV](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data)

التشكيلة المشتركة لذرات التخزين`DataStorageConfig`, `IDataStorageAtom<TKey, TValue>`) بالإضافة إلى اتفاقيات الإشارة التي تدفع الملف، SQLite، ومكيفات PostgresQL.

```csharp
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`](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data.sqlite) أو [`Mostlylucid.Ephemeral.Atoms.Data.Postgres`](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data.postgres) SQLite/Posstgres. يمكن أن تشترك وظائف الصّف في `saved.data.{dbname}` تُشير إلى بدء العمل في مرحلة ما بعد العمل بينما `load.data.{dbname}` يُؤخّرُ مُخْبَئَاتَ هيدراتِ.

---


### & ذرة المُنتجِر

> **الحزم:
> ** [المادة الكيميائية: المواد الكيميائية](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.molecules)

المطبوعـات المتكونـة مـن `MoleculeBlueprintBuilder` دعْك تُعرّفُ الذراتَ (الدفعة، المخزون، الشحن،
(الإخطار) الذي ينبغي تشغيله عندما تكون إشارة مثل `order.placed` يَصِلُ. يَصِلُ. يَقِلُ. `MoleculeRunner` يُستمع إلى الزناد
نمطية، إنشاء `MoleculeContext`و ينفّذ كل خطوة أثناء الاشتراك في بدء/اكتمال الأحداث.
`AtomTrigger` عندما تكون إشارة ذرة واحدة يجب أن تبدأ منسق أو جزيء آخر.

```csharp
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")`لذا فإن بقية النظام يلتقط
مُتَكَوِّن.

---


### مُسَلِدCAtom

> **الحزم:
> ** [IC CF CF CF CF](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.slidingcache)

المظلة مع إنتهاء الإنزلاق - الوصول إلى نتيجة يُعيد تشغيل TTL.

```csharp
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}");
```

### محفوظات

> **الحزم:** (بدولارات الولايات المتحدة الأمريكية)`mostlylucid.ephemeral`- المخبأ الأمثل ذاتياً مع وضع TTL على كل ضرب وممدد TTL من أجل
> المفاتيح الساخنة.

```csharp
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` يمكن أن تكون مُهيأة من أجل الإنتهاء الإنزلاقي، لكنها لا تطلق أبداً الإشارات الساخنة/البردية أو تمد TTL
> للمفاتيح الساخنة. `EphemeralLruCache` في الحزمة الأساسية (وفي `SqliteSingleWriter`)
> عندما تريد أن يركز المخبأ على مجموعة العمل النشطة.

### المُصدِِِِِِِِِِِْ مُجْْْْْ مِْ مِْ مِْ مِْ مِْ مِمْ مِ

> **الحزم:** [أ. أ. أ.](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.echo)

تلتقط "الكلمات الأخيرة" التي تطلقها عملية ما قبل أن تُقلّص.
الحمولات (المطابقة) `ActivationSignalPattern` / `CaptureSignalPattern` ما إذا كان `OperationFinalized` تُنْجِجُ
`OperationEchoEntry<TPayload>` يمكنك الاستمرار عن طريق `OperationEchoAtom<TPayload>`.

```csharp
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");
```

تقوم فقط برفع الإشارة المطبوعة بأي حالة تعتبرها حرجة، ويحتفظ الصانع بمجموعة العمل
مُحَوَّل بينما أنت تُواصلُ الصدى.

---


## الأنماط (القابلة للاستخدام)

### شُكّر

> **الحزم:
> ** [في الغالب الأعمـى مـن الأوكـسـسـيـسـيـسـي الـمـا فـي الأوسـس](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.circuitbreaker)

مكسرات الدوائر الكهربائية التي تستخدم نافذة تاريخ الإشارة.

```csharp
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);
```

---


### باء باء باء باء -

> **الحزم:
> ** [مبيدات حشرات، ضغط في الرجع](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.backpressure)

(ج) إدارة الآفاق المتعلقة بالعمق مع التأجيل التلقائي لإشارات الضغط الخلفية.

```csharp
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
```

---


### المُسَطر المُسَطر

> **الحزم:
> ** [مبيدات مبيدات حشرات متحكم فيها](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.controlledfanout)

Global + bl- key geting for control conference.

```csharp
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();
```

---


### 

> **الحزم:
> ** [مبيدات بطاريات.](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.adaptiverate)

معدل الاشارات المدفوعة يحد من مع الرجوع التلقائي.

```csharp
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}");
```

---


### المحركات المحركات

> **الحزم:
> ** [بطاريات، عملة ديناميكية](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.dynamicconcurrency)

وقت التشغيل contring إعتماداً على إشارات التحميل.

```csharp
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();
```

---


### الأولوية الرئيسية

> **الحزم:
> ** [مبيدات مبيدات الآفات، الأولوية الأولية الرئيسية](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.keyedpriorityfanout)

الممرات ذات الأولوية مع أوامر حفظ المفتاح.

```csharp
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();
```

---


### & نشطFanoutoutPPPelin

> **الحزم:
> ** [مبيدات مبيدات حشرات.](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.reactivefanout)

خط أنابيب من مرحلتين مع ضغط ظهر أوتوماتيكي

```csharp
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();
```

---


### معمِم إشارة معمِم معلِم

> **الحزم:
> ** [مبيدات مبيدات حشرات، مكتشفات أورامية](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.anomalydetector)

الكشف عن شذوذ النوافذ المتحركة.

```csharp
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}");
```

---


### مُسند مُسند

> **الحزم:
> ** [مبيدات حشرات، إشارة إلى قراءات منسقة منسقة](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalcoordinatedreads)

(كويستشي) يقرأ خلال التحديثات بدون أقفال صلبة.

```csharp
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
```

---


### 

> **الحزم:
> ** [مبيدات / / / / / / / / / / / /](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalinghttp)

HTTTP عميل مع إشارات التقدم.

```csharp
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
```

---


### 2 مُحُسِس

> **الحزم:
> ** [Paptns. يُشار إلى مراقب لوغاريتم](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signallogwatcher)

راقبْ إشارةَ نافذةَ للأنماطِ واطلقْ نداءاً خلفياً.

```csharp
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)
```

---


### تقر الاتصالاتSSS

> **الحزم:
> ** [مبيدات بطاريات، قياسات عن بعد](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.telemetry)

تكامل التنظير OpenTeleatis/Appication Insights.

```csharp
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();
```

---


### DIMS

> **الحزم:
> ** [مبيدات حشرات، ونافذة طويلة](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.longwindowdemo)

(ب) إعداد تشكيلات كبيرة للنافذة من أجل عمليات مراجعة الحسابات.

```csharp
using Mostlylucid.Ephemeral.Patterns.LongWindowDemo;

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

---


### عرض

> **الحزم:
> ** [مبيدات مبيدات حشرات.](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalreactionshowcase)

خطوط الإستراتيك إشاره إرسال أنماط و إستدعاءات.

```csharp
using Mostlylucid.Ephemeral.Patterns.SignalReactionShowcase;

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

---


### SSINSINSL Windindow

> **الحزم:
> ** [كربونات النافذ النافذ النافذ النافذ](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.persistentwindow)

نافذة إشارة مع ثبات SQLit - ينجو من عملية إعادة التشغيل.

```csharp
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}");
```

---


## حقــوق

```csharp
// 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());
    }
}
```

قد تفضل جذور دي دي الحديثة المُساعدين الأقصر مثل: `services.AddCoordinator<T>(...)`,
`services.AddScopedCoordinator<T>(...)`أو `services.AddKeyedCoordinator<T, TKey>(...)` « وقرأوا » أي كفار « كأنهم عاديون » .
`AddX` التسجيلات؛ هم فقط يفوضون المساعدين الخاصين بالأبحار تحت القلنسوة.

---


## الأطر

- ... ٦,٠,٠,٧,٠,٠,٠,٠,٠,٠,٠,

## الرخصة

غير ترخيص (نطاق عام)