MVVM场景下如何避免线程Task因ViewModel回收而终止？

问题场景 #

在MVVM项目的页面ViewModel命令中，需要执行一个无需等待的后台任务（调用API发送事件信息），避免阻塞后续的导航操作。原有实现示例：

// Purchase completed
// <code to purchase here>

// API Call to send event
await Task.Run(() => { _ = ApiService.PostEvent("purchased"); });

// Navigate Back
// <code to navigate back here>

但存在问题：若导航操作在后台任务完成前执行，ViewModel会被垃圾回收，导致关联的后台任务也被终止，无法完成API调用。

解决方案 #

1. 全局后台任务托管容器 #

创建一个生命周期与应用一致的全局容器，负责托管所有无需等待的后台任务，让任务生命周期与ViewModel解绑。

实现代码：

public static class BackgroundTaskManager
{
    private static readonly object _lock = new object();
    private static readonly List<Task> _runningTasks = new List<Task>();

    public static void Run(Func<Task> taskFunc)
    {
        lock (_lock)
        {
            var task = ExecuteAndCleanup(taskFunc);
            _runningTasks.Add(task);
        }
    }

    private static async Task ExecuteAndCleanup(Func<Task> taskFunc)
    {
        try
        {
            await taskFunc();
        }
        catch (Exception ex)
        {
            // 此处添加日志记录逻辑，例如写入本地日志或监控平台
        }
        finally
        {
            lock (_lock)
            {
                var currentTask = Task.CurrentId.HasValue 
                    ? _runningTasks.FirstOrDefault(t => t.Id == Task.CurrentId.Value) 
                    : null;
                if (currentTask != null)
                    _runningTasks.Remove(currentTask);
            }
        }
    }
}

ViewModel中调用：

// Purchase completed
// <code to purchase here>

// API Call to send event
BackgroundTaskManager.Run(() => ApiService.PostEvent("purchased"));

// Navigate Back
// <code to navigate back here>

2. 单例服务托管事件发送逻辑 #

将事件发送的后台处理逻辑移到单例生命周期的ApiService中，由服务自身持有任务引用，避免依赖ViewModel的生命周期。

修改ApiService：

public class ApiService
{
    private static readonly object _lock = new object();
    private static readonly List<Task> _pendingTasks = new List<Task>();

    // 原有API调用方法
    public async Task PostEvent(string eventName)
    {
        using (var client = new HttpClient())
        {
            await client.PostAsync("https://your-api-domain/events", new StringContent(eventName));
        }
    }

    // 火并忘调用方法
    public void PostEventFireAndForget(string eventName)
    {
        lock (_lock)
        {
            var task = ExecuteEventPost(eventName);
            _pendingTasks.Add(task);
        }
    }

    private async Task ExecuteEventPost(string eventName)
    {
        try
        {
            await PostEvent(eventName);
        }
        catch (Exception ex)
        {
            // 日志记录
        }
        finally
        {
            lock (_lock)
            {
                var currentTask = Task.CurrentId.HasValue 
                    ? _pendingTasks.FirstOrDefault(t => t.Id == Task.CurrentId.Value) 
                    : null;
                if (currentTask != null)
                    _pendingTasks.Remove(currentTask);
            }
        }
    }
}

ViewModel中调用：

// Purchase completed
// <code to purchase here>

// API Call to send event
_apiService.PostEventFireAndForget("purchased");

// Navigate Back
// <code to navigate back here>

3. 基于队列的后台服务（高可靠性方案） #

如果需要保证事件一定能发送成功（支持失败重试），可以使用事件队列+后台服务的模式，ViewModel仅负责将事件加入队列，由独立的后台服务负责消费并调用API。

步骤1：定义事件队列

public interface IEventQueue
{
    void Enqueue(string eventName);
    Task<string> DequeueAsync(CancellationToken cancellationToken);
}

public class EventQueue : IEventQueue
{
    private readonly ConcurrentQueue<string> _queue = new ConcurrentQueue<string>();
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(0);

    public void Enqueue(string eventName)
    {
        _queue.Enqueue(eventName);
        _semaphore.Release();
    }

    public async Task<string> DequeueAsync(CancellationToken cancellationToken)
    {
        await _semaphore.WaitAsync(cancellationToken);
        _queue.TryDequeue(out var eventName);
        return eventName;
    }
}

步骤2：实现后台处理服务

public class EventProcessingService : BackgroundService
{
    private readonly IEventQueue _eventQueue;
    private readonly ApiService _apiService;

    public EventProcessingService(IEventQueue eventQueue, ApiService apiService)
    {
        _eventQueue = eventQueue;
        _apiService = apiService;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var eventName = await _eventQueue.DequeueAsync(stoppingToken);
            try
            {
                // 可添加重试逻辑，例如失败后重新入队
                await _apiService.PostEvent(eventName);
            }
            catch (Exception ex)
            {
                // 记录错误日志，或处理死信事件
            }
        }
    }
}

步骤3：注册服务（以.NET为例）

// 在Program.cs或Startup.cs中注册
builder.Services.AddSingleton<IEventQueue, EventQueue>();
builder.Services.AddHostedService<EventProcessingService>();
builder.Services.AddSingleton<ApiService>();

ViewModel中调用：

// Purchase completed
// <code to purchase here>

// API Call to send event
_eventQueue.Enqueue("purchased");

// Navigate Back
// <code to navigate back here>

内容的提问来源于stack exchange，提问作者Hans Voralberg