Rob conery's LazyList in .net 4.0, is this good enough?

Question

Can you suggest any further improvements that can be made with .net 4.0 in mind?

public class LazyList<T> : IList<T>
{
    public LazyList() 
    {
        myLazyList = new Lazy<IList<T>>(() =>
        {
            return new List<T>();
        });
    }

    public LazyList(IQueryable<T> query)
    {
        myLazyList = new Lazy<IList<T>>(() =>
        {
            return query.ToList();
        });
    }

    Lazy<IList<T>> myLazyList;

    public IEnumerator<T> GetEnumerator()
    {
        return myLazyList.Value.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return myLazyList.Value.GetEnumerator();
    }

    public int IndexOf(T item)
    {
        return myLazyList.Value.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        myLazyList.Value.Insert(index, item);
    }

    public void RemoveAt(int index)
    {
        myLazyList.Value.RemoveAt(index);
    }

    public T this[int index]
    {
        get
        {
            return myLazyList.Value[index];
        }
        set
        {
            myLazyList.Value[index] = value;
        }
    }

    public void Add(T item)
    {
        myLazyList.Value.Add(item);
    }

    public void Clear()
    {
        myLazyList.Value.Clear();
    }

    public bool Contains(T item)
    {
        return myLazyList.Value.Contains(item);
    }

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

    public int Count
    {
        get { return myLazyList.Value.Count; }
    }

    public bool IsReadOnly
    {
        get { return myLazyList.Value.IsReadOnly; }
    }

    public bool Remove(T item)
    {
        return myLazyList.Value.Remove(item);
    }

    public IList<T> Inner
    {
        get { return myLazyList.Value; }
    }
}