Simple Freelock collection I wrote simple lock-free collection class for saving items from multithreading code. I did it just for fun and experience. Can you check my code for potentially problems please?     

    public class InputBox&lt;T&gt;
    {
        private BoxItem&lt;T&gt; _current;

        public InputBox()
        {
            _current = null;
        }

        public void Add(T value)
        {
            var nextItem = new BoxItem&lt;T&gt;(value);
            BoxItem&lt;T&gt; initialItem = null;
            do
            {
                initialItem = _current;
                nextItem.Next = _current;
            } while (initialItem != Interlocked.CompareExchange(ref _current,
                                                                nextItem,
                                                                initialItem));
        }

        public bool TryAdd(T value)
        {
            var initialItem = _current;
            return initialItem ==
                   Interlocked.CompareExchange(ref _current, 
                                               new BoxItem&lt;T&gt;(value, _current), 
                                               initialItem);
        }

        public BoxResultCollection&lt;T&gt; TakeAll()
        {
            return new BoxResultCollection&lt;T&gt;(_current);
        }
    }

    internal sealed class BoxItem&lt;T&gt;
    {
        private readonly T _value;
        private BoxItem&lt;T&gt; _next;

        internal BoxItem(T value)
            :this(value, null)
        {
            // empty
        }

        internal BoxItem(T value, BoxItem&lt;T&gt; next)
        {
            _value = value;
            _next = next;
        }

        internal T Value
        {
            get { return _value; }
        }

        internal BoxItem&lt;T&gt; Next
        {
            get { return _next; }
            set { _next = value; }
        }
    }

    public class BoxResultCollection&lt;T&gt; : IEnumerable&lt;T&gt;
    {
        private readonly BoxItem&lt;T&gt; _root;

        internal BoxResultCollection(BoxItem&lt;T&gt; root)
        {
            _root = root;
        }

        public IEnumerator&lt;T&gt; GetEnumerator()
        {
            var current = _root;

            while (current != null)
            {
                yield return current.Value;
                current = current.Next;
            }

            yield break;
        }

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

        public bool IsEmpty
        {
            get { return _root == null; }
        }

        public IEnumerable&lt;T&gt; ToEnumerable()
        {
            return this;
        }
    }
public bool TryAdd(T value)


A method that intentionally doesn't work when there is contention? I don't see how would that be ever useful.

internal BoxItem&lt;T&gt; Next
{
    get { return _next; }
    set { _next = value; }
}


You could have used an autoproperty here.

yield break;


Adding yield break; at the end of iterator method is the same as adding return; at te end of a normal void method: the method would work exactly the same without it.

public IEnumerable&lt;T&gt; ToEnumerable()


I don't see how would this method be useful. Especially since there already is AsEnumerable() extension method that does exactly the same thing.