基于Web API/WCF实现C/S架构定时长时数据任务的技术问询

阿华AIGC实验室

2026-5-25

嘿，针对你这个基于C# WinForms的C/S架构数据导入导出定时长时任务的需求，我来分享几个实用的实现思路，分别从Web API和WCF两个方向展开，同时覆盖定时调度、长时任务处理以及客户端交互的关键要点：

一、基于Web API的实现方案

Web API是当前.NET生态里更主流的服务端通信方式，轻量易扩展，非常适配你的场景。

1. 定时任务核心：用成熟调度框架

推荐用Hangfire或者Quartz.NET，这两个框架都能完美集成到ASP.NET Core Web API中，支持你需要的单次定时、按小时/日/周/月重复的调度规则：

Hangfire上手更简单，自带后台面板可直观管理任务，还内置了任务状态跟踪和重试机制；
Quartz.NET灵活性更高，适合复杂的调度规则配置。

举个Hangfire的简单示例（ASP.NET Core Web API）：

// Startup.cs 配置Hangfire
public void ConfigureServices(IServiceCollection services)
{
    // 用SQL Server存储任务数据，也支持其他数据库
    services.AddHangfire(config => config.UseSqlServerStorage("你的数据库连接字符串"));
    services.AddHangfireServer();
    // 注册你的数据导入导出任务服务
    services.AddScoped<IDataTransferService, DataTransferService>();
}

// 任务调度API控制器
[ApiController]
[Route("api/tasks")]
public class TaskSchedulerController : ControllerBase
{
    private readonly IBackgroundJobClient _backgroundJobClient;
    private readonly IRecurringJobManager _recurringJobManager;

    public TaskSchedulerController(IBackgroundJobClient backgroundJobClient, IRecurringJobManager recurringJobManager)
    {
        _backgroundJobClient = backgroundJobClient;
        _recurringJobManager = recurringJobManager;
    }

    // 创建单次定时任务
    [HttpPost("single")]
    public IActionResult CreateSingleTask([FromBody] SingleTaskRequest request)
    {
        var jobId = _backgroundJobClient.Schedule<IDataTransferService>(
            service => service.ExecuteTransfer(request.TaskConfig),
            request.StartTime);
        return Ok(new { JobId = jobId });
    }

    // 创建周期性任务
    [HttpPost("recurring")]
    public IActionResult CreateRecurringTask([FromBody] RecurringTaskRequest request)
    {
        _recurringJobManager.AddOrUpdate(
            request.TaskName,
            () => new DataTransferService().ExecuteTransfer(request.TaskConfig),
            request.CronExpression); // 比如"0 * * * *"代表每小时执行
        return Ok();
    }
}

2. 长时任务处理：异步+状态跟踪

数据导入导出属于长时任务，要避免阻塞API请求，同时得让客户端能查询任务进度和状态：

任务执行逻辑要写成异步方法，用async/await；
把任务状态（等待中、运行中、完成、失败）、进度百分比、日志信息存储到数据库，提供专门的API让WinForms客户端查询：

public interface IDataTransferService
{
    Task ExecuteTransfer(TaskConfig config);
}

public class DataTransferService : IDataTransferService
{
    private readonly ITaskStatusRepository _statusRepo;

    public DataTransferService(ITaskStatusRepository statusRepo)
    {
        _statusRepo = statusRepo;
    }

    public async Task ExecuteTransfer(TaskConfig config)
    {
        var status = new TaskStatus { JobId = config.JobId, Status = TaskStatusEnum.Running, Progress = 0 };
        await _statusRepo.UpdateStatusAsync(status);

        try
        {
            // 模拟数据导入导出步骤
            await Step1(config);
            status.Progress = 30;
            await _statusRepo.UpdateStatusAsync(status);

            await Step2(config);
            status.Progress = 70;
            await _statusRepo.UpdateStatusAsync(status);

            await Step3(config);
            status.Progress = 100;
            status.Status = TaskStatusEnum.Completed;
            await _statusRepo.UpdateStatusAsync(status);
        }
        catch (Exception ex)
        {
            status.Status = TaskStatusEnum.Failed;
            status.ErrorMessage = ex.Message;
            await _statusRepo.UpdateStatusAsync(status);
            throw; // 让Hangfire记录错误，支持重试
        }
    }
}

3. WinForms客户端交互

客户端通过HttpClient调用Web API来创建、查询、取消任务：

// 客户端创建定时任务示例
private async void btnCreateTask_Click(object sender, EventArgs e)
{
    var request = new SingleTaskRequest
    {
        StartTime = dtpStartTime.Value,
        TaskConfig = new TaskConfig { SourceType = "Excel", TargetType = "SQLServer", ... }
    };

    using var client = new HttpClient();
    client.BaseAddress = new Uri("http://你的服务端地址/api/");
    var response = await client.PostAsJsonAsync("tasks/single", request);
    if (response.IsSuccessStatusCode)
    {
        var result = await response.Content.ReadFromJsonAsync<JobResponse>();
        MessageBox.Show($"任务创建成功，ID：{result.JobId}");
    }
}

// 客户端查询任务状态
private async void btnCheckStatus_Click(object sender, EventArgs e)
{
    var jobId = txtJobId.Text;
    using var client = new HttpClient();
    client.BaseAddress = new Uri("http://你的服务端地址/api/");
    var status = await client.GetFromJsonAsync<TaskStatus>($"tasks/status/{jobId}");
    if (status != null)
    {
        lblStatus.Text = $"状态：{status.Status}，进度：{status.Progress}%";
    }
}

二、基于WCF的实现方案

如果你的项目已经在使用WCF，或者需要更强大的双工通信（实时推送任务状态到客户端），可以选择这个方案。

1. 服务端架构：Windows服务承载WCF服务

把WCF服务部署在Windows服务中，保证服务始终运行，然后集成Quartz.NET做定时任务调度。

2. 双工通信实现实时状态推送

WCF的双工绑定（比如NetTcpBinding）可以让服务端主动推送任务状态到客户端，不需要客户端轮询：

// 双工服务契约
[ServiceContract(CallbackContract = typeof(ITaskStatusCallback))]
public interface IDataTransferTaskService
{
    [OperationContract]
    Guid ScheduleSingleTask(TaskConfig config, DateTime startTime);

    [OperationContract]
    void ScheduleRecurringTask(string taskName, TaskConfig config, string cronExpression);
}

// 回调契约，用于服务端推送状态
public interface ITaskStatusCallback
{
    [OperationContract(IsOneWay = true)]
    void OnTaskStatusUpdated(TaskStatus status);
}

// 服务实现
public class DataTransferTaskService : IDataTransferTaskService
{
    private readonly IScheduler _scheduler;

    public DataTransferTaskService(IScheduler scheduler)
    {
        _scheduler = scheduler;
    }

    public Guid ScheduleSingleTask(TaskConfig config, DateTime startTime)
    {
        var jobId = Guid.NewGuid();
        var job = JobBuilder.Create<DataTransferJob>()
            .UsingJobData("JobId", jobId.ToString())
            .UsingJobData("Config", JsonConvert.SerializeObject(config))
            .Build();

        var trigger = TriggerBuilder.Create()
            .StartAt(startTime)
            .Build();

        _scheduler.ScheduleJob(job, trigger);
        return jobId;
    }

    // 周期性任务实现类似...
}

// Quartz任务执行类，这里可以获取回调客户端推送状态
public class DataTransferJob : IJob
{
    public async Task Execute(IJobExecutionContext context)
    {
        var jobId = Guid.Parse(context.JobDetail.JobDataMap.GetString("JobId"));
        var config = JsonConvert.DeserializeObject<TaskConfig>(context.JobDetail.JobDataMap.GetString("Config"));

        // 获取客户端回调通道（如果需要实时推送）
        var callbackOperationContext = OperationContext.Current;
        var callback = callbackOperationContext.GetCallbackChannel<ITaskStatusCallback>();

        try
        {
            callback.OnTaskStatusUpdated(new TaskStatus { JobId = jobId, Status = TaskStatusEnum.Running, Progress = 0 });
            // 执行数据传输步骤，更新进度并推送
            // ...
            callback.OnTaskStatusUpdated(new TaskStatus { JobId = jobId, Status = TaskStatusEnum.Completed, Progress = 100 });
        }
        catch (Exception ex)
        {
            callback.OnTaskStatusUpdated(new TaskStatus { JobId = jobId, Status = TaskStatusEnum.Failed, ErrorMessage = ex.Message });
        }
    }
}

3. WinForms客户端实现

客户端需要实现回调接口，绑定WCF服务：

public class TaskStatusCallback : ITaskStatusCallback
{
    private readonly Form1 _form;

    public TaskStatusCallback(Form1 form)
    {
        _form = form;
    }

    public void OnTaskStatusUpdated(TaskStatus status)
    {
        // 跨线程更新UI
        _form.Invoke(new Action(() =>
        {
            _form.lblStatus.Text = $"状态：{status.Status}，进度：{status.Progress}%";
            if (status.Status == TaskStatusEnum.Failed)
            {
                MessageBox.Show($"任务失败：{status.ErrorMessage}");
            }
        }));
    }
}

// 客户端调用WCF服务
private void btnCreateTask_Click(object sender, EventArgs e)
{
    var callback = new TaskStatusCallback(this);
    var factory = new DuplexChannelFactory<IDataTransferTaskService>(callback, "NetTcpBinding_IDataTransferTaskService");
    var service = factory.CreateChannel();

    var config = new TaskConfig { SourceType = "Excel", TargetType = "SQLServer", ... };
    var jobId = service.ScheduleSingleTask(config, dtpStartTime.Value);
    MessageBox.Show($"任务创建成功，ID：{jobId}");
}

三、通用关键注意事项

不管选Web API还是WCF，这些要点都不能忽略：