### Install AsyncFixer via Package Manager

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Commands to add the AsyncFixer NuGet package to a project using the .NET CLI or PowerShell Package Manager.

```bash
dotnet add package AsyncFixer
```

```powershell
Install-Package AsyncFixer
```

--------------------------------

### Suppress AsyncFixer Warnings

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Example of how to suppress specific AsyncFixer warnings within C# code using pragma directives.

```csharp
#pragma warning disable AsyncFixer01
async Task<int> Method() => await SomeTaskAsync();
#pragma warning restore AsyncFixer01
```

--------------------------------

### Add AsyncFixer to .csproj file

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Demonstrates how to add the AsyncFixer NuGet package dependency directly to a C# project file (.csproj). This ensures the analyzer is included in the project's build process.

```xml
<ItemGroup>
  <PackageReference Include="AsyncFixer" Version="2.1.0">
    <PrivateAssets>all</PrivateAssets>
    <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
  </PackageReference>
</ItemGroup>
```

--------------------------------

### C# AsyncFixer01: Unnecessary async/await Usage

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Demonstrates the AsyncFixer01 rule, which identifies and suggests corrections for unnecessary async/await usage in C# methods. It shows how to refactor code to return Task directly, avoiding state machine allocation overhead, while also highlighting exceptions for using blocks and try/catch blocks.

```csharp
// BAD: Unnecessary async/await - allocates state machine for simple passthrough
public async Task<User> GetUserAsync(int id)
{
    return await _repository.GetUserAsync(id);
}

// GOOD: Direct task return - no state machine overhead
public Task<User> GetUserAsync(int id)
{
    return _repository.GetUserAsync(id);
}

// BAD: Expression-bodied async with unnecessary await
public async Task<int> GetValueAsync() => await _cache.GetAsync(key);

// GOOD: Expression-bodied direct return
public Task<int> GetValueAsync() => _cache.GetAsync(key);

// EXCEPTION: Keep async/await inside using blocks (disposal timing)
public async Task<string> ReadFileAsync(string path)
{
    using var reader = new StreamReader(path);
    return await reader.ReadToEndAsync();  // Keep - ensures disposal after completion
}

// EXCEPTION: Keep async/await in try/catch blocks (exception handling)
public async Task<Data> GetDataSafeAsync()
{
    try
    {
        return await _client.GetAsync();
    }
    catch (HttpException)
    {
        return Data.Empty;  // Can only catch if using await
    }
}

// Suppress for specific methods
#pragma warning disable AsyncFixer01
public async Task<int> MethodWithAsyncForDebugging() => await SomeTaskAsync();
#pragma warning restore AsyncFixer01
```

--------------------------------

### Resolve Nested Task Issues with TaskFactory.StartNew

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Addresses AsyncFixer05, which detects Task<Task> issues when using TaskFactory.StartNew with async lambdas. It demonstrates how to use Task.Run, Unwrap, or double-awaiting to ensure the inner task is correctly awaited.

```csharp
// BAD: StartNew with async lambda returns Task<Task>
public async Task ProcessAsync()
{
    Console.WriteLine("Start");
    await Task.Factory.StartNew(async () =>  // Returns Task<Task>!
    {
        await Task.Delay(1000);
    });
    Console.WriteLine("End");  // Prints immediately, doesn't wait 1 second!
}

// GOOD: Use Task.Run instead (handles async lambdas correctly)
public async Task ProcessAsync()
{
    Console.WriteLine("Start");
    await Task.Run(async () =>
    {
        await Task.Delay(1000);
    });
    Console.WriteLine("End");  // Correctly waits 1 second
}

// GOOD: Use Unwrap() to get inner task
public async Task ProcessAsync()
{
    Console.WriteLine("Start");
    await Task.Factory.StartNew(async () =>
    {
        await Task.Delay(1000);
    }).Unwrap();  // Unwrap gets the inner Task
    Console.WriteLine("End");  // Correctly waits 1 second
}

// GOOD: Double await
public async Task ProcessAsync()
{
    Console.WriteLine("Start");
    await await Task.Factory.StartNew(async () =>
    {
        await Task.Delay(1000);
    });
    Console.WriteLine("End");  // Correctly waits 1 second
}
```

--------------------------------

### Configure AsyncFixer Rules in EditorConfig

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

How to adjust the severity of AsyncFixer diagnostic rules using a standard .editorconfig file.

```ini
[*.cs]
dotnet_diagnostic.AsyncFixer01.severity = none
dotnet_diagnostic.AsyncFixer02.severity = error
dotnet_diagnostic.AsyncFixer03.severity = suggestion
```

--------------------------------

### Keeping Async/Await for Specific Scenarios in C#

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Illustrates scenarios where async/await should be retained, such as within using blocks for resource management, try/catch blocks for exception handling, and when multiple await expressions are present. This ensures correct behavior and stack trace preservation.

```csharp
// Keep async/await here - inside using block
async Task ProcessAsync()
{
    using var stream = new FileStream("file.txt", FileMode.Open);
    await stream.ReadAsync(buffer);  // Must await before disposal
}

// Keep async/await here - exception handling
async Task<Data> GetDataAsync()
{
    try {
        return await _client.GetAsync();
    } catch (HttpException) {
        return Data.Empty;
    }
}
```

--------------------------------

### AsyncFixer05 vs AsyncFixer06 Task Mismatch in C#

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Explains the difference between AsyncFixer05 (nested Task<Task<T>>) and AsyncFixer06 (implicit conversion Task<T> to Task), highlighting the problems they detect and how to fix them.

```csharp
// AsyncFixer05 - nested task: Task<Task>
Task task = Task.Factory.StartNew(() => DelayAsync());

// AsyncFixer06 - result discarded: Task<string> converted to Task
Func<Task> fn = () => GetDataAsync();  // GetDataAsync returns Task<string>
```

--------------------------------

### Eliding Unnecessary Async/Await in C#

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Demonstrates the performance benefits of removing unnecessary async/await keywords by directly returning Task objects instead of allocating state machines. This is recommended for simple passthrough methods.

```csharp
// ❌ Unnecessary overhead - allocates state machine
async Task<User> GetUserAsync(int id) => await _repository.GetUserAsync(id);

// ✅ Direct passthrough - no allocation, same behavior
Task<User> GetUserAsync(int id) => _repository.GetUserAsync(id);
```

--------------------------------

### Fix nested task downcasting with Unwrap or Task.Run

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Addresses the issue where Task.Factory.StartNew returns a nested Task, preventing proper awaiting. Recommends using Unwrap() or Task.Run() for cleaner execution.

```csharp
// ❌ Bad: StartNew returns Task<Task>, outer await completes immediately
async Task ProcessAsync()
{
    Console.WriteLine("Hello");
    await Task.Factory.StartNew(() => Task.Delay(1000)); // Returns Task<Task>!
    Console.WriteLine("World");  // Prints immediately, doesn't wait 1 second
}

// ✅ Good: Use Unwrap() or Task.Run()
async Task ProcessAsync()
{
    Console.WriteLine("Hello");
    await Task.Factory.StartNew(() => Task.Delay(1000)).Unwrap();
    // Or simply:
    await Task.Run(() => Task.Delay(1000));
    Console.WriteLine("World");  // Waits 1 second
}
```

--------------------------------

### Refactor async-void methods to async-Task

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Demonstrates how to avoid process crashes by replacing async-void methods with async-Task, allowing exceptions to be properly caught by the caller.

```csharp
// ❌ Bad: async void - exceptions will crash the process
async void ProcessDataAsync()
{
    await Task.Delay(1000);
    throw new Exception("Oops!"); // Crashes the app!
}

// ✅ Good: async Task - exceptions can be caught
async Task ProcessDataAsync()
{
    await Task.Delay(1000);
    throw new Exception("Oops!"); // Can be caught by caller
}
```

--------------------------------

### Handle Implicit Task<T> to Task Conversions

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Addresses AsyncFixer06, which flags non-async lambdas where Task<T> is implicitly converted to Task, causing the result to be discarded. It shows how to use correct delegate types or explicit handling to preserve results.

```csharp
// BAD: Task<string> silently converted to Task, result discarded
Func<Task> fn = () => GetDataAsync();  // GetDataAsync returns Task<string>
await fn();  // The string result is lost forever!

// GOOD: Use correct delegate type to preserve result
Func<Task<string>> fn = () => GetDataAsync();
var result = await fn();  // Result is accessible

// GOOD: Explicit discard if result truly not needed
Func<Task> fn = async () => { _ = await GetDataAsync(); };
```

--------------------------------

### Suppress AsyncFixer Diagnostics

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Demonstrates multiple ways to suppress AsyncFixer diagnostics, including inline pragma, SuppressMessage attributes, assembly-level suppression, and EditorConfig configuration.

```csharp
// Method 1: Inline pragma (single occurrence)
#pragma warning disable AsyncFixer01
public async Task<int> Method() => await SomeTaskAsync();
#pragma warning restore AsyncFixer01

// Method 2: SuppressMessage attribute (method or class level)
[System.Diagnostics.CodeAnalysis.SuppressMessage("AsyncUsage", "AsyncFixer01")]
public async Task<int> Method() => await SomeTaskAsync();

// Method 3: Assembly-level suppression (GlobalSuppressions.cs)
[assembly: SuppressMessage("AsyncUsage", "AsyncFixer01",
    Justification = "Performance not critical in this assembly")]

// Method 4: EditorConfig (project-wide)
// [*.cs]
// dotnet_diagnostic.AsyncFixer01.severity = none
```

--------------------------------

### AsyncFixer04: Detect Unawaited Async Calls in Using Blocks (C#)

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Flags asynchronous operations initiated within a 'using' block that are not awaited. This can lead to the disposable resource being disposed before the asynchronous operation completes, potentially causing errors or data loss. The fix involves awaiting the async call within the 'using' block. This applies to both standard 'using' statements and 'using var' declarations.

```csharp
// BAD: Stream disposed before copy completes
public void CopyFileAsync(string source, string dest)
{
    using (var stream = new FileStream(source, FileMode.Open))
    {
        stream.CopyToAsync(destStream);  // AsyncFixer04: Fire-and-forget!
    }  // stream.Dispose() called here - CopyToAsync may still be running!
}

// GOOD: Await the async operation
public async Task CopyFileAsync(string source, string dest)
{
    using (var stream = new FileStream(source, FileMode.Open))
    {
        await stream.CopyToAsync(destStream);  // Completes before disposal
    }
}

// BAD: using var declaration (C# 8.0+) with returned task
public Task<string> ReadAsync(string path)
{
    using var reader = new StreamReader(path);
    return reader.ReadToEndAsync();  // AsyncFixer04: reader disposed on method exit!
}

// GOOD: Keep async/await with using var
public async Task<string> ReadAsync(string path)
{
    using var reader = new StreamReader(path);
    return await reader.ReadToEndAsync();  // Completes before disposal
}

// SAFE: Task assigned and awaited within same block
public async Task ProcessWithTimeoutAsync(CancellationToken ct)
{
    using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
    var task = DoWorkAsync(cts.Token);
    await Task.WhenAny(task, Task.Delay(5000));  // OK - task is used within block
}
```

--------------------------------

### AsyncFixer03: Detect Async Void Methods and Delegates (C#)

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Identifies 'async void' methods and delegates, which can lead to unhandled exceptions crashing the application. It recommends using 'async Task' return types for proper error propagation and handling by the caller. Event handlers are an exception and are permitted to be 'async void' due to their fire-and-forget nature.

```csharp
// BAD: async void - unhandled exceptions crash the process
public async void ProcessDataAsync()
{
    await Task.Delay(1000);
    throw new Exception("Oops!");  // Crashes the application!
}

// GOOD: async Task - exceptions can be caught by caller
public async Task ProcessDataAsync()
{
    await Task.Delay(1000);
    throw new Exception("Oops!");  // Caller can catch this
}

// BAD: async void delegate
Action callback = async () =>
{
    await Task.Delay(100);
    throw new Exception("Silent crash!");
};

// GOOD: Func<Task> delegate
Func<Task> callback = async () =>
{
    await Task.Delay(100);
    throw new Exception("Can be awaited and caught!");
};

// EXCEPTION: Event handlers are allowed to be async void
private async void Button_Click(object sender, EventArgs e)
{
    await LoadDataAsync();  // OK - event handlers are fire-and-forget by design
}

// EXCEPTION: Methods with EventArgs parameter are not flagged
private async void OnDataReceived(object sender, DataReceivedEventArgs e)
{
    await ProcessAsync(e.Data);  // OK - event handler pattern
}
```

--------------------------------

### Fix Unnecessary Async/Await Usage

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Demonstrates removing unnecessary async/await modifiers when a task can be returned directly, improving performance.

```csharp
// Bad
async Task<int> GetValueAsync() {
    return await _cache.GetAsync(key);
}

// Good
Task<int> GetValueAsync() {
    return _cache.GetAsync(key);
}
```

--------------------------------

### AsyncFixer02: Detect Blocking Calls in Async Methods (C#)

Source: https://context7.com/semihokur/asyncfixer/llms.txt

Identifies synchronous blocking calls within async methods that should be replaced with their asynchronous counterparts to prevent deadlocks. It offers automatic code fixes for common blocking patterns like .Result, Task.WaitAll, and Thread.Sleep, suggesting awaitable alternatives. Exceptions are made for accessing .Result after Task.WhenAll and short Thread.Sleep durations.

```csharp
// BAD: Blocking calls can cause deadlocks in UI/ASP.NET contexts
public async Task ProcessDataAsync()
{
    var result = GetDataAsync().Result;  // AsyncFixer02: Use 'await' instead of 'Result'
    Thread.Sleep(1000);                   // AsyncFixer02: Use 'Task.Delay' instead
    Task.WaitAll(task1, task2);          // AsyncFixer02: Use 'Task.WhenAll' instead
}

// GOOD: Use async equivalents
public async Task ProcessDataAsync()
{
    var result = await GetDataAsync();
    await Task.Delay(1000);
    await Task.WhenAll(task1, task2);
}

// Blocking call replacements:
// | Blocking Call           | Async Replacement          |
// |-------------------------|----------------------------|
// | task.Wait()             | await task                 |
// | task.Result             | await task                 |
// | Task.WaitAll(...)       | await Task.WhenAll(...)    |
// | Task.WaitAny(...)       | await Task.WhenAny(...)    |
// | Thread.Sleep(ms)        | await Task.Delay(ms)       |
// | stream.Read(...)        | await stream.ReadAsync(...)|
// | reader.ReadToEnd()      | await reader.ReadToEndAsync()|

// SAFE: Accessing .Result after Task.WhenAll is allowed (tasks are completed)
public async Task ProcessAllAsync()
{
    Task<int>[] tasks = CreateTasks();
    await Task.WhenAll(tasks);  // All tasks now completed

    foreach (var task in tasks)
    {
        Console.WriteLine(task.Result);  // Safe - no warning
    }
}

// SAFE: Short Thread.Sleep (<50ms) is not flagged
public async Task QuickPauseAsync()
{
    Thread.Sleep(10);  // Not flagged - too short to matter
    await DoWorkAsync();
}
```

--------------------------------

### Replace Blocking Calls in Async Methods

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Shows how to replace blocking operations like Task.Result or Thread.Sleep with their non-blocking asynchronous equivalents.

```csharp
// Bad
async Task ProcessAsync() {
    var result = GetDataAsync().Result;
    Thread.Sleep(1000);
}

// Good
async Task ProcessAsync() {
    var result = await GetDataAsync();
    await Task.Delay(1000);
}
```

--------------------------------

### Safe .Result Usage After Task.WhenAll in C#

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Shows a safe pattern where accessing the .Result property of tasks after awaiting Task.WhenAll() does not cause blocking warnings. This is because all tasks are guaranteed to be completed at this point.

```csharp
Task<int>[] tasks = CreateTasks();
await Task.WhenAll(tasks);  // All tasks are now completed

foreach (var task in tasks)
    Console.WriteLine(task.Result);  // Safe - no warning
```

--------------------------------

### Prevent premature resource disposal in async calls

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Shows how to avoid race conditions where a resource is disposed before an asynchronous operation completes by awaiting the task within the using block.

```csharp
// ❌ Bad: Stream disposed before copy completes
using (var stream = new FileStream("file.txt", FileMode.Open))
{
    stream.CopyToAsync(destination);  // Fire-and-forget!
}  // stream disposed here - CopyToAsync may still be running!

// ✅ Good: Await the async operation
using (var stream = new FileStream("file.txt", FileMode.Open))
{
    await stream.CopyToAsync(destination);
}
```

--------------------------------

### Suppressing AsyncFixer Warnings in C#

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Provides multiple methods for suppressing AsyncFixer warnings, including inline `#pragma` directives, `SuppressMessage` attributes, EditorConfig settings, and global suppression files.

```csharp
#pragma warning disable AsyncFixer01
async Task<int> Method() => await SomeTaskAsync();
#pragma warning restore AsyncFixer01
```

```csharp
[System.Diagnostics.CodeAnalysis.SuppressMessage("AsyncUsage", "AsyncFixer01")]
async Task<int> Method() => await SomeTaskAsync();
```

```ini
[*.cs]
dotnet_diagnostic.AsyncFixer01.severity = none
```

```csharp
[assembly: SuppressMessage("AsyncUsage", "AsyncFixer01", Justification = "Team preference")]
```

--------------------------------

### Avoid silent Task<T> result discarding

Source: https://github.com/semihokur/asyncfixer/blob/main/README.md

Explains how to prevent the loss of return values when assigning Task<T> to a Task delegate, ensuring the correct delegate type is used.

```csharp
// ❌ Bad: Task<string> silently converted to Task, result discarded
Func<Task> fn = () => GetDataAsync();  // GetDataAsync returns Task<string>
await fn();  // The string result is lost!

// ✅ Good: Use correct delegate type
Func<Task<string>> fn = () => GetDataAsync();
var result = await fn();

// ✅ Also Good: Explicit discard if you don't need the result
Func<Task> fn = async () => { _ = await GetDataAsync(); };
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.