# Погоня і Дон *Досить* Забудьте про - Недовгострокове страти без держави

<!--category-- ASP.NET, Architecture, CQRS, Systems Design, Async, Privacy-Safe Design -->
<datetime class="hidden">2025-12-12T12:00</datetime>

Більшість асинхічних систем пам 'ятають або надто багато ( журналів , чергах МSK2 нестерпного сміття, якого ви ніколи не хотіли M SK3 або взагалі нічого не пам' ятають МSK4 спалаху М SK5 і - забувайте про чорні діри, які зникають в момент, коли щось не так

У цьому artykule представлено щось інше:

> Pattern, де кожна асинкова операція стає крихітною **відслідковується**, **можна перевірити**, **re-вмикається**, **self- утилізація** - і вся система залишається приватною , обмеженою M SK2 швидкою , та детерміністичною МSK4

Це співвідповідатель мого попереднього artykułу **[Усвідомлення LRUs - Коли надмірна спроможність робить вашу систему кращою](/blog/learning-lrus-when-capacity-makes-systems-better)**. Ми дослідили, як обмежена пам 'ять + перетворюється на механізм виживання

Цей досліджує іншу половину **обмежена, efeмерна страта** - як крихітний переміщований буфер активних завдань стає розладником , журналом подій МSK2 і двигуном повторюваності M SK3 не зберігаючи жодних даних користувача

Ось приклад з мого блогу. ' виджет для перекладу.

Це **Частина 1** двохкомпонентної серії

- **Частина 1 МSK1 цей artykułM SK2**: Теорія МSK1 схема МSK2 і реальний - приклад світу
- **[Частина 2: Збудувати поновлювану ефемеральну бібліотеку для виконання](/blog/ephemeral-execution-library)**: Полне втілення з інтеграцією DI

## NUGET!!!

Тепер це також є у mostlylucid.ephemerals Nuget пакеті [більше, ніж 20 переважно зрозумілийM SK1нефемеральні шаблони і МSK2атоми](https://www.nuget.org/packages?q=mostlylucid.ephemeral&includeComputedFrameworks=true&prerel=true&sortby=created-desc).

[![NuGet](https://img.shields.io/nuget/v/mostlylucid.ephemeral.svg)](https://www.nuget.org/packages/mostlylucid.ephemeral)
[![Ліцензія](https://img.shields.io/badge/license-Unlicense-blue.svg)](../../UNLICENSE)

[TOC]

---


## Źródлі

Полний код є в [mostlylucid.atoms - база GitHub](https://github.com/scottgal/mostlylucid.atoms)

## Проблема -Async Workflows Створити прихований стан

ASP. NET розробники схильні вибирати з трьох поганих варіантів

### Огонь

Ви `Task.Run()` щось. МСК0. Сподіваюсь, що воно закінчиться. МSK1. І коли воно вибухне, ви нічого не отримаєте. .. Жодна корреляція.

### Подождімо

Ви блокуєте ті потоки, які не повинні блокувати' не блокуєш . пропускна спроможність знижується МSK2 затримка вибухає M SK3 Ваші користувачі ненавидять вас .

### Вказівки в чергах

Тепер у вас є

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

### Розповсюджене відстеження

корисний… але зовнішній . також: він не здатнийM SK3 не відтворювати нічого і часто витікає дані, які ви ніколи не збиралися зберігати

Насправді ми хочемо

- **короткий-живий**
- **приватно**
- **непоганий**
- **можна перевірити**
- **обмежені**
- **можна отримати, якщо необхідно**
- **а потім пішов**

Пам 'ять про те, що робить система. - і нічого більше.

---


## Модель -Fire і *Не забудьте* Забудьте

Ось ідея в одній реченні

> **Відкрийте асинкну операцію негайно, відслідковуйте її експлицитно за допомогоюソース закінчування задачі, очистите її детерміністичноM SK2 і зберігайте крихітний переміщований буфер останніх кількох задач, щоб ви могли перевірити або отримати їх - без збереження будь-якого змісту для користувачаMSC4**

Він розташований на півдолі між

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

… без того, щоб ставати одним із нихM SK1

```mermaid
flowchart TB
    subgraph Client["Client Request"]
        R[Start Translation]
    end

    subgraph API["API Layer"]
        A[Create TaskId] --> B[Create TaskCompletionSource]
        B --> C[Queue to Channel]
        C --> D[Return TaskId Immediately]
    end

    subgraph Cache["Ephemeral Cache (Bounded)"]
        E[Store TranslateTask]
        F[Max 5 per user]
        G[6hr absolute / 1hr sliding expiry]
    end

    subgraph Worker["Background Worker"]
        H[Read from Channel]
        H --> I[Execute Translation]
        I --> J[Complete TCS]
    end

    R --> A
    B --> E
    E --> F --> G
    C --> H

    style Cache fill:none,stroke:#10b981,stroke-width:2px
    style Worker fill:none,stroke:#6366f1,stroke-width:2px
```

---


## Анатомія короткотривалого завдання

Коренная структура даних - `TranslateTask` - крихітна атомна реакція, підкріплена `Task<TaskCompletion>`:

```csharp
// From TranslateTask.cs
public class TranslateTask(
    string taskId,
    DateTime startTime,
    string language,
    Task<TaskCompletion>? task)
    : TranslateResultTask(taskId, startTime, language)
{
    public Task<TaskCompletion>? Task { get; init; } = task;
}

public record TaskCompletion(
    string? TranslatedMarkdown,
    string OriginalMarkdown,
    string Language,
    bool Complete,
    DateTime? EndTime);
```

Він містить:

- Уникальний ID ( співвідноситься з усім потоком
- Часовий знак ( коли він починавсяM SK1
- Метадані (зразок мови -не пользовательський контент МSK2
- Відказ на реальну `Task<TaskCompletion>`
- Тривалість (рахунки на доступіM SK1
- Статуй помилки (походить від стату задачі)
- кінцевий результат ( тільки якщо закінчено успішноM SK1

Це так. МСК0 - це воно. МSK1 - Нічого не залишилося. . - Ніхто не було написано на диск. МСК3 - Ніщо не зберігається за бортовим вікном

AWS має функції кроку. А Azure має тривалі функції. У вас єM SK2 30 ряди коду, які не потребуютьМSK4 не потребують хмарного купюра .

---


## Patternソース закінчування завдання -Запамотування пожежі -иM SK2Forget to Fire-andMSC4Track

Магія відбувається в `BackgroundTranslateService`. Замість пожежі , - і МSK2 забудьте . [Źródło завершення завдання](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskcompletionsource-1) -а обіцянкаM SK1подібна конструкції, яка дає нам можливість негайно повернутися, поки робота відбувається в фоні .

```csharp
// From BackgroundTranslateService.cs
private readonly Channel<(PageTranslationModel, TaskCompletionSource<TaskCompletion>)>
    _translations = Channel.CreateUnbounded<(PageTranslationModel, TaskCompletionSource<TaskCompletion>)>();

private async Task<Task<TaskCompletion>> Translate(PageTranslationModel message)
{
    // Create a TaskCompletionSource that will eventually hold the result
    var tcs = new TaskCompletionSource<TaskCompletion>();

    // Send the translation request along with the TCS to be processed
    await _translations.Writer.WriteAsync((message, tcs));

    // Return the Task immediately -caller can await it or check status later
    return tcs.Task;
}
```

### Що це?

Якщо ви не користувались `TaskCompletionSource<T>` до того, як **обіцяю, що ви контролюєте їх ручно**. На відміну від звичайного `Task` що закінчується, коли робота завершена, *ти* виклик `SetResult()`, `SetException()`, або `SetCanceled()`.

Це дозволяє вам

1. Поверніть `Task` негайно до телефону
2. Зробіть реальну роботу деінде. (різноманітний нитьM SK1 фонова служба, і т.д.
3. Завершити завдання, коли *ти* вирішити, що це зроблено

"" МСК0 "" - це міст між МСК1, МСК2 і МСК3, забути МСК4 та МСК5, МSK6 і МSK7, трамвай МСК8

---


## Лаyer API -Початок перекладу

Коли пользователь натискає "Перевести",, фронтальний інтерфейс набирає API

```javascript
// From translations.js
fetch('/api/translate/start-translation', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
        Language: shortCode,
        OriginalMarkdown: markdown
    })
})
.then(response => response.json())
.then(taskId => {
    // Got a taskId immediately -translation is running in background
    console.log("Task ID:", taskId);

    // Poll for updates via HTMX
    htmx.ajax('get', "/editor/get-translations", {
        target: '#translations',
        swap: 'innerHTML'
    });
});
```

API повертається негайно, лише за допомогою ID завдання:

```csharp
// From TranslateAPI.cs
[HttpPost("start-translation")]
public async Task<Results<Ok<string>, BadRequest<string>>> StartTranslation(
    [FromBody] MarkdownTranslationModel model)
{
    if (!backgroundTranslateService.TranslationServiceUp)
        return TypedResults.BadRequest("Translation service is down");

    // Create a unique identifier for this translation task
    var taskId = Guid.NewGuid().ToString("N");
    var userId = Request.GetUserId(Response);

    // Trigger translation -returns Task<TaskCompletion> immediately
    var translationTask = await backgroundTranslateService.Translate(model);

    // Wrap it in our trackable TranslateTask
    var translateTask = new TranslateTask(taskId, DateTime.Now, model.Language, translationTask);

    // Store in the ephemeral cache (bounded, self-cleaning)
    translateCacheService.AddTask(userId, translateTask);

    // Return the task ID to the client -they can poll for status
    return TypedResults.Ok(taskId);
}
```

Відповідь є миттєвою. Фактичний переклад працює в фоні. Пользователь може перевірити або просто дивитись на поновлення інтерфейсуM SK2

---


## Рабочий вікно для Rolling Operation -A Self-Cleaning Buffer

Найголовніша ідея [Статья LRU](/blog/learning-lrus-when-capacity-makes-systems-better) і тут також:

> **Утримуйте достатньо історій, щоб розв 'язати проблему та розібратися про систему… і дозволити природній зруйнування стирати все іншеM SK1**

```csharp
// From TranslateCacheService.cs
public class TranslateCacheService(IMemoryCache memoryCache)
{
    public void AddTask(string userId, TranslateTask task)
    {
        if (memoryCache.TryGetValue(userId, out CachedTasks? tasks))
        {
            var currentTasks = tasks?.Tasks ?? new List<TranslateTask>();
            currentTasks = currentTasks.OrderByDescending(x => x.StartTime).ToList();

            // Keep only the 5 most recent tasks -bounded window
            if (currentTasks.Count >= 5)
            {
                var lastTask = currentTasks.Last();
                currentTasks.Remove(lastTask);
            }

            currentTasks.Add(task);
            currentTasks = currentTasks.OrderByDescending(x => x.StartTime).ToList();
            tasks!.Tasks = currentTasks;

            memoryCache.Set(userId, tasks, new MemoryCacheEntryOptions
            {
                AbsoluteExpiration = tasks.AbsoluteExpiration,
                SlidingExpiration = TimeSpan.FromHours(1)
            });
        }
        else
        {
            // First task for this user
            var cachedTasks = new CachedTasks
            {
                Tasks = new List<TranslateTask> { task },
                AbsoluteExpiration = DateTime.Now.AddHours(6)
            };
            memoryCache.Set(userId, cachedTasks, new MemoryCacheEntryOptions
            {
                AbsoluteExpiration = cachedTasks.AbsoluteExpiration,
                SlidingExpiration = TimeSpan.FromHours(1)
            });
        }
    }

    public List<TranslateTask> GetTasks(string userId)
    {
        if (memoryCache.TryGetValue(userId, out CachedTasks? tasks))
            return tasks?.Tasks ?? new List<TranslateTask>();
        return new List<TranslateTask>();
    }

    private class CachedTasks
    {
        public List<TranslateTask> Tasks { get; set; } = new();
        public DateTime AbsoluteExpiration { get; set; }
    }
}
```

Кожна нова задача:

- Додається до roling window użytkownika'
- Викидає найстаріший, якщо ми
- Він випаровується цілковито після 6 годин неактивності

```mermaid
flowchart LR
    subgraph Window["Per-User Task Window (Max 5)"]
        T1[Oldest Task] --- T2[Older] --- T3[Recent] --- T4[Newer] --- T5[Newest]
    end

    New[New Task] -->|Enqueue| Window
    T1 -->|Evicted| Gone[(Expired)]

    style Window fill:none,stroke:#10b981,stroke-width:2px
    style Gone fill:none,stroke:#ef4444,stroke-width:2px
```

Ніяких ризиків зберігання. Ніяких ПII в кэші МSK1правильні ID-показки на задачуM SK2 тайм-тампы, і мовні кодиMSC4 Ніхто не стикається з GDPR

---


## Обмежена конкуренція - Губернаторська петля

Ця служба реалізує **постійне співпадіння** цикл з використанням читача каналу і `Task.WhenAny`:

```csharp
// From BackgroundTranslateService.cs
private async Task TranslateFilesAsync(CancellationToken cancellationToken)
{
    var processingTasks = new List<Task>();

    while (!cancellationToken.IsCancellationRequested)
    {
        // Fill up to IPCount concurrent tasks (e.g., 4 parallel translations)
        while (processingTasks.Count < markdownTranslatorService.IPCount &&
               !cancellationToken.IsCancellationRequested)
        {
            var item = await _translations.Reader.ReadAsync(cancellationToken);
            var translateModel = item.Item1;
            var tcs = item.Item2;

            // Start the task and add it to the list
            var task = TranslateTask(cancellationToken, translateModel, item, tcs);
            processingTasks.Add(task);
        }

        // Wait for ANY of the tasks to complete
        var completedTask = await Task.WhenAny(processingTasks);
        processingTasks.Remove(completedTask);

        // Handle exceptions if needed
        try
        {
            await completedTask;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error translating markdown");
        }
    }
}
```

Це як **губернатор на паровому двигуні**: більше навантаження МSK1 зворотний тиск збудовує

Модель дає вам:

- **Жодна спираль з перенавантаженням** -canM SK1t spawn unlimited tasks
- **Soft real-time behaviour** - обмежена затримка
- **Природне зглаżenie пульсів** -kanal buffers the spikes
- **Стабільність під навантаженням** - граційно деградує

---


## Завершення проекту Завершене джерело zadań .

Коли робота над перекладом закінчується, ми завершимо

```csharp
// From BackgroundTranslateService.cs
private async Task TranslateTask(
    CancellationToken cancellationToken,
    PageTranslationModel translateModel,
    (PageTranslationModel, TaskCompletionSource<TaskCompletion>) item,
    TaskCompletionSource<TaskCompletion> tcs)
{
    try
    {
        await retryPolicy.ExecuteAsync(async () =>
        {
            // Do the actual translation work
            var translatedMarkdown = await markdownTranslatorService.TranslateMarkdown(
                translateModel.OriginalMarkdown,
                translateModel.Language,
                cancellationToken);

            // SUCCESS: Complete the TCS with the result
            tcs.SetResult(new TaskCompletion(
                translatedMarkdown,
                translateModel.OriginalMarkdown,
                translateModel.Language,
                true,
                DateTime.Now));
        });
    }
    catch (TranslateException e)
    {
        // FAILURE: Complete the TCS with an exception
        tcs.SetException(new Exception($"Translation failed after 3 retries: {e.Message}"));
    }
    catch (Exception e)
    {
        // UNEXPECTED: Complete the TCS with the exception
        tcs.SetException(e);
    }
}
```

Телефон: 's `Task<TaskCompletion>` -, які вони отримали одразу, коли зателефонували `Translate()` - тепер закінчується . Вони можуть МSK2

- `await` якщо вони хочуть блокувати
- Проверка `IsCompleted` для опитування
- Проверка `IsFaulted` щоб перевірити, чи він провалився
- Проверка `Result` щоб отримати перекладений контент

---


## Проекція статусу -Статистика, що випливає з стану завдання

Коли ми показуємо завдання пользователю, ми проектуємо реальний стан завдання в модель widokу.

```csharp
// From TranslateTask.cs
public TranslateResultTask(TranslateTask task, bool includeMarkdown = false)
{
    TaskId = task.TaskId;
    StartTime = task.StartTime;
    Language = task.Language;

    // Check for faulted state first -a faulted task is also "completed" in .NET terms
    if (task.Task?.IsFaulted == true)
    {
        Failed = true;
        Completed = false;
        TotalMilliseconds = (int)(DateTime.Now - task.StartTime).TotalMilliseconds;
    }
    else if (task.Task?.IsCompletedSuccessfully == true)
    {
        Completed = true;
        Failed = false;
        var endTime = task.Task.Result.EndTime;
        TotalMilliseconds = (int)((endTime - task.StartTime)!).Value.TotalMilliseconds;
        EndTime = endTime;
    }
    else
    {
        // Still in progress
        Completed = false;
        Failed = false;
        TotalMilliseconds = (int)(DateTime.Now - task.StartTime).TotalMilliseconds;
    }

    if (Completed && includeMarkdown)
    {
        var result = task.Task?.Result;
        if (result == null) return;
        OriginalMarkdown = result.OriginalMarkdown;
        TranslatedMarkdown = result.TranslatedMarkdown;
    }
}
```

### Запис про стан завдання

МSK0NET's `Task` має деякі дивні станові комбінації:

- `IsCompleted` є правдою для **обидві** успішне виконання і неправильні завдання
- `IsCompletedSuccessfully` лише для успіху
- `IsFaulted` означає, що він кинув винятку
- `IsCanceled` означає, що вона була відменена

Тому ви повинні перевірити `IsFaulted` перед перевіркою `IsCompleted`, або ви ' ставитесь до невдачі як до успіху

---


## Веб-сайт -HTMX

Виглядання опитування щодо оновлень за допомогою HTMX's `hx-trigger`:

```html
@* From _GetTranslations.cshtml *@
@{
    var allCompleted = Model.All(x => x.Completed);
    var trigger = allCompleted ? "none" : "every 5s";
}

<div class="translationpoller"
     hx-get="/editor/get-translations"
     hx-swap="outerHTML"
     hx-trigger="@trigger">
    <table class="table">
        @foreach (var item in Model)
        {
            <tr>
                <td>
                    @if (item.Completed)
                    {
                        <a href="#" x-on:click.prevent="viewTranslation('@item.TaskId')">View</a>
                    }
                    else if (item.Failed)
                    {
                        <text>Failed</text>
                    }
                    else
                    {
                        <text>Processing</text>
                    }
                </td>
                <td>
                    @if (item.Completed)
                    {
                        <i class='bx bx-check text-green'></i>
                    }
                    else if (item.Failed)
                    {
                        <i class='bx bx-x text-red'></i>
                    }
                    else
                    {
                        <img src="~/img/3-dots-bounce.svg" />
                    }
                </td>
                <td>@item.Language</td>
                <td>@TimeSpan.FromMilliseconds(item.TotalMilliseconds).Humanize()</td>
            </tr>
        }
    </table>
</div>
```

Розумний біт: `hx-trigger="@trigger"` зміни на основі stanu:

- Якщо завдання все ще продовжуються: кожні M SK1 секунди
- Якщо всі завдання завершені: перестань голосувати M SK1`"none"`)

Це **саморегулююче голосування** - він зупиняється автоматично, коли немає нічого для перегляду

---


## Перейдемо до результату

Коли użytkownik натискає "View", ми отримуємо повний переклад

```csharp
// From TranslateAPI.cs
[HttpGet("get-translation/{taskId}")]
public async Task<Results<JsonHttpResult<TranslateResultTask>, BadRequest<string>>> GetTranslation(
    string taskId)
{
    var userId = Request.GetUserId(Response);
    var tasks = translateCacheService.GetTasks(userId);

    var translationTask = tasks.FirstOrDefault(t => t.TaskId == taskId);
    if (translationTask == null)
        return TypedResults.BadRequest("Task not found");

    // Include the markdown content in the response
    var result = new TranslateResultTask(translationTask, includeMarkdown: true);
    return TypedResults.Json(result);
}
```

Тоді JavaScript заповнює редактор:

```javascript
// From translations.js
export function viewTranslation(taskId) {
    fetch(`/api/translate/get-translation/${taskId}`)
        .then(response => response.json())
        .then(data => {
            // Show the translated content area
            document.getElementById("translatedcontent").classList.remove("hidden");

            // Populate the editors
            var originalMde = window.mostlylucid.simplemde.getinstance('translatedcontentarea');
            originalMde.value(data.originalMarkdown);

            var mde = window.mostlylucid.simplemde.getinstance('markdowneditor');
            mde.value(data.translatedMarkdown);
        });
}
```

---


## Чому це конфіденційне-Безпека

Бо:

- **Ніхто не зберігає контенту користувача в кэші.** -только метадані задачі МSK1IDM SK2 тайм-шап МSK3 мова )
- **Контент існує лише в результаті Задачі'** -, який є в пам 'яті , прикріплений до Задачі
- **Окно обмежене** -max МSK1 завдання на одного користувачаM SK2 max 6 часове пам 'ять
- **Все руйнується природно** -забігання терміну вичерпає неактивних користувачів
- **Ніщо не торкається диска** - немає журналівM SK1 немає чергов , немає бази даних
- **Ви не можете випадково зберегти PII** МСК0, там , ', там немає куди йти .

Це архітектура *Я хотів би, щоб браузери і фронтальні фреймворки використовувались для операцій на сеансі*.

---


## З 'являється поведінка

Що ви отримуєте, не думаючи надто сильно:

МSK0 Прибутки | Як МSK2
|---------|-----|
| **Стабільність** | Об 'єднане співпадіння через канал + шаблон семпора МSK2
| **Негативний зворотній зв 'язок** | Більше навантаження МSK1 тиск спини МSK2 обмежена пам 'ять → послідовне поведінку мSK4
| **Відтворюваність** | Точні операції існують досить довго, щоб перевірити
| **Здатність отримати інформацію** | Завершені результати доступні доти, поки вони не закінчуються
| **Нульове зберігання даних** | Prywatність і простота збалансовані один раз |
| **Самої оптимізації виконання** | Старі завдання зникають , важливі залишаються

Так само, як Cache LRU остриблює поведінкову пам 'ять,, операційне вікно rolling operation window sharpens the execution view.

---


## Коли використовувати цей візерунок

Використовуйте його, коли:

- Дані користувача не можуть існувати
- Операції короткі-живі МSK1секунд до хвилинM SK2
- Справа з виправленням
- Питання приватності
- Рівень стійкості навантаження
- Ви хочете миттєву відповідь + обробки фону

Не використовувати його, коли

- Вам потрібна справжня довготривалість (используйте реальну чергу МSK1
- Операція триває годинами (используйте Hangfire або щось подібне )
- Вам потрібно точно-одної семантики M SK1используйте розподілену транзакцію)
- Множество серверів мають координувати ( використати Redis або посередника повідомленьM SK1

---


## Завершення -Ефемеричне виконання як філософія дизайну

Якщо [Статья LRU](/blog/learning-lrus-when-capacity-makes-systems-better) про **навчаючись забуваючи**, це про **шляхом випаровування**.

Система пам 'ятає достатньо, щоб бути корисною. - і нічого більше.

МSK0, МSK1

- обмежені
- детерміністична
- приватно
- непоганий
- відновлюваний
- self-czyszczenie
- міцний
- і архітектура-перша

Найкраще те, що ви знаєте `TaskCompletionSource`, a `Channel`, `IMemoryCache` з знижуванням терміну служби, і другорядним працівникомM SK1

**Огонь… і ДонM SK1 Не забувайш.**

---


## Що' СледующаяM SK1

В **[Частина 2: Збудувати поновлювану ефемеральну бібліотеку для виконання](/blog/ephemeral-execution-library)**МСК0 ми ' перетворимо цю модель на крапку - в помічнику МSK3

- `EphemeralForEachAsync<T>` - як `Parallel.ForEachAsync` але з операційним стеженням
- Кільовані труби для послідовного виконання entités per-
- `EphemeralWorkCoordinator<T>` - довга МSK1 тривалий обсерваційний робочий ряд
- Надіслані/координаторами з `AddEphemeralWorkCoordinator<TCoordinator>` ( як `AddHttpClient`)
- Полна інтеграція з Шкопером іシングルтоном
- Порівняння з іншими підходами (TPL Dataflow , ChannelsM SK2 Background Services)

---


## Ліки

- [Усвідомлення LRUs - Коли надмірна спроможність робить вашу систему кращою](/blog/learning-lrus-when-capacity-makes-systems-better) -довідник статті про обмежену пам 'ять
- [Частина 2: Збудувати поновлювану ефемеральну бібліотеку для виконання](/blog/ephemeral-execution-library) - повне втілення
- [Дослідженняソース завершення завдання](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskcompletionsource-1) -Microsoft's Docs на шаблоні TCS
- [Система.ThreadingM SK1Channels](https://learn.microsoft.com/en-us/dotnet/core/extensions/channels) -продюсерM SK1примітивний споживач, який ми використовуємо
- [Документація IMemoryCache](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/memory) -ASPM SK1NET'сконструйовані -вキャッシュі