ReadOnlyCollection o IEnumerable para exponer colecciones de miembros?

¿Hay alguna razón para exponer una colección interna como ReadOnlyCollection en lugar de IEnumerable si el código de llamada solo itera sobre la colección?

class Bar
{
    private ICollection<Foo> foos;

    // Which one is to be preferred?
    public IEnumerable<Foo> Foos { ... }
    public ReadOnlyCollection<Foo> Foos { ... }
}


// Calling code:

foreach (var f in bar.Foos)
    DoSomething(f);

A mi entender, IEnumerable es un subconjunto de la interfaz de ReadOnlyCollection y no permite al usuario modificar la colección. Entonces, si la interfaz IEnumberable es suficiente, entonces esa es la que hay que usar. ¿Es esa una forma adecuada de razonar al respecto o me estoy perdiendo algo?

Gracias / Erik

Solución más moderna

A menos que necesite que la colección interna sea mutable, puede usar el System.Collections.Immutablepaquete, cambiar su tipo de campo para que sea una colección inmutable y luego exponerlo directamente, suponiendo que Foosea ​​inmutable, por supuesto.

Respuesta actualizada para abordar la pregunta más directamente

¿Hay alguna razón para exponer una colección interna como ReadOnlyCollection en lugar de IEnumerable si el código de llamada solo itera sobre la colección?

Depende de cuánto confíes en el código de llamada. Si tiene el control total sobre todo lo que alguna vez llamará a este miembro y garantiza que ningún código usará:

ICollection<Foo> evil = (ICollection<Foo>) bar.Foos;
evil.Add(...);

entonces seguro, no se hará daño si solo devuelve la colección directamente. Sin embargo, generalmente trato de ser un poco más paranoico que eso.

Del mismo modo, como dices: si solo necesitas IEnumerable<T> , ¿por qué atarte a algo más fuerte?

Respuesta original

Si está utilizando .NET 3.5, puede evitar hacer una copia y evitar la conversión simple mediante una simple llamada para Omitir:

public IEnumerable<Foo> Foos {
    get { return foos.Skip(0); }
}

(Hay muchas otras opciones para ajustar trivialmente; lo bueno de Skipseleccionar / Dónde es que no hay delegado para ejecutar sin sentido para cada iteración).

Si no está utilizando .NET 3.5, puede escribir un contenedor muy simple para hacer lo mismo:

public static IEnumerable<T> Wrapper<T>(IEnumerable<T> source)
{
    foreach (T element in source)
    {
        yield return element;
    }
}

Si solo necesita recorrer la colección:

foreach (Foo f in bar.Foos)

entonces devolver IEnumerable es suficiente.

Si necesita acceso aleatorio a los elementos:

Foo f = bar.Foos[17];

luego envuélvala en ReadOnlyCollection .

Si hace esto, no hay nada que impida que las personas que llaman vuelvan el IEnumerable a ICollection y luego lo modifiquen. ReadOnlyCollection elimina esta posibilidad, aunque todavía es posible acceder a la colección de escritura subyacente a través de la reflexión. Si la colección es pequeña, una forma segura y fácil de solucionar este problema es devolver una copia.

Evito usar ReadOnlyCollection tanto como sea posible, en realidad es considerablemente más lento que simplemente usar una Lista normal. Ver este ejemplo:

List<int> intList = new List<int>();
        //Use a ReadOnlyCollection around the List
        System.Collections.ObjectModel.ReadOnlyCollection<int> mValue = new System.Collections.ObjectModel.ReadOnlyCollection<int>(intList);

        for (int i = 0; i < 100000000; i++)
        {
            intList.Add(i);
        }
        long result = 0;

        //Use normal foreach on the ReadOnlyCollection
        TimeSpan lStart = new TimeSpan(System.DateTime.Now.Ticks);
        foreach (int i in mValue)
            result += i;
        TimeSpan lEnd = new TimeSpan(System.DateTime.Now.Ticks);
        MessageBox.Show("Speed(ms): " + (lEnd.TotalMilliseconds - lStart.TotalMilliseconds).ToString());
        MessageBox.Show("Result: " + result.ToString());

        //use <list>.ForEach
        lStart = new TimeSpan(System.DateTime.Now.Ticks);
        result = 0;
        intList.ForEach(delegate(int i) { result += i; });
        lEnd = new TimeSpan(System.DateTime.Now.Ticks);
        MessageBox.Show("Speed(ms): " + (lEnd.TotalMilliseconds - lStart.TotalMilliseconds).ToString());
        MessageBox.Show("Result: " + result.ToString());

A veces es posible que desee utilizar una interfaz, tal vez porque quiere burlarse de la colección durante las pruebas unitarias. Consulte mi entrada de blog para agregar su propia interfaz a ReadonlyCollection utilizando un adaptador.