‫مدیریت منابع با Task.Dispose در برنامه‌نویسی ناهمزمان #C

public class Task : IAsyncResult, IDisposable
{
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

public async Task ProcessDataAsync()
{
    var task = Task.Run(() => 
    {
        throw new Exception("This exception might be unobserved!");
    });
    
    // اگر Task را await نکنیم یا آن را مدیریت نکنیم، باید آن را Dispose کنیم
    task.Dispose(); // از پرتاب استثنای مشاهده نشده جلوگیری می‌کند
}

public class DataProcessor : IDisposable
{
    private Task _processingTask;
    
    public void StartProcessing()
    {
        _processingTask = Task.Run(() => 
        {
            // پردازش طولانی مدت
            while (true)
            {
                // پردازش داده
            }
        });
    }
    
    public void Dispose()
    {
        _processingTask?.Dispose();
    }
}

• تکمیل موفقیت‌آمیز Task: هنگامی که Task بدون استثنا به پایان می‌رسد.
• Task مورد await قرار می‌گیرد: با استفاده از کلمه کلیدی await، استثناهای Task در همان کانتکس (Context) کد مدیریت می‌شوند.
• نتیجه Task مورد دسترسی قرار می‌گیرد: دسترسی به ویژگی Result یک Task یا فراخوانی Wait()، استثناهای موجود را پرتاب می‌کند و Task را مشاهده می‌کند.

// نیازی به Dispose نیست - Task به درستی مدیریت می‌شود
public async Task<string> GetDataAsync()
{
    var task = Task.Run(() => "Data");
    return await task;
}

// نیازی به Dispose نیست - نتیجه مورد دسترسی قرار می‌گیرد
public string GetData()
{
    var task = Task.Run(() => "Data");
    return task.Result;
}

public async Task ProcessWithCancellationAsync(CancellationToken cancellationToken)
{
    var task = Task.Run(() => 
    {
        // به صورت دوره‌ای توکن لغو را بررسی کنید
        while (!cancellationToken.IsCancellationRequested)
        {
            // پردازش داده
        }
    }, cancellationToken);
    
    await task;
}

public async Task ProcessWithDisposalAsync()
{
    using (var task = Task.Run(() => 
    {
        // برخی پردازش‌ها
    }))
    {
        // با Task کار کنید
        await task;
    } // Task به صورت خودکار Dispose می‌شود
}

TaskScheduler.UnobservedTaskException += (sender, args) =>
{
    // استثنا را ثبت کنید
    Console.WriteLine($"Unobserved exception: {args.Exception}");
    // به عنوان مدیریت شده علامت‌گذاری کنید
    args.SetObserved();
};

public class CustomTaskManager : IDisposable
{
    private readonly TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
    
    public Task<bool> Operation => _tcs.Task;
    
    public void CompleteOperation(bool result)
    {
        _tcs.TrySetResult(result);
    }
    
    public void Dispose()
    {
        _tcs.TrySetCanceled();
        _tcs.Task.Dispose();
    }
}

public class BackgroundProcessor : IDisposable
{
    private Task _processingTask;
    private CancellationTokenSource _cts;
    
    public void StartProcessing()
    {
        _cts = new CancellationTokenSource();
        _processingTask = Task.Run(async () =>
        {
            while (!_cts.Token.IsCancellationRequested)
            {
                try
                {
                    await ProcessDataAsync();
                }
                catch (Exception ex)
                {
                    // استثنا را ثبت کنید اما به پردازش ادامه دهید
                    Console.WriteLine($"Error: {ex.Message}");
                }
            }
        }, _cts.Token);
    }
    
    public void Dispose()
    {
        _cts?.Cancel();
        _processingTask?.Dispose();
        _cts?.Dispose();
    }
}