C# 同时处理单个和批处理请求的体系结构

我有一个托管在Windows服务中的WCF服务。此服务公开了两种方法：

boolprocesclaim（字符串选项，参考字符串xml）

将一些数据作为输入，进行一些处理（包括IO绑定操作，如DB查询），然后返回结果

void RunJob（字符串票据）立即返回。根据
票据
，从存储器（如数据库或文件系统）读取输入数据，对每个数据元素进行相同的处理，并将结果保存回存储器。批次通常由许多索赔组成

用户可以调用

ProcessClaim

来处理单个请求，也可以调用

RunJob

来运行批处理。几个批次可以同时运行。每个处理请求都包装为

任务

，因此所有请求都并行执行。 问题是不允许批处理通过调度大量请求阻塞处理队列。换句话说，若用户执行大批量，它将在相当长的时间内阻止小批量和单个处理请求。 因此，我提出了以下模式，由（非常简短地）描述：

公共密封类处理队列：IDisposable
{
私有类工作项
{
公共只读任务完成源任务源；
公共只读字符串选项；
公共只读字符串声明；
公共只读取消令牌？取消令牌；
公共工作项目(
TaskCompletionSource任务源，
字符串选项，
字符串声明，
CancellationToken？cancelToken）
{
TaskSource=TaskSource；
选项=选项；
索赔=索赔；
CancelToken=CancelToken；
}
}
公共处理队列（）
：此（Environment.ProcessorCount）
{
}
公共处理队列（int workerCount）
{
_taskQ=新的BlockingCollection（workerCount*2）；
对于（变量i=0；iProcessItem（选项，声明））；
}
私有void消费（）
{
foreach（在_taskQ.getconsumineGenumerable（）中的var workItem）
{
if（workItem.CancelToken.HasValue&&workItem.CancelToken.Value.IsCancellationRequested）
workItem.TaskSource.setCancelled（）；
其他的
{
尝试
{
workItem.TaskSource.SetResult（ProcessItem（workItem.Options，workItem.Claim））；
}
捕获（例外情况除外）
{
workItem.TaskSource.SetException（ex）；
}
}
}
}
私有静态字符串ProcessItem（字符串选项、字符串声明）
{
//在这里做一些实际工作
Thread.Sleep（2000）；//模拟工作；
返回选项+索赔；//返回最终结果
}
}

静态方法

ProcessRequest

可用于处理单个请求，而实例方法

EnqueueTask

-用于批处理。当然，所有批处理都必须使用

ProcessingQueue

的单个共享实例。虽然这种方法工作得相当好，可以控制多个批次同时运行的速度，但我觉得有些地方不对劲：

• 必须手动维护工作线程池
• 难以猜测最佳工作线程数（默认情况下，我使用处理器内核数）
• 当没有批处理正在运行时，一堆线程仍然被阻塞，浪费了系统资源
• 处理块工作线程的IO绑定部分降低CPU使用效率

我想知道，有没有更好的方法来处理这种情况

更新：

---

其中一个要求是为批处理提供全功率，这意味着当用户执行一个批处理时，没有其他传入请求，所有资源都必须专用于处理此批处理。

我想说，使用单一服务接口和单一托管容器来处理这两种截然不同的需求可能是一个错误

您应该将您的服务解耦为两个部分：一个返回对单个请求的响应，另一个排队处理批处理查询，并在单个线程上处理它们

这样，您就可以为实时用户提供高可用性通道，为批量用户提供脱机通道。这些可以作为单独的关注点进行部署和管理，允许您在每个服务接口上提供不同的服务级别

只是我对提议的架构的想法

更新

事实上，卷处理通道是脱机通道。这意味着消费者将不得不排队等待，等待他们的请求返回的时间是不确定的

---

那么工作队列呢？每个作业在处理过程中都会获得所有可用资源。处理作业后，调用者会收到作业已完成的通知。

听起来您希望以更一致的方式分配负载。我会找一辆服务车来做这件事。这是一个很好的观点，我肯定应该把这些函数分开。然而，其中一个要求是为批处理提供全功率，这意味着当用户执行一个批处理时

public sealed class ProcessingQueue : IDisposable
{
    private class WorkItem
    {
        public readonly TaskCompletionSource<string> TaskSource;
        public readonly string Options;
        public readonly string Claim;
        public readonly CancellationToken? CancelToken;

        public WorkItem(
            TaskCompletionSource<string> taskSource,
            string options,
            string claim,
            CancellationToken? cancelToken)
        {
            TaskSource = taskSource;
            Options = options;
            Claim = claim;
            CancelToken = cancelToken;
        }
    }

    public ProcessingQueue()
        : this(Environment.ProcessorCount)
    {
    }

    public ProcessingQueue(int workerCount)
    {
        _taskQ = new BlockingCollection<WorkItem>(workerCount * 2);

        for (var i = 0; i < workerCount; i++)
            Task.Factory.StartNew(Consume);
    }

    public void Dispose()
    {
        _taskQ.CompleteAdding();
    }

    private readonly BlockingCollection<WorkItem> _taskQ;

    public Task<string> EnqueueTask(string options, string claim, CancellationToken? cancelToken = null)
    {
        var tcs = new TaskCompletionSource<string>();
        _taskQ.Add(new WorkItem(tcs, options, claim, cancelToken));
        return tcs.Task;
    }

    public static Task<string> ProcessRequest(string options, string claim, CancellationToken? cancelToken = null)
    {
        return Task<string>.Factory.StartNew(() => ProcessItem(options, claim));
    }

    private void Consume()
    {
        foreach (var workItem in _taskQ.GetConsumingEnumerable())
        {
            if (workItem.CancelToken.HasValue && workItem.CancelToken.Value.IsCancellationRequested)
                workItem.TaskSource.SetCanceled();
            else
            {
                try
                {
                    workItem.TaskSource.SetResult(ProcessItem(workItem.Options, workItem.Claim));
                }
                catch (Exception ex)
                {
                    workItem.TaskSource.SetException(ex);
                }
            }
        }
    }

    private static string ProcessItem(string options, string claim)
    {
        // do some actual work here
        Thread.Sleep(2000); // simulate work;
        return options + claim; // return final result
    }
}