Custom Dynamic Array Pretty simple class but just want to make sure I've approached it correctly.

public class DynamicArray&lt;T&gt; : IEnumerable&lt;T&gt;, ICollection&lt;T&gt;
    {
        private T[] _items;
        private int _size;
        private const int _growFactor = 2;

        public DynamicArray()
        {
            _items = new T[4];
        }

        public int Count
        {
            get
            {
                return _size;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public void Add(T item)
        {
            if (_size + 1 &gt; _items.Length)
            {
                var newArray = new T[_items.Length * _growFactor];
                _items.CopyTo(newArray, 0);
                _items = newArray;
            }
            _items[_size] = item;
            _size++;
        }

        public void Clear()
        {
            _items = new T[2];
            _size = 0;
        }

        public bool Contains(T item)
        {
            foreach(var value in _items)
            {
                if (value.Equals(item))
                {
                    return true;
                }
            }
            return false;
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            _items.CopyTo(array, arrayIndex);
        }

        public IEnumerator&lt;T&gt; GetEnumerator()
        {
            for(var i = 0; i &lt; _size; i++)
            {
                yield return _items[i];
            }
        }

        public bool Remove(T item)
        {
            for(var i = 0; i &lt; _items.Length; i++)
            {
                if (_items[i].Equals(item))
                {
                    _items[i] = default(T);
                    _size--;
                    return true;
                }
            }
            return false;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
Just a couple of minor points:


In your constructor, you create an the array with an initial size of 4: 

_items = new T[4];


However in your Clear method you set it to an size of 2:

_items = new T[2];


It's odd that you set it to a smaller number.  If you had a constant for initial size, or called Clear from the constructor this could be avoided.
That said, do you really want clear to discard _items?  If you're reusing the array in a similar section of code, it seems reasonable to assume that after Clear has been called, there is a good chance the the array would grow again to a similar size.  It may be more efficient to simply reset _size, but leave _items intact.  Obviously this depends how you're using the array as to whether or not it's a good idea...
You don't limit the size of the array.  Dynamic doubling whilst efficient, can get big pretty quick.  You might want to consider adding a maximum size to your array, again, this would depend on what you're using it for as to whether or not it's worth while.  List limits it's growth for example, albeit to a rather large number.