ReadOnlyCollection o IEnumerable per esporre raccolte di membri?

C'è qualche motivo per esporre una raccolta interna come ReadOnlyCollection anziché IEnumerable se il codice chiamante scorre solo sulla raccolta?

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 mio avviso, IEnumerable è un sottoinsieme dell'interfaccia di ReadOnlyCollection e non consente all'utente di modificare la raccolta. Quindi, se l'interfaccia IEnumberable è sufficiente, quella è quella da usare. È un modo corretto di ragionare al riguardo o mi sto perdendo qualcosa?

Grazie / Erik

Soluzione più moderna

A meno che non sia necessario che la raccolta interna sia mutabile, è possibile utilizzare il System.Collections.Immutablepacchetto, modificare il tipo di campo in una raccolta immutabile e quindi esporlo direttamente - presupponendo che Foosia immutabile, ovviamente.

Risposta aggiornata per rispondere alla domanda in modo più diretto

C'è qualche motivo per esporre una raccolta interna come ReadOnlyCollection anziché IEnumerable se il codice chiamante scorre solo sulla raccolta?

Dipende da quanto ti fidi del codice chiamante. Se hai il controllo completo su tutto ciò che chiamerà mai questo membro e garantisci che nessun codice verrà mai utilizzato:

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

quindi certo, non verrà fatto alcun danno se si restituisce direttamente la raccolta. In genere cerco di essere un po 'più paranoico di quello.

Allo stesso modo, come dici: se ne hai solo bisogno IEnumerable<T> , perché legarti a qualcosa di più forte?

Risposta originale

Se stai usando .NET 3.5, puoi evitare di fare una copia ed evitare il cast semplice usando una semplice chiamata a Skip:

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

(Esistono molte altre opzioni per Skipeseguire il wrapping banalmente: la cosa bella di oltre Select / Where è che non c'è delegato da eseguire inutilmente per ogni iterazione.)

Se non stai utilizzando .NET 3.5 puoi scrivere un wrapper molto semplice per fare la stessa cosa:

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

Se hai solo bisogno di scorrere la raccolta:

foreach (Foo f in bar.Foos)

quindi è sufficiente restituire IEnumerable .

Se hai bisogno di un accesso casuale agli oggetti:

Foo f = bar.Foos[17];

quindi avvolgilo in ReadOnlyCollection .

Se lo fai, non c'è niente che impedisce ai chiamanti di riportare IEnumerable su ICollection e di modificarlo. ReadOnlyCollection rimuove questa possibilità, sebbene sia ancora possibile accedere alla raccolta scrivibile sottostante tramite la riflessione. Se la raccolta è piccola, un modo semplice e sicuro per aggirare questo problema è restituire una copia.

Evito di utilizzare ReadOnlyCollection il più possibile, in realtà è considerevolmente più lento di un semplice elenco. Vedi questo esempio:

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 volte potresti voler usare un'interfaccia, forse perché vuoi deridere la raccolta durante i test delle unità. Si prega di consultare il mio blog per l'aggiunta della propria interfaccia a ReadonlyCollection utilizzando un adattatore.