What is the best way to expose a List<T> as readonly?

Question

I've been around this design problem many times, and never found a killer solution.

I want to expose a collection that is editable in the owner class scope, but only readable for other public scopes.

Trial 1:

public class MyClass
{
    private List<object> _myList = new List<object>();

    public IEnumerable<object> MyList { get { return _myList; } }
}

The problem with this is a external code can just cast it back to List and edit, like this:

var x = ((List<object>)MyList);

Trial 2:

public class MyClass
{
    private List<object> _myList = new List<object>();

    public IEnumerable<object> MyList { get { return _myList.ToList(); } }
}

This way we prevent external modification, but create a unnecessary overhead of copying the List many times.

Trial 3:

public class MyClass
{
    private List<object> _myList = new List<object>();
    private ReadOnlyCollection<object> _roList = 
        new ReadOnlyCollection<object>(_myList)

    public IEnumerable<object> MyList { get { return _roList; } }
}

This is the standard solution, wich I use currently, but ReadOnlyCollection is about 30% slower:

Debug Trace:
Use normal foreach on the ReadOnlyCollection
Speed(ms): 2520,3203125
Result: 4999999950000000

use<list>.ForEach
Speed(ms): 1446,1796875
Result: 4999999950000000

Use normal foreach on the List
Speed(ms): 1891,2421875
Result: 4999999950000000

Is there a 'perfect' way of doing this? Thanks.

Answer 1

Have you tried returning the enumerator?

public class MyClass
{
    private List<object> _myList = new List<object>();

    public IEnumerable<object> MyList { get { yield return _myList.GetEnumerator(); } }
}

This doesn't create a copy, is readonly, and cannot be cast back to list.

Edit: this only works with yield return. It is lazy evaluated this way, I do not know whether that is an issue for you or not.

Answer 2

You can use List<T>.AsReadOnly method to expose a thin read-only wrapper of your list. There will be no additional copying, and the caller will "see" changes to the original array done inside your method instantaneously:

public ReadOnlyCollection<object> MyList { get { return _myList.AsReadOnly(); } }