Why my ConcurentSet doesn't work?
<p>I was asking for any ConcurentSet/ConcurentQueue implementation here <a href="http://stackoverflow.com/questions/5845241/how-to-create-no-duplicates-concurrentqueue">how to create no-duplicates ConcurrentQueue?</a> but noone suggested anything.</p>

<p>So I've decided to wrote it myself, modified MSDN example slightly.
I've created <code>ConcurentSet</code> class. I insert the same element twice, and expect it to be inserted only once, because <code>Set</code> is used inside:</p>

<pre><code>                numbers.Add(i);
                Console.WriteLine("Add:{0} Count={1}", i, numbers.Count);
                numbers.Add(i);
                Console.WriteLine("Add:{0} Count={1}", i, numbers.Count);
</code></pre>

<p>However according to output elements inserted twice:</p>

<pre><code>    Add:0 Count=0
    Add:0 Count=1
    Add:1 Count=2
    Add:1 Count=3
    Add:2 Count=4
    Take:0
    Add:2 Count=5
    Add:3 Count=6
    Add:3 Count=7
    Add:4 Count=7
    Add:4 Count=8
    Take:3
    Add:5 Count=9
    Add:5 Count=10
    Add:6 Count=11
    Add:6 Count=12
</code></pre>

<p>The question is - why my ConcurentSet implementation doesn't work as expected?
I expect such output:</p>

<pre><code>    Add:0 Count=0
    Add:0 Count=0
    Add:1 Count=1
    Add:1 Count=1
    Add:2 Count=2
    Take:0
    Add:2 Count=1
    Add:3 Count=2
    Add:3 Count=2
    Add:4 Count=3
    Add:4 Count=3
    Take:3
    Add:5 Count=3
    Add:5 Count=3
    .....
</code></pre>

<p>Full listing below:</p>

<pre><code>using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace BCBlockingAccess
{
using System;
using System.Collections.Concurrent;

public class ConcurentSet
: IProducerConsumerCollection&lt;int&gt;
{
    private readonly object m_lockObject = new object();
    private readonly HashSet&lt;int&gt; m_set = new HashSet&lt;int&gt;();

    public void CopyTo(Array array, int index)
    {
        throw new NotImplementedException();
    }

    public int Count { get { return m_set.Count; } }

    public object SyncRoot { get { return m_lockObject; } }

    public bool IsSynchronized { get { return true; } }

    public void CopyTo(int[] array, int index)
    {
        throw new NotImplementedException();
    }

    public bool TryAdd(int item)
    {
        lock (m_lockObject)
        {
            m_set.Add(item);
        }

        return true;
    }

    public bool TryTake(out int item)
    {
        lock (m_lockObject)
        {
            foreach (var i in m_set)
            {
                if (m_set.Remove(i))
                {
                    item = i;
                    return true;
                }
            }
            item = -1;
            return false;
        }
    }

    public int[] ToArray()
    {
        throw new NotImplementedException();
    }

    public IEnumerator&lt;int&gt; GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}


class Program
{
    static void Main(string[] args)
    {
        // Increase or decrease this value as desired.
        int itemsToAdd = 50;

        // Preserve all the display output for Adds and Takes
        Console.SetBufferSize(80, (itemsToAdd * 5) + 3);

        // A bounded collection. Increase, decrease, or remove the 
        // maximum capacity argument to see how it impacts behavior.
        BlockingCollection&lt;int&gt; numbers = new BlockingCollection&lt;int&gt;(new ConcurentSet());


        // A simple blocking consumer with no cancellation.
        Task.Factory.StartNew(() =&gt;
        {
            int i = -1;
            while (!numbers.IsCompleted)
            {
                try
                {
                    i = numbers.Take();
                }
                catch (InvalidOperationException)
                {
                    Console.WriteLine("Adding was compeleted!");
                    break;
                }
                Console.WriteLine("Take:{0} ", i);

                // Simulate a slow consumer. This will cause
                // collection to fill up fast and thus Adds wil block.
                Thread.SpinWait(100000);
            }

            Console.WriteLine("\r\nNo more items to take. Press the Enter key to exit.");
        });

        // A simple blocking producer with no cancellation.
        Task.Factory.StartNew(() =&gt;
        {
            for (int i = 0; i &lt; itemsToAdd; i++)
            {
                numbers.Add(i);
                Console.WriteLine("Add:{0} Count={1}", i, numbers.Count);
                numbers.Add(i);
                Console.WriteLine("Add:{0} Count={1}", i, numbers.Count);
            }

            // See documentation for this method.
            numbers.CompleteAdding();
        });

        // Keep the console display open in debug mode.

        Console.ReadLine();
    }
}
}
</code></pre>
