Easiest way to create Set shared between Consumer and Producer?

Question

I need to create a set which would be shared between Consumer and Producer. I can't use BlockingCollection, because for some reason "BlockingCollection maintains its own count and doesn't use count of underlying ConcurrentSet of yours therefore even if duplicates are ignored, the count increases." refer my previous question Why my ConcurentSet doesn't work?

I really confused why BlockingCollection wrote such a strange way? Does it mean that there are a mistake in C# library class, and because of it I have to use classical, "hard" approach http://msdn.microsoft.com/en-us/library/yy12yx1f(v=vs.80).aspx

Just want to triple-check my undertanding, because in 99% cases libraries are well-written, but I just don't understand something...

upd If it makes sense - my set can contain only integers from 1 to 100.

Answer 1

I have read your previous question "What type of IProducerConsumerCollection to use for my task?". If I understand it correctly, on one hand you want to process the data from sensors in approximate FIFO order, but on the other hand if data from some sensor weren't yet processed when newer data are ready, you want to update it discarding the older data.

I would suggest the following schema to you.
For the sensor data, simply use an array; you indicated that this is sufficient:

All I need is an array of 100 elements. Sensor #33 should REPLACE it's value into array[33] Consumer should take value from array[33] and if not null, then send it and set array[33] to null. Consumer should react on any not null values in array asap.

The trick is how you update the data. For that, use Interlocked.Exchange instead of plain read/write. A producer uses it to write the new value, and then checks what was the old value (as returned by Interlocked.Exchange). If not null, the old value was not read by the consumer, and you just successfully replaced it. If the old value was null, the previos data have been consumed; in this case, the producer sends a message to the consumer that new data are available. The message can consist of the number of the array cell to read, and can be sent through ConcurrentQueue or another suitable mechanism.
The consumer waits for a message to arrive through that mechanism, finds the updated array cell number in the message, and also uses Interlocked.Exchange to replace the current value in that cell with null, getting the value back as the result of the operation. It will always get the most recent value written into the cell, and it will process values in the order of messages being obtained; with ConcurrentQueue, it should be FIFO.