如何使用Electron.NET运行定时任务？需每60秒获取API数据且不冻结GUI

当然可以实现！Electron.NET结合了.NET的并发能力和Electron的桌面特性，完全能搞定这个每60秒执行一次的API数据获取+处理任务，还能保证GUI丝滑不卡顿。下面给你两种常用的实现方案，适配不同场景：

方案1：通用Electron.NET项目（非Blazor） #

如果你的项目没有用Blazor，直接用.NET + Electron的组合，可以用System.Timers.Timer来实现后台定时任务，核心是让任务在后台线程跑，更新UI时切回主线程。

步骤1：创建后台任务服务 #

using System.Timers;
using System.Net.Http.Json;
using System.Text.Json;

public class PeriodicTaskService
{
    private Timer _taskTimer;
    private readonly HttpClient _httpClient;

    public PeriodicTaskService()
    {
        _httpClient = new HttpClient();
        SetupTimer();
    }

    private void SetupTimer()
    {
        // 设置60秒间隔（单位：毫秒）
        _taskTimer = new Timer(60000);
        // 绑定定时触发的异步方法
        _taskTimer.Elapsed += async (sender, e) => await ExecuteTaskAsync();
        // 自动重复触发
        _taskTimer.AutoReset = true;
        _taskTimer.Start();
    }

    private async Task ExecuteTaskAsync()
    {
        try
        {
            // 可选：暂停定时器，避免任务重叠执行（比如API响应慢的情况）
            _taskTimer.Stop();

            // 1. 异步获取API数据（非阻塞）
            var apiData = await _httpClient.GetFromJsonAsync<YourDataModel>("https://your-api-endpoint.com/data");

            // 2. 后台处理数据（这里不会阻塞GUI）
            ProcessFetchedData(apiData);

            // 3. 线程安全更新GUI：通过Electron的ExecuteJavaScriptAsync在主线程执行UI更新
            var serializedData = JsonSerializer.Serialize(apiData);
            await Electron.WindowManager.BrowserWindows.First()
                .ExecuteJavaScriptAsync($"updateApplicationUI({serializedData})");
        }
        catch (Exception ex)
        {
            // 别忘了处理异常，比如打日志或者给用户提示
            Console.WriteLine($"定时任务执行失败：{ex.Message}");
        }
        finally
        {
            // 重启定时器，确保下一次任务能正常触发
            _taskTimer.Start();
        }
    }

    private void ProcessFetchedData(YourDataModel data)
    {
        // 这里写你的数据处理逻辑，比如过滤、计算、存储等
        // 示例：筛选出符合条件的条目
        var filteredItems = data.Items.Where(item => item.IsActive).ToList();
    }
}

// 替换成你实际的API数据模型
public class YourDataModel
{
    public List<DataItem> Items { get; set; }
}

public class DataItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsActive { get; set; }
}

步骤2：在启动时初始化服务 #

在项目的Program.cs里，启动Electron后初始化这个后台服务：

public static async Task Main(string[] args)
{
    var electronApp = await ElectronNET.API.Electron.StartAsync();
    var mainWindow = await Electron.WindowManager.CreateWindowAsync();
    
    // 初始化定时任务服务，启动后自动开始执行
    var taskService = new PeriodicTaskService();
    
    await electronApp.RunAsync();
}

步骤3：前端UI更新方法 #

在你的HTML/JS代码里，实现updateApplicationUI方法来接收数据并更新界面：

function updateApplicationUI(data) {
    // 示例：更新页面上的数据展示
    document.getElementById('data-container').innerText = JSON.stringify(data, null, 2);
}

方案2：Blazor + Electron.NET项目 #

如果你的Electron.NET项目用了Blazor，实现起来更简单，因为Blazor自带线程调度机制，不用手动处理主线程切换：

@page "/"
@implements IDisposable

<h3>实时API数据展示</h3>
<div>@(_data != null ? $"最新数据：{_data.Items.Count}条" : "等待数据...")</div>

@code {
    private YourDataModel _data;
    private CancellationTokenSource _taskCts;

    protected override async Task OnInitializedAsync()
    {
        // 创建取消令牌，用于组件销毁时停止任务
        _taskCts = new CancellationTokenSource();
        // 启动异步定时循环（用_ = 避免阻塞组件初始化）
        _ = RunPeriodicTaskAsync(_taskCts.Token);
    }

    private async Task RunPeriodicTaskAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                using var httpClient = new HttpClient();
                // 异步获取API数据
                _data = await httpClient.GetFromJsonAsync<YourDataModel>(
                    "https://your-api-endpoint.com/data", 
                    cancellationToken
                );

                // 后台处理数据
                ProcessFetchedData(_data);

                // Blazor自动切换到主线程更新UI
                await InvokeAsync(StateHasChanged);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"任务出错：{ex.Message}");
            }

            // 等待60秒，可被取消
            await Task.Delay(60000, cancellationToken);
        }
    }

    private void ProcessFetchedData(YourDataModel data)
    {
        // 你的数据处理逻辑
    }

    public void Dispose()
    {
        // 组件销毁时取消定时任务，避免内存泄漏
        _taskCts?.Cancel();
        _taskCts?.Dispose();
    }
}

关键注意事项 #

• 必须用异步API调用：不管用哪种方案，都要使用HttpClient的异步方法（比如GetFromJsonAsync），避免阻塞后台线程。
• 线程安全更新UI：后台线程绝对不能直接操作GUI，必须通过Electron的ExecuteJavaScriptAsync或者Blazor的InvokeAsync切换到主线程执行更新。
• 避免任务重叠：如果API响应可能超过60秒，记得在任务执行时暂停定时器（方案1里的_taskTimer.Stop()），执行完再重启。
• 异常处理：一定要捕获任务中的异常，不然一次失败可能导致整个定时任务停止运行。

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