async-programming
/async-programming
Async programming patterns with UniTask, cancellation tokens, and exception handling. Use when writing async code, handling CancellationTokenSource lifecycle, using SuppressToResultAsync, implementing detached UniTask/UniTaskVoid flows, or working with Result/EnumResult types for exception-free flow propagation.
- Author
- decentraland ↗
- Repository
- unity-explorer ↗
- Licence
- Apache-2.0
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Async programming patterns with UniTask, cancellation tokens, and exception handling. Use when writing async code, handling CancellationTokenSource lifecycle, using SuppressToResultAsync, implementing detached UniTask/UniTaskVoid flows, or working with Result/EnumResult types for exception-free flow propagation.
Original author description
Async programming patterns with UniTask, cancellation tokens, and exception handling. Use when writing async code, handling CancellationTokenSource lifecycle, using SuppressToResultAsync, implementing detached UniTask/UniTaskVoid flows, or working with Result/EnumResult types for exception-free flow propagation.
How it works
- Sources
- Core Rules
- Exception Handling Pattern
- SuppressToResultAsync Pattern
- Result and EnumResult Types
- Cancellation Token Management
SKILL.md preview
---
name: async-programming
description: "Async programming patterns with UniTask, cancellation tokens, and exception handling. Use when writing async code, handling CancellationTokenSource lifecycle, using SuppressToResultAsync, implementing detached UniTask/UniTaskVoid flows, or working with Result/EnumResult types for exception-free flow propagation."
user-invocable: false
---
# Async Programming Patterns
## Sources
- `docs/async-programming.md` — Async pattern guidelines for UniTask flows
- `docs/architecture-overview.md` — Result struct and exception-free flow details
---
## Core Rules
> Condensed rules are in CLAUDE.md §9. This skill provides expanded patterns and code examples not covered there.
## Exception Handling Pattern
### Wrong — Unhandled exceptions in detached flow
```csharp
// BAD: Exception kills the flow silently
async UniTaskVoid DoSomethingAsync(CancellationToken ct)
{
var result = await webRequestController.GetAsync(args, ct);
// If this throws, nobody catches it
}
```
### Correct — Proper exception handling
```csharp
async UniTaskVoid DoSomethingAsync(CancellationToken ct)
{
try
{
var result = await webRequestController.GetAsync(args, ct);
ProcessResult(result);
}
catch (OperationCanceledException) { } // Normal cancellation — ignore
catch (Exception exception)
{
ReportHub.LogException(exception, ReportCategory.GENERIC_WEB_REQUEST);
}
}
```
### Code Example — Exception Handling in Controller
From `MinimapController.cs`:
```csharp
private async UniTask<PlacesData.PlaceInfo?> GetPlaceInfoAsync(
Vector2Int parcelPosition, CancellationToken ct, bool renewCache = false)
{
try
{
return await placesAPIService.GetPlaceAsync(parcelPosition, ct, renewCache);
}
catch (OperationCanceledException _) { }
catch (NotAPlaceException notAPlaceException)
{
ReportHub.LogWarning(ReportCategory.UNSPECIFIED,
$"Not a place requested: {notAPlaceException.Message}");
}
catch (Exception exception)
{
ReportHub.LogException(exception, ReportCategory.GENERIC_WEB_REQUEST);
}
return null;
}
```
## SuppressToResultAsync Pattern
Wraps a `UniTask<T>` in a try/catch and returns a `Result<T>` struct instead of throwing.
### Code Example — SuppressToResultAsync + Result
From `TokenFileAuthenticator.cs`:
```csharp
private async UniTask<IWeb3Identity> LoginAsync(CancellationToken ct)
{
if (!File.Exists(TOKEN_PATH))
throw new AutoLoginTokenNotFoundException();
// SuppressToResultAsync catches exceptions and wraps in Result<string>
Result<string> contentResult = await File.ReadAllTextAsync(TOKEN_PATH, ct)!
.SuppressToResultAsync<string>(ReportCategory.AUTHENTICATION);
if (contentResult.Success == false)
throw new Exception(contentResult.ErrorMessage ?? "Cannot read token file");
string token = contentResult.Value;
// ... continue with token ...
}
```
## Result and EnumResult Types
### Result Struct
Zero-cost value type for exception-free flow propagation:
```csharp
// Success
return Result<string>.SuccessResult(value);
// Error
return Result<string>.ErrorResult("Something went wrong");
// Check
if (result.Success)
UseValue(result.Value);
else
HandleError(result.ErrorMessage);
```
### REnum Union Types
Roslyn Source Generator for Rust-style enums. Zero-cost pattern matching:
```csharp
// Pattern matching via .Match()
result.Match(
success: value => ProcessValue(value),
error: msg => LogError(msg)
);
// Safe access via .IsXXX(out T)
if (result.IsSuccess(out var value))
ProcessValue(value);
```
## Cancellation Token Management
### CancellationTokenSource Lifecycle
From `MinimapController.cs` — proper CTS management:
```csharp
private CancellationTokenSource? placesApiCts;
protected override void OnFocus()
{
// Cancel any in-flight request
placesApiCts.SafeCancelAndDispose();
placesApiCts = new CancellationTokenSource();
RefreshPlaceInfoUIAsync(previousParcelPosition, placesApiCts.Token).Forget();
}
// SafeRestart = cancel + dispose + create new
private void OnFavoriteButtonClicked(bool value)
{
favoriteCancellationToken = favoriteCancellationToken.SafeRestart();
SetAsFavoriteAsync(favoriteCancellationToken.Token).Forget();
}
public override void Dispose()
{
placesApiCts.SafeCancelAndDispose();
disposeCts.Cancel();
favoriteCancellationToken.SafeCancelAndDispose();
}
```
**Key patterns:**
- `SafeCancelAndDispose()` — Cancel and dispose in one call, null-safe
- `SafeRestart()` — Cancel + dispose + create new CTS
- Always dispose CTS in `Dispose()`
- Use a dedicated `disposeCts` for operations that should cancel on controller disposal
### Cancellation Checking
```csharp
// CORRECT — Check without throwing (cheap)
if (ct.IsCancellationRequested)
return;
// WRONG — Throws exception (expensive)
ct.ThrowIfCancellationRequested();
```
Versions
The database has no other skills named async-programming.
Database snapshot: 13.11.2026 · package version c73e61a9d77f (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 91python-async-patterns
Comprehensive guide to Python async/await patterns, best practices, and anti-patterns. Covers asyncio fundamentals, coroutines, async context managers, task management, common libraries (aiohttp, aiofiles, asyncpg), framework integration (FastAPI, Django), performance… - 98error-handling-patterns
Design error handling strategies for TypeScript and Python applications — exception hierarchies, Result/Either types, retry patterns, error boundaries, and structured error logging. Use when designing error handling architecture, choosing between exceptions and Result types,… - 100rust-async-patterns
Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code. - 100async-drop
Guide to the AsyncDrop pattern for async cleanup in Rust. Use when working with AsyncDropGuard, implementing AsyncDrop trait, or handling async resource cleanup. - 100rust-async-patterns
Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code. - 100unity-game-dev
Use when working on Unity game projects, especially Unity 6, C# gameplay systems, UI Toolkit or UGUI, Addressables, Input System, UniTask, Onity, ServiceLocator, tests, performance, project structure, package setup, and Unity-specific architecture decisions.