Question

This is the scenario: In a separate task I read from a datareader which represent a single column result set with a string, a JSON. In that task I add the JSON string to a BlockingCollection that wraps the ConcurrentQueue. At the same time in the main thread I TryTake/dequeue a JSON string from the collection and then yield return it deserialized.

The reading from the database and the deserialization is approximately of the same speed so there will not be to much memory consumption caused by a large BlockingCollection.

When the reading from the database is done, the task is closed and I then deserialize all the non deserialized JSON strings.

Questions/thoughts:

1) Does the TryTake lock so that no adding can be done?

2) Don’t do it. Just do it in serial and yield return.

using (var q = new BlockingCollection<string>())
{
Task task = null;

try
{
    task = new Task(() =>
    {
        foreach (var json in sourceData)
            q.Add(json);
    });

    task.Start();

    while (!task.IsCompleted)
    {
        string json;
        if (q.TryTake(out json))
            yield return Deserialize<T>(json);
    }

    Task.WaitAll(task);
}
finally 
{
    if (task != null)
    {
        task.Dispose();
    }

    q.CompleteAdding();
}

foreach (var e in q.GetConsumingEnumerable())
    yield return Deserialize<T>(e);
}

Answer 1

Question 1

Does the TryTake lock so that no adding can be done

There will be a very brief period whereby an add cannot be performed, however this time will be negligible. From http://msdn.microsoft.com/en-us/library/dd997305.aspx

Some of the concurrent collection types use lightweight
synchronization mechanisms such as SpinLock, SpinWait, SemaphoreSlim,
and CountdownEvent, which are new in the .NET Framework 4. These
synchronization types typically use busy spinning for brief periods
before they put the thread into a true Wait state. When wait times are
expected to be very short, spinning is far less computationally
expensive than waiting, which involves an expensive kernel transition.
For collection classes that use spinning, this efficiency means that
multiple threads can add and remove items at a very high rate. For
more information about spinning vs. blocking, see SpinLock and
SpinWait.

The ConcurrentQueue and ConcurrentStack classes do not use locks
at all. Instead, they rely on Interlocked operations to achieve
thread-safety.

Question 2:

Don’t do it. Just do it in serial and yield return.

This seems like the way to go. As with any optimisation work – do what is simplest and then measure! If there is a bottleneck here consider optimising, but at least you’ll know if your ‘optimistations’ are actually helping by virtue of having metrics to compare against.