如何创建具备定时后台任务功能的.NET类库？

要实现跨场景的定时后台刷新任务，同时封装内部细节，以下几种机制是最适合的选择，兼顾轻量性、兼容性和易用性：

1. 基础定时器：System.Threading.Timer 或 System.Timers.Timer #

这两个是.NET原生的轻量定时组件，不依赖任何宿主环境，适配所有.NET应用场景（控制台、Web服务、类库等）。

核心特点 #

• System.Threading.Timer：基于线程池线程执行回调，资源占用极低，适合简单的定时任务；
• System.Timers.Timer：封装了Threading.Timer，提供事件触发模式，更符合传统事件驱动编程习惯。

实现要点 #

• 把定时器逻辑封装在内部服务类中，仅对外暴露缓存查询接口；
• 处理重入问题：如果任务执行时间超过定时间隔，需要加锁或用标志位避免并发执行；
• 实现IDisposable接口，在释放时销毁定时器，防止资源泄漏。

简化示例 #

// 对外暴露的公共接口
public interface IPageCache
{
    string GetCachedPageContent();
}

// 内部实现类
internal class PageCache : IPageCache, IDisposable
{
    private readonly Timer _refreshTimer;
    private string _cachedContent = string.Empty;
    private readonly object _lockObj = new();
    private readonly string _targetUrl;
    private bool _isRefreshing = false;

    public PageCache(string targetUrl, TimeSpan refreshInterval)
    {
        _targetUrl = targetUrl;
        // 初始化时先执行一次缓存刷新
        RefreshContentSync();
        // 创建定时器，间隔执行刷新任务
        _refreshTimer = new Timer(_ => RefreshContent(), null, TimeSpan.Zero, refreshInterval);
    }

    public string GetCachedPageContent()
    {
        lock (_lockObj)
        {
            return _cachedContent;
        }
    }

    private void RefreshContent()
    {
        // 避免重入：如果上一次任务还在执行，直接跳过
        if (Interlocked.CompareExchange(ref _isRefreshing, true, false) == true)
            return;

        try
        {
            using var httpClient = new HttpClient();
            var newContent = httpClient.GetStringAsync(_targetUrl).GetAwaiter().GetResult();
            
            lock (_lockObj)
            {
                _cachedContent = newContent;
            }
        }
        catch (Exception ex)
        {
            // 异常处理：保留旧缓存、记录日志（可注入ILogger让使用者提供日志实现）
        }
        finally
        {
            Interlocked.Exchange(ref _isRefreshing, false);
        }
    }

    private void RefreshContentSync()
    {
        // 初始化缓存的同步实现
        try
        {
            using var httpClient = new HttpClient();
            var content = httpClient.GetStringAsync(_targetUrl).GetAwaiter().GetResult();
            lock (_lockObj)
            {
                _cachedContent = content;
            }
        }
        catch
        {
            // 初始化失败时设置默认值
            _cachedContent = string.Empty;
        }
    }

    public void Dispose()
    {
        _refreshTimer?.Dispose();
    }
}

2. 托管服务：BackgroundService（适配依赖注入场景） #

如果你的类库主要面向使用.NET依赖注入（DI）的场景（如ASP.NET Core、控制台Generic Host），BackgroundService是更规范的选择，它依托.NET的宿主生命周期管理自动启动/停止任务。

核心特点 #

• 天然支持异步任务，避免阻塞线程；
• 与宿主生命周期绑定，宿主停止时自动触发任务终止逻辑；
• 可通过DI注入其他服务（如日志、配置）。

结合PeriodicTimer（.NET 6+推荐） #

.NET 6新增的PeriodicTimer专门解决定时器重入问题，它的WaitForNextTickAsync方法会等待上一次任务完成后再进入下一轮循环，无需手动处理并发。

实现示例 #

// 公共接口
public interface IPageCache
{
    string GetCachedPageContent();
}

// 缓存服务实现
internal class PageCache : IPageCache
{
    private string _cachedContent = string.Empty;
    private readonly object _lockObj = new();
    private readonly string _targetUrl;

    public PageCache(string targetUrl)
    {
        _targetUrl = targetUrl;
    }

    public string GetCachedPageContent()
    {
        lock (_lockObj)
        {
            return _cachedContent;
        }
    }

    internal async Task RefreshContentAsync(CancellationToken cancellationToken)
    {
        try
        {
            using var httpClient = new HttpClient();
            var newContent = await httpClient.GetStringAsync(_targetUrl, cancellationToken);
            
            lock (_lockObj)
            {
                _cachedContent = newContent;
            }
        }
        catch (Exception ex)
        {
            // 异常处理逻辑
        }
    }
}

// 后台托管服务
public class PageCacheRefreshService : BackgroundService
{
    private readonly IPageCache _pageCache;
    private readonly TimeSpan _refreshInterval;

    public PageCacheRefreshService(IPageCache pageCache, TimeSpan refreshInterval)
    {
        _pageCache = pageCache;
        _refreshInterval = refreshInterval;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // 初始化缓存
        await ((PageCache)_pageCache).RefreshContentAsync(stoppingToken);

        using var timer = new PeriodicTimer(_refreshInterval);
        while (await timer.WaitForNextTickAsync(stoppingToken))
        {
            await ((PageCache)_pageCache).RefreshContentAsync(stoppingToken);
        }
    }
}

// 扩展方法，简化使用者注册
public static class PageCacheExtensions
{
    public static IServiceCollection AddPageCache(this IServiceCollection services, string targetUrl, TimeSpan refreshInterval)
    {
        services.AddSingleton<IPageCache>(_ => new PageCache(targetUrl));
        services.AddHostedService(provider => 
            new PageCacheRefreshService(provider.GetRequiredService<IPageCache>(), refreshInterval));
        return services;
    }
}

使用者接入方式 #

• ASP.NET Core：在Program.cs中调用builder.Services.AddPageCache("https://example.com", TimeSpan.FromHours(1));，之后直接在控制器/服务中注入IPageCache使用；
• 控制台应用：搭建Generic Host后注册服务：

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddPageCache("https://example.com", TimeSpan.FromHours(1));
    })
    .Build();

await host.RunAsync();

3. 设计关键注意事项 #

• 封装内部细节：确保公共接口仅包含业务相关方法（如GetCachedPageContent），定时刷新、网页抓取逻辑完全隐藏；
• 线程安全：缓存的读写操作必须加锁，避免并发访问导致的数据异常；
• 异常容错：刷新任务失败时保留旧缓存，避免影响使用者；
• 配置灵活性：允许使用者通过构造函数或配置类指定刷新间隔、目标URL等参数；
• 资源释放：所有持有非托管资源（如定时器）的类必须实现IDisposable，确保使用者能正确释放资源。

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