public interface IProducerConsumerCollection<T> : IEnumerable<T>, ICollection

{

    void CopyTo(T[] array, int index);

    bool TryAdd(T item);

    bool TryTake(out T item);

    T[] ToArray();

}

 public class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>

{

    [NonSerialized]

    private volatile Segment m_head;

    [NonSerialized]

    private volatile Segment m_tail;

    private T[] m_serializationArray; // Used for custom serialization.

    private const int SEGMENT_SIZE = ;

    //number of snapshot takers, GetEnumerator(), ToList() and ToArray() operations take snapshot.

    [NonSerialized]

    internal volatile int m_numSnapshotTakers = ;

    public ConcurrentQueue()

    {

        m_head = m_tail = new Segment(, this);

    }

    public ConcurrentQueue(IEnumerable<T> collection)

    {

        if (collection == null)

        {

            throw new ArgumentNullException("collection");

        }

        InitializeFromCollection(collection);

    }

    private void InitializeFromCollection(IEnumerable<T> collection)

    {

        Segment localTail = new Segment(, this);//use this local variable to avoid the extra volatile read/write. this is safe because it is only called from ctor

        m_head = localTail; 

        int index = ;

        foreach (T element in collection)

        {

            Contract.Assert(index >=  && index < SEGMENT_SIZE);

            localTail.UnsafeAdd(element);

            index++;

            if (index >= SEGMENT_SIZE)

            {

                localTail = localTail.UnsafeGrow();

                index = ;

            }

        }

        m_tail = localTail;

    }

    public void Enqueue(T item)

    {

        SpinWait spin = new SpinWait();

        while (true)

        {

            Segment tail = m_tail;

            if (tail.TryAppend(item))

                return;

            spin.SpinOnce();

        }

    }

    public bool TryDequeue(out T result)

    {

        while (!IsEmpty)

        {

            Segment head = m_head;

            if (head.TryRemove(out result))

                return true;

            //since method IsEmpty spins, we don't need to spin in the while loop

        }

        result = default(T);

        return false;

    }

    private class Segment

   {

        internal volatile T[] m_array;

        internal volatile VolatileBool[] m_state;

        private volatile Segment m_next;

        internal readonly long m_index;

        private volatile int m_low;

        private volatile int m_high;

        private volatile ConcurrentQueue<T> m_source;

        internal Segment(long index, ConcurrentQueue<T> source)

        {

            m_array = new T[SEGMENT_SIZE];

            m_state = new VolatileBool[SEGMENT_SIZE]; //all initialized to false

            m_high = -;

            Contract.Assert(index >= );

            m_index = index;

            m_source = source;

        }

        internal void UnsafeAdd(T value)

        {

            Contract.Assert(m_high < SEGMENT_SIZE - );

            m_high++;

            m_array[m_high] = value;

            m_state[m_high].m_value = true;

        }

       internal Segment UnsafeGrow()

        {

            Contract.Assert(m_high >= SEGMENT_SIZE - );

            Segment newSegment = new Segment(m_index + , m_source); //m_index is Int64, we don't need to worry about overflow

            m_next = newSegment;

            return newSegment;

        }

      internal void Grow()

        {

            //no CAS is needed, since there is no contention (other threads are blocked, busy waiting)

            Segment newSegment = new Segment(m_index + , m_source);  //m_index is Int64, we don't need to worry about overflow

            m_next = newSegment;

            Contract.Assert(m_source.m_tail == this);

            m_source.m_tail = m_next;

        }    

       internal bool TryAppend(T value)

       {

            if (m_high >= SEGMENT_SIZE - )

            {

                return false;

            }

            try

            { }

            finally

            {

                newhigh = Interlocked.Increment(ref m_high);

                if (newhigh <= SEGMENT_SIZE - )

                {

                    m_array[newhigh] = value;

                    m_state[newhigh].m_value = true;

                }

                if (newhigh == SEGMENT_SIZE - )

                {

                    Grow();

                }

            }

            return newhigh <= SEGMENT_SIZE - ;

        }

      internal bool TryRemove(out T result)

        {

            SpinWait spin = new SpinWait();

            int lowLocal = Low, highLocal = High;

            while (lowLocal <= highLocal)

            {

                if (Interlocked.CompareExchange(ref m_low, lowLocal + , lowLocal) == lowLocal)

                {

                    SpinWait spinLocal = new SpinWait();

                    while (!m_state[lowLocal].m_value)

                    {

                        spinLocal.SpinOnce();

                    }

                    result = m_array[lowLocal];

                    if (m_source.m_numSnapshotTakers <= )

                    {

                        m_array[lowLocal] = default(T); //release the reference to the object.

                    }

                    if (lowLocal +  >= SEGMENT_SIZE)

                    {

                        spinLocal = new SpinWait();

                        while (m_next == null)

                        {

                            spinLocal.SpinOnce();

                        }

                        Contract.Assert(m_source.m_head == this);

                        m_source.m_head = m_next;

                    }

                    return true;

                }

                else

                {

                    spin.SpinOnce();

                    lowLocal = Low; highLocal = High;

                }

            }//end of while

            result = default(T);

            return false;

        }

 }

}