# आम तौर पर, सा. यु.
2025-12-14T13:35
खैर यह पिछले सप्ताह के लिए मेरा जुनून किया गया है. देखो पिछले भाग और क्या इस के लिए ले लिया, 'क्या अगर एक LRU एक हत्या संदर्भ था. '.' अब यह 30 tuuin पैकेज के एक सेट है सबसे बड़े पैमाने पर हत्या के पैटर्न (Ti-10-10 पंक्ति पैकेजों में). एक अद्भुत पत्रकारीय क्षमता प्राप्त करें!
यहाँ का स्रोत ढूंढें: https://skttt.com/sk/ sallypak/gik/mphphphp/ allyphphpt.phyphphphyyynymp/ ad पाया जा सकता है.
[TOC]
# पहले
पढ़ें [सिग्नल पर पिछला हिस्सा ]कुछ अन्तर्दृष्टि के लिए इसका उपयोग करते हैं. यहाँ इस्तेमाल किया जाता है विशेष रूप से पढ़ने के लिए.
## कोर
OR प्रयोग करें को [आम तौर पर सा. यु. पू.](https://github.com/scottgal/mostlylucid.atoms/tree/main/mostlylucid.ephemeral/src/mostlylucid.ephemeral) एक TIyyy (शाब्दिक 10 क्लास) जो आप सभी कच्चे कार्य देता है.
## गुण (b)
OR यदि आप सम्पूर्ण गुण सरल के साथ अतुल्यकालिक स्थिति से बाहर करना चाहते हैं `[EphemeralJob]` और सेवा करते हैं।कोरिएशन शैली पंजीयन प्रयोग करें [अधिकतर अल्पपारदर्शिता के पैकेज](https://github.com/scottgal/mostlylucid.atoms/tree/main/mostlylucid.ephemeral/src/mostlylucid.ephemeral.attributes).
यह संभव है कि मेरे चिट्ठे का विषय आगे बढ़ने जा रहा है... आपको चेतावनी दी गई है
# यु. पू.
[](https://www.nuget.org/packages/mostlylucid.ephemeral.complete)
**एक एकल डीएल में सबसे अधिक अलंकार** - संकेत आधारित समन्वय के साथ बाध्य अतुल्यकालित अतुल्यकालित मौत.
```bash
dotnet add package mostlylucid.ephemeral.complete
```
यह पैकेज सभी को अलग करता है, परमाणु, तथा पैटर्न कोड को एक सम्मेलन में रखता है. अलग- अलग पैकेजों के लिए, प्रत्येक में लिंक देखें
नीचे दिया गया है.
---
## विषय - सूची
- [क्विक स्टार्ट](#quick-start)
- [कोर कोरलेटर](#core-coordinators)
- [कॉन्फ़िगरेशन](#configuration-ephemeraloptions)
- [सिग्नल](#signals)
- [अणु](#atoms-building-blocks)
- [स्थिर कार्य एट](#fixedworkatom)
- [कुंजी/ पर्थ](#keyedsequentialatom)
- [सिग्नल जानकारी](#signalawareatom)
- [बैच एटम](#batchingatom)
- [पर फिर कोशिश करें](#retryatom)
- [डाटा भंडार अणु](#data-storage-atoms)
- [अणु- अणु एवं अणु](#moleculerunner--atomtrigger)
- [बाल - बाल बढ़ता जा रहा है](#slidingcacheatom)
- [एपम्रॉल- टोन्](#ephemerallrucache)
- [इको सृजक](#echo-maker)
- [पैटर्न](#patterns-ready-to-use)
- [सिग्नल बेस- बेस्कर ब्रेकर](#signalbasedcircuitbreaker)
- [सिग्नल Caseukraine. kgm](#signaldrivenbackpressure)
- [कंट्रोलFE (l)](#controlledfanout)
- [एडाप्टिव आइडेंशियलComment](#adaptiverateservice)
- [गतिशीलताडो](#dynamicconcurrencydemo)
- [कुंजीीकृत](#keyedpriorityfanout)
- [प्रतिक्रिया](#reactivefanoutpipeline)
- [सिग्नल एनमांडर](#signalanomalydetector)
- [सिग्नल कोरित पढ़ें](#signalcoordinatedreads)
- [सिग्नलीकरण_BAR_](#signalinghttpclient)
- [सिग्नल- स्टारर](#signallogwatcher)
- [ह्यूमर चिह्न](#telemetrysignalhandler)
- [लंबा विंडो आयामीमो](#longwindowdemo)
- [सिग्नल रीकर दिखाएँ](#signalreactionshowcase)
- [एसिंक चिह्नीय विंडोComment](#persistentsignalwindow)
- [डिपेंडेंसी इनवेशन](#dependency-injection)
---
## क्विक स्टार्ट
```csharp
using Mostlylucid.Ephemeral;
// Long-lived work coordinator
await using var coordinator = new EphemeralWorkCoordinator(
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(
async (item, ct) => await ProcessAsync(item, ct),
new EphemeralOptions { MaxConcurrency = 8, MaxTrackedOperations = 128 });
builder.Services.AddEphemeralSignalJobRunner();
var app = builder.Build();
app.MapPost("/", async ([FromServices] IEphemeralCoordinatorFactory factory, WorkItem item) =>
{
var coordinator = factory.CreateCoordinator();
await coordinator.EnqueueAsync(item);
return Results.Accepted();
});
await app.RunAsync();
```
जाना जाता है `services.AddCoordinator()` सहायक तथा सहायक `AddEphemeralSignalJobRunner()` सेवा को पंजीयन रखें, स्वयं सिंक/ रनर, और नई जिम्मेदारी / कांश कहानियों को एक ही क्लिक दूर बनाने के लिए।
### गुणधर्म कार्य
`mostlylucid.ephemeral.complete` बंडल `mostlylucid.ephemeral.attributes`, इसलिए गुण विश्लेषण कोर का हिस्सा हैं
सतह पर, धावक को पहली-क्लास उपभोक्ताओं के रूप में उपचार करें: शानदार तरीकों से एक ही कलिंग, लॉगिंग, और
सजीव कहानियाँ, और प्रत्येक गुण घोषित कर सकते हैं `Priority`, नौकरी- लेवल `MaxConcurrency`, `Lane`, `Key` स्रोत, सिग्नल
उत्सर्जन, पिन/पिय ओवरराइड, और निकासी.
कुंजी गुण सहायक:
- **यात्रा के क्रम (P)**: इस्तेमाल `Priority`, `MaxConcurrency`, और `Lane` गर्म पथों के दौरान कार्य व्यवस्थित क्रम में रखने के लिए
अलग रहो.
- **कुंजीिंग विंग**: `OperationKey`, `KeyFromSignal`, `KeyFromPayload`, और `[KeySource]` समूह के साथ काम करने में आपकी मदद करें
लॉगिंग, निष्पक्ष सारिणी, और निदान के लिए अर्थपूर्ण कुंजियाँ.
- **कॉन्फ़िगरेशन (R)**: `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(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.*` या किसी भी उत्पन्न संकेत सिंक हिट करता है.
हैंडलर संकेतों से भी पढ़ सकता है
अनुक्रम के लिए यात्रा में स्लॉट. DIM-SUs प्रयोग के लिए `services.AddEphemeralSignalJobRunner()` (या स्कोप्ड है
अतः धावक और सिंक पात्र द्वारा प्रबंधित कर रहे हैं.
[एपीडैम्स( SERPPERTCP = "क्लिन", डिफ़ॉल्ट tran = "ppeliline")
सार्वजनिक वर्ग मंच- कार्य- सूची (b)
{
[एपीड्रॉडिम कार्य ("सबसे"), एम- ऑन- योग्य = नया[] {" " मंच. सबसे दूर"}
सार्वजनिक कार्य
[EphemeralJob("finalize")]
public Task FinalizeAsync(SignalEvent evt) => Console.Out.WriteLineAsync("final stage");
}
अवस्था चरण- स्याही = नया सिग्नल- ओएस ();
स्टेज रनर का उपयोग करने का इंतजार करें = नया एपेक्टर- से- पारर- चल रहा है - मंच- बस्टर- बस्टर, नया[{] नई कार्य- सूची (});
चरण . ऊपर (" मंच. सबसे")
पिन- भारी नौकरियों पर भरोसा कर सकते हैं `ResponsibilitySignalManager.PinUntilQueried` (तयशुदा रूप से एक) `responsibility.ack.*`() को
अपने दृश्य संचालन को तब तक बनाए रखें जब तक कि एक प्लैटोच रीडर लोड नहीं करता, जबकि वे कर अदा करते हैं `OperationEchoMaker`/
`OperationEchoAtom` अंतिम संकेत धारा जारी रखें इतने परिष्करण या अणु अभी भी “अन्तिम राज्य का अनुकरण ” कर सकते हैं
परमाणु मर जाता है.
### सारिणीबद्ध किए गए कार्य
`mostlylucid.ephemeral.complete` भी रखता है `mostlylucid.ephemeral.atoms.scheduledtasks`.ston या JSON परिभाषित करें
के द्वारा सारिणीबद्ध करता है `ScheduledTaskDefinition` (C), संकेत, वैकल्पिक `key`, `payload`, `description`, `timeZone`, `format`,
`runOnStartup`और दुरूस्त किया और जिसने (उसका) अन्दाज़ा मुक़र्रर किया फिर राह बतायी `ScheduledTasksAtom` मज़बूती का काम `DurableTaskAtom`हर सारिणी की नौकरी
एक कच्चे विंडो के अंदर कॉन्फ़िगर्ड संकेत देता है, इसलिए यह पिनिंग, लॉगिंग, और जिम्मेदारी के अधिकारी होता है
जब आप अणुओं या गुण का श्रेय देते हैं तो संकेत तरंग के प्रति प्रतिक्रिया दिखाते हैं ।
प्रत्येक `DurableTask` समय तय करता है `Name`, `Signal`वैकल्पिक `Key`एक ज्ञात और निश्चित अवधि तक? `Payload`, और `Description`इसलिए वे तुरंत पता लगा लेते हैं कि कौन सा काम करता है और क्या मेटाडेटा, यूआरएल इत्यादि । `DurableTaskAtom.WaitForIdleAsync()` जब आप मौजूदा देरी के लिए इंतजार करना चाहते हैं... ... परमाणु को पूरा करने के लिए...
### सिग्नल लॉग किया जा रहा है (U)
`mostlylucid.ephemeral.logging` प्रतिबिम्बित करता है. विस्तार. संकेतों में टॉगल और फिर भी बदलाव. संलग्न करने के द्वारा प्रारंभ करें
`SignalLoggerProvider` अपने लॉगर फैक्टरी के लिए तो लॉग घटनाओं का निर्माण `log.*` संकेत, तथा हुक `SignalToLoggerAdapter` यदि
आप संकेत को मानक लॉग बराबर में वापस प्रवाहित करना चाहते हैं.
```csharp
var sink = new SignalSink();
var typedSink = new TypedSignalSink(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` परिणाम स्वरूप लॉग में वापस लाने के लिए ताकि आपकी निगरानी में दोनों दिखाई दे
पुल के पक्ष.
---
## कोर कोरलेटर
> **पैकेज:** [आम तौर पर सा. यु. पू.](https://www.nuget.org/packages/mostlylucid.ephemeral)
### एपम्रॉमवर्क कोर<टी>
लंबे समय के लिए कार्य कतार तथा दृश्य विंडो के साथ बाध्य किया गया.
```csharp
await using var coordinator = new EphemeralWorkCoordinator(
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();
```
### एपीट- कम्पेटर<टी- कुंजी, टी>
पर- कुंजी अनुक्रम - क्रम में एक ही कुंजी प्रक्रिया के साथ वस्तु.
```csharp
await using var coordinator = new EphemeralKeyedWorkCoordinator(
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);
```
### एपम्रॉल<TVERT, TVVER>
अतुल्यकालिक्शन से कैप्चर परिणाम.
```csharp
await using var coordinator = new EphemeralResultCoordinator(
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);
```
### प्राथमिकता कार्यकर्ता<टी>
गाड़ी चलाते वक्त आप क्या कर सकते हैं, इस बारे में आप कैसा महसूस करते हैं?
```csharp
var coordinator = new PriorityWorkCoordinator(
async (item, ct) => await ProcessAsync(item, ct),
new PriorityWorkCoordinatorOptions(
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 { "circuit-open" },
DeferOnSignals = new HashSet { "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(body, new EphemeralOptions { Signals = sink });
var c2 = new EphemeralWorkCoordinator(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` छोटा रहता है (प्रयोग आईडी, मुख्य, संकेत, समय- चिह्न, समय, इत्यादि), तो आप जो भी कम स्थिति आप देख सकते हैं वह रिकॉर्ड कर सकते हैं
ऑपरेशन को जमा करने से पहले के बारे में.
संयोजक भी अंतिम संकेतों का एक छोटा सा इको रहता है (यह संभवतः के द्वारा हो सकता है) `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` तो जब बड़ी सख्त मुसीबत (क़यामत) आ मौजूद होगी
सदस्यता लें यदि आप अंतिम संकेत, लॉग्स, या "पिछले शब्द" साफ करना चाहते हैं.
---
## अणु (अनुड़ को बिल्ड करना)
### स्थिर कार्य एट
> **पैकेज:
> ** [आम तौर पर बहुत कम काम होते हैं ।](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.fixedwork)
उदाहरण के लिए, मान लीजिए कि आप एक छोटे - से खेत में काम कर रहे हैं ।
```csharp
using Mostlylucid.Ephemeral.Atoms.FixedWork;
await using var atom = new FixedWorkAtom(
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();
```
---
### कुंजी/ पर्थ
> **पैकेज:
> ** [आमतौर पर सा. यु. पू.](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.keyedsequential)
प्रति-key अनुक्रम वैकल्पिक अनुकूल तैयारी के साथ.
```csharp
using Mostlylucid.Ephemeral.Atoms.KeyedSequential;
await using var atom = new KeyedSequentialAtom(
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();
```
---
### सिग्नल जानकारी
> **पैकेज:
> ** [ज़्यादातर लोगों ने इस बात पर गौर किया कि वे कहाँ रहते हैं ।](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(
async (item, ct) => await ProcessAsync(item, ct),
cancelOn: new HashSet { "shutdown", "circuit-open" },
deferOn: new HashSet { "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();
```
---
### बैच एटम
> **पैकेज:
> ** [आम तौर पर कच्चे लोहे के बने होते हैं ।](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.batching)
वस्तुओं को आकार या समय अंतराल द्वारा मिटाया जाने वाला है.
```csharp
using Mostlylucid.Ephemeral.Atoms.Batching;
await using var atom = new BatchingAtom(
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
```
---
### पर फिर कोशिश करें
> **पैकेज:** [आम तौर पर, सा. यु. पू.](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.retry)
बैकऑफ राइपर फिर से कोशिश करें.
```csharp
using Mostlylucid.Ephemeral.Atoms.Retry;
await using var atom = new RetryAtom(
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();
```
---
### डाटा भंडार अणु
> **पैकेज:** [अधिकतर सा. यु. पू.](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.data)
भंडार परमाणु के लिए साझा विन्यास (S)`DataStorageConfig`, `IDataStorageAtom`( ख) साथ ही, अधिवेशनों में जो खास अधिवेशन आते हैं, वे किन अधिवेशनों में शामिल होते हैं?
```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(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) अटलता के लिए कार्यान्वयन, संकेत लगन से आग्रह किया गया है. विशेषता कार्य सदस्यता ले सकते हैं `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")`) तो बाकी की प्रणाली लेने
बल्ला.
---
### बाल - बाल बढ़ता जा रहा है
> **पैकेज:
> ** [अधिकतर सहवास. Pacenter.ms. scutingiks.](https://www.nuget.org/packages/mostlylucid.ephemeral.atoms.slidingcache)
कैशिंग एक्सपायरेशन के साथ - इसके TTL को रीसेट कर रहा है.
```csharp
using Mostlylucid.Ephemeral.Atoms.SlidingCache;
await using var cache = new SlidingCacheAtom(
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}");
```
### एपम्रॉल- टोन्
> **पैकेज:** कोर (e)`mostlylucid.ephemeral`) — खुद को स्व-शित कर रहा है प्रत्येक हिट पर टीटीएल और टीएल के लिए विस्तारित
> गर्म कुंजियाँ.
```csharp
using Mostlylucid.Ephemeral;
var cache = new EphemeralLruCache(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` रिकॉर्ड आप के द्वारा रोक सकते हैं `OperationEchoAtom`.
```csharp
var sink = new SignalSink();
var typedSink = new TypedSignalSink(sink);
var echoAtom = new OperationEchoAtom(async echo => await repository.AppendAsync(echo));
await using var coordinator = new EphemeralWorkCoordinator(ProcessAsync);
using var maker = coordinator.EnableOperationEchoing(
typedSink,
echoAtom,
new OperationEchoMakerOptions
{
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);
```
---
### सिग्नल Caseukraine. kgm
> **पैकेज:
> ** [अधिकतर अल्पप्रयोगी. पैटर्न. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .](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(
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
```
---
### कंट्रोलFE (l)
> **पैकेज:
> ** [अधिकतर सौंडी। पैटर्न।](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.controlledfanout)
नियंत्रण समानांतरता के लिए वैश्विक + प्रति कुंजी.
```csharp
using Mostlylucid.Ephemeral.Patterns.ControlledFanOut;
await using var fanout = new ControlledFanOut(
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();
```
---
### एडाप्टिव आइडेंशियलComment
> **पैकेज:
> ** [आमतौर पर माना जाता है ।](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.adaptiverate)
सिग्नल- युक्ति दर स्वचालित बैकऑफ के साथ सीमित है.
```csharp
using Mostlylucid.Ephemeral.Patterns.AdaptiveRate;
await using var service = new AdaptiveRateService(
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)
संकेतों पर आधारित रन टाइम निर्भर करता है.
```csharp
using Mostlylucid.Ephemeral.Patterns.DynamicConcurrency;
var sink = new SignalSink();
await using var demo = new DynamicConcurrencyDemo(
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)
प्रति-key आदेश के साथ प्राथमिकताएं सुरक्षित हैं.
```csharp
using Mostlylucid.Ephemeral.Patterns.KeyedPriorityFanOut;
await using var fanout = new KeyedPriorityFanOut(
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();
```
---
### प्रतिक्रिया
> **पैकेज:
> ** [अधिकतर अल्पप्रयोगित। पैटर्न।](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.reactivefanout)
दो मंच स्वचालित पीठ के साथ कदम.
```csharp
using Mostlylucid.Ephemeral.Patterns.ReactiveFanOut;
await using var pipeline = new ReactiveFanOutPipeline(
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)
जा रही एक ram पूरी तरह से पता चल रहा है.
```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(
body,
new EphemeralOptions
{
DeferOnSignals = new HashSet { "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
```
---
### सिग्नलीकरण_BAR_
> **पैकेज:
> ** [अधिकतर सौंडी. पैटर्न. साइनिंग http.](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signalinghttp)
एचटीटीपी क्लाएंट प्रगति संकेत के साथ.
```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
```
---
### सिग्नल- स्टारर
> **पैकेज:
> ** [अधिकतर अल्पपारीड. पैटर्न. साइन-बोर्डर](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.signallogwatcher)
पैटर्न के लिए संकेत विंडो देखें तथा कॉलबैकss.
```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)
```
---
### ह्यूमर चिह्न
> **पैकेज:
> ** [अधिकतर अल्पप्रयोगित। पैटर्न।](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.telemetry)
खोलना/ इंसाइट ऑन द स्क्रिप्चर्स् एकीकरण है.
```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();
```
---
### लंबा विंडो आयामीमो
> **पैकेज:
> ** [आम तौर पर अष्टि। पैटर्न।](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
```
---
### एसिंक चिह्नीय विंडोComment
> **पैकेज:
> ** [अधिकतर सा. यु. पू.](https://www.nuget.org/packages/mostlylucid.ephemeral.patterns.persistentwindow)
सिग्नल विंडो के साथ साफ - सफाई से बचने की प्रक्रिया फिर से चालू होती है.
```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(
async (item, ct) => await ProcessAsync(item, ct),
new EphemeralOptions { MaxConcurrency = 8 });
// Named coordinators
services.AddEphemeralWorkCoordinator("priority",
async (item, ct) => await ProcessPriorityAsync(item, ct));
// Inject and use
public class MyService(IEphemeralCoordinatorFactory factory)
{
public async Task DoWork()
{
var coordinator = factory.CreateCoordinator();
await coordinator.EnqueueAsync(new WorkItem());
}
}
```
आधुनिक पतन जड़ें शायद छोटे सहायकों को पसन्द करे `services.AddCoordinator(...)`,
`services.AddScopedCoordinator(...)`, या `services.AddKeyedCoordinator(...)` क्योंकि वे सामान्य की तरह पढ़ते हैं
`AddX` पंजीकरण करता है; वे सिर्फ एपीअल-फ के नीचे सह सहायकों को प्रतिनिधि.
---
## लक्ष्य फ्रेमवर्क
- . WEERT , 7. 0, 8. 0, 9. 0, 1. 0
## लाइसेंस
अनधिकृत (सार्वजन डोमेन)