ReadOnlyCollection oder IEnumerable zum Anzeigen von Mitgliedssammlungen?

Gibt es einen Grund, eine interne Sammlung als ReadOnlyCollection und nicht als IEnumerable verfügbar zu machen, wenn der aufrufende Code nur die Sammlung durchläuft?

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

Aus meiner Sicht ist IEnumerable eine Teilmenge der Schnittstelle von ReadOnlyCollection und erlaubt dem Benutzer nicht, die Sammlung zu ändern. Wenn also die IEnumberable-Schnittstelle ausreicht, ist dies die zu verwendende. Ist das eine richtige Art, darüber nachzudenken, oder fehlt mir etwas?

Danke / Erik

Modernere Lösung

Sofern die interne Sammlung nicht veränderbar sein muss, können Sie das System.Collections.ImmutablePaket verwenden, Ihren Feldtyp in eine unveränderliche Sammlung ändern und diese dann direkt verfügbar machen - vorausgesetzt Foonatürlich, sie ist unveränderlich.

Die Antwort wurde aktualisiert, um die Frage direkter zu beantworten

Gibt es einen Grund, eine interne Sammlung als ReadOnlyCollection und nicht als IEnumerable verfügbar zu machen, wenn der aufrufende Code nur die Sammlung durchläuft?

Es hängt davon ab, wie sehr Sie dem aufrufenden Code vertrauen. Wenn Sie die vollständige Kontrolle über alles haben, was dieses Mitglied jemals anrufen wird, und Sie garantieren, dass kein Code jemals verwendet wird:

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

Dann wird sicher kein Schaden angerichtet, wenn Sie die Sammlung direkt zurückgeben. Ich versuche im Allgemeinen, ein bisschen paranoider zu sein.

Ebenso, wie Sie sagen: Wenn Sie nur brauchen IEnumerable<T> , warum binden Sie sich dann an etwas Stärkeres?

Ursprüngliche Antwort

Wenn Sie .NET 3.5 verwenden, können Sie das Erstellen einer Kopie und die einfache Umwandlung vermeiden, indem Sie einen einfachen Aufruf von Überspringen verwenden:

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

(Es gibt viele andere Optionen für das einfache Umbrechen - das Schöne an SkipSelect / Where ist, dass es keinen Delegaten gibt, der für jede Iteration sinnlos ausgeführt werden kann.)

Wenn Sie .NET 3.5 nicht verwenden, können Sie einen sehr einfachen Wrapper schreiben, um dasselbe zu tun:

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

Wenn Sie nur die Sammlung durchlaufen müssen:

foreach (Foo f in bar.Foos)

dann reicht es aus, IEnumerable zurückzugeben .

Wenn Sie zufälligen Zugriff auf Elemente benötigen:

Foo f = bar.Foos[17];

Wickeln Sie es dann in ReadOnlyCollection ein .

Wenn Sie dies tun, hindert nichts Ihre Anrufer daran, die IEnumerable zurück in ICollection zu übertragen und sie dann zu ändern. ReadOnlyCollection entfernt diese Möglichkeit, obwohl es weiterhin möglich ist, über Reflektion auf die zugrunde liegende beschreibbare Sammlung zuzugreifen. Wenn die Sammlung klein ist, können Sie dieses Problem sicher und einfach umgehen, indem Sie stattdessen eine Kopie zurückgeben.

Ich vermeide es so oft wie möglich, ReadOnlyCollection zu verwenden. Es ist tatsächlich erheblich langsamer als nur die Verwendung einer normalen Liste. Siehe dieses Beispiel:

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

Manchmal möchten Sie möglicherweise eine Schnittstelle verwenden, möglicherweise, weil Sie die Sammlung während des Komponententests verspotten möchten. In meinem Blogeintrag finden Sie Informationen zum Hinzufügen Ihrer eigenen Benutzeroberfläche zu ReadonlyCollection mithilfe eines Adapters.