C# 读写作为并行任务

在两个并行任务中进行读写，如下所示：

Task[] tasks = new Task[2];
var entityCollection = new BlockingCollection<Dictionary<String, object>>();

tasks[0] = Task.Factory.StartNew(() => ReadData(entityCollection), TaskCreationOptions.LongRunning);
tasks[1] = Task.Factory.StartNew(() => WriteJsontoFile(JSONFileName, entityCollection), TaskCreationOptions.LongRunning);

Task.WaitAll(tasks);

Task[]tasks=新任务[2]；
var entityCollection=new BlockingCollection（）；
tasks[0]=Task.Factory.StartNew（（）=>ReadData（entityCollection），TaskCreationOptions.LongRunning）；
tasks[1]=Task.Factory.StartNew（（）=>WriteJsontoFile（JSONFileName，entityCollection），TaskCreationOptions.LongRunning）；
Task.WaitAll（任务）；

阅读任务：

private void ReadData(BlockingCollection<Dictionary<String, object>> collection)
{
    do
    {
        //continuously data is being read in to entities, this part is working fine and then adding it to collection of BlockingCollection type to be consumed in Write task
        entitites.ToList().ForEach(e => collection.Add(e));
    } while (true);
    collection.CompleteAdding();
}

private void ReadData（BlockingCollection）
{
做
{
//数据不断读入实体，这部分工作正常，然后将其添加到BlockingCollection类型的集合中，以便在写入任务中使用
entitites.ToList（）.ForEach（e=>collection.Add（e））；
}虽然（正确）；
collection.CompleteAdding（）；
}

写入任务：

private void WriteJsontoFile(String JsonFileName, BlockingCollection<Dictionary<String, object>> source)
{
    using (StreamWriter sw = new StreamWriter(JsonFileName, true))
    {
        Parallel.ForEach(source.GetConsumingPartitioner(), (line) => ser.Serialize(sw, line));
    }
}

private void WriteJsontoFile（字符串JsonFileName，BlockingCollection源）
{
使用（StreamWriter sw=newstreamwriter（JsonFileName，true））
{
Parallel.ForEach（source.GetConsumingPartitioner（），（line）=>ser.Serialize（sw，line））；
}
}

GetConsumingPartitioner（）相关代码：

public static class BlockingCollection
{
    public static Partitioner<T> GetConsumingPartitioner<T>(
    this BlockingCollection<T> collection)
    {
        return new BlockingCollectionPartitioner<T>(collection);
    }
}

class BlockingCollectionPartitioner<T> : Partitioner<T>
{
    private BlockingCollection<T> _collection;

    internal BlockingCollectionPartitioner(BlockingCollection<T> collection)
    {
        if (collection == null)
            throw new ArgumentNullException("collection");
        _collection = collection;
    }

    public override bool SupportsDynamicPartitions
    {
        get { return true; }
    }

    public override IList<IEnumerator<T>> GetPartitions(int partitionCount)
    {
        if (partitionCount < 1)
            throw new ArgumentOutOfRangeException("partitionCount");
        var dynamicPartitioner = GetDynamicPartitions();
        return Enumerable.Range(0, partitionCount).Select(_ =>
            dynamicPartitioner.GetEnumerator()).ToArray();
    }

    public override IEnumerable<T> GetDynamicPartitions()
    {
        return _collection.GetConsumingEnumerable();
    }
}

公共静态类阻止集合
{
公共静态分区器GetConsumingPartitioner(
此阻止集合（收集）
{
返回新的BlockingCollectionPartitioner（集合）；
}
}
类BlockingCollectionPartitioner:Partitioner
{
私人封锁收集(u收集);；
内部BlockingCollectionPartitioner（BlockingCollection集合）
{
if（集合==null）
抛出新的ArgumentNullException（“集合”）；
_收集=收集；
}
公共覆盖布尔支持动态分区
{
获取{return true；}
}
公共覆盖IList GetPartitions（int partitionCount）
{
如果（分区计数<1）
抛出新ArgumentOutOfRangeException（“partitionCount”）；
var dynamicPartitioner=GetDynamicPartitions（）；
返回可枚举的范围（0，partitionCount）。选择（=>
dynamicPartitioner.GetEnumerator（））.ToArray（）；
}
公共重写IEnumerable GetDynamicPartitions（）
{
return _collection.getconsumineGenumerable（）；
}
}

我在写入任务中遇到以下异常：

计数不能小于零。\r\n参数名称：计数

---

这不是消费的标准语法

---

这不是消费的标准语法

---

那么，这种例外情况究竟发生在哪里呢？它有什么类型和什么堆栈？出于某种奇怪的原因，VS显示此消息时没有更多信息“{无法计算表达式，因为线程在无法进行垃圾收集的点停止，可能是因为代码已优化。}”。不管怎样，布拉姆的答案是有效的。它适用于非常狭窄的示例代码，但您不能停止使用该代码（请不要使用超时或轮询循环…）。还有，为什么你使用了分割者，而现在却很高兴没有了他们？这是令人惊讶的，因为我认为你这样做是有原因的。下面是关于分区器的一些事情：我的工作代码中仍然有分区器，那么这种异常到底发生在哪里呢？它有什么类型和什么堆栈？出于某种奇怪的原因，VS显示此消息时没有更多信息“{无法计算表达式，因为线程在无法进行垃圾收集的点停止，可能是因为代码已优化。}”。不管怎样，布拉姆的答案是有效的。它适用于非常狭窄的示例代码，但您不能停止使用该代码（请不要使用超时或轮询循环…）。还有，为什么你使用了分割者，而现在却很高兴没有了他们？这是令人惊讶的，因为我认为你这样做是有原因的。以下是关于分区器的一些事情：我在工作代码中仍然有分区器实际上我在使用foreach（bc.getconsumineGenumerable（）中的var项）{//code}，实际上我在使用foreach（bc.getconsumineGenumerable（）中的var项）{//code}并且它正在工作

// Consume consume the BlockingCollection 
while (true) Console.WriteLine(bc.Take());