ReadOnlyCollection ou IEnumerable para expor coleções de membros?

Existe algum motivo para expor uma coleção interna como um ReadOnlyCollection em vez de um IEnumerable se o código de chamada iterar apenas sobre a coleção?

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 meu ver, IEnumerable é um subconjunto da interface do ReadOnlyCollection e não permite que o usuário modifique a coleção. Portanto, se a interface IEnumberable for suficiente, essa é a única a ser usada. Essa é uma maneira adequada de argumentar sobre isso ou estou perdendo alguma coisa?

Obrigado / Erik

Solução mais moderna

A menos que você precise que a coleção interna seja mutável, você pode usar o System.Collections.Immutablepacote, alterar seu tipo de campo para ser uma coleção imutável e expô-la diretamente - assumindo que Fooela é imutável, é claro.

Resposta atualizada para responder à pergunta mais diretamente

Existe algum motivo para expor uma coleção interna como um ReadOnlyCollection em vez de um IEnumerable se o código de chamada iterar apenas sobre a coleção?

Depende de quanto você confia no código de chamada. Se você tiver controle total sobre tudo o que chamará esse membro e garantir que nenhum código será usado:

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

então, certamente, nenhum dano será causado se você apenas devolver a coleção diretamente. Eu geralmente tento ser um pouco mais paranóico do que isso.

Da mesma forma, como você diz: se você só precisa IEnumerable<T> , por que se amarrar a algo mais forte?

Resposta original

Se você estiver usando o .NET 3.5, evite fazer uma cópia e evitar a conversão simples usando uma chamada simples para Ignorar:

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

(Existem muitas outras opções para agrupar trivialmente - o Skipmais interessante de Selecionar / Onde é que não há delegado para executar sem sentido para cada iteração.)

Se você não estiver usando o .NET 3.5, você pode escrever um invólucro muito simples para fazer a mesma coisa:

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

Se você apenas precisar percorrer a coleção:

foreach (Foo f in bar.Foos)

devolver IEnumerable é suficiente.

Se você precisar de acesso aleatório aos itens:

Foo f = bar.Foos[17];

Em seguida, envolva-o em ReadOnlyCollection .

Se você fizer isso, nada impedirá que os chamadores convertam o IEnumerable de volta ao ICollection e o modifiquem. O ReadOnlyCollection remove essa possibilidade, embora ainda seja possível acessar a coleção gravável subjacente por meio de reflexão. Se a coleção for pequena, uma maneira fácil e segura de contornar esse problema é retornar uma cópia.

Evito usar o ReadOnlyCollection, tanto quanto possível, é realmente consideravelmente mais lento do que apenas usar uma lista normal. Veja este exemplo:

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());

Às vezes, você pode querer usar uma interface, talvez porque queira zombar da coleção durante o teste de unidade. Consulte a entrada do meu blog para adicionar sua própria interface ao ReadonlyCollection usando um adaptador.