ReadOnlyCollection lub IEnumerable do ujawniania kolekcji elementów członkowskich?

Czy istnieje jakiś powód, aby uwidaczniać kolekcję wewnętrzną jako ReadOnlyCollection, a nie IEnumerable, jeśli kod wywołujący wykonuje iterację tylko po kolekcji?

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

Jak widzę, IEnumerable jest podzbiorem interfejsu ReadOnlyCollection i nie pozwala użytkownikowi modyfikować kolekcji. Więc jeśli interfejs IEnumberable jest wystarczający, to jest ten, którego należy użyć. Czy to właściwy sposób rozumowania, czy czegoś mi brakuje?

Dzięki / Erik

Bardziej nowoczesne rozwiązanie

O ile nie potrzebujesz, aby kolekcja wewnętrzna była zmienna, możesz użyć System.Collections.Immutablepakietu, zmienić typ pola na niezmienną kolekcję, a następnie ujawnić to bezpośrednio - Foooczywiście zakładając , że jest niezmienny.

Zaktualizowana odpowiedź, aby bardziej bezpośrednio odpowiedzieć na pytanie

Czy istnieje jakiś powód, aby uwidaczniać kolekcję wewnętrzną jako ReadOnlyCollection, a nie IEnumerable, jeśli kod wywołujący wykonuje iterację tylko po kolekcji?

To zależy od tego, jak bardzo ufasz kodowi dzwoniącemu. Jeśli masz pełną kontrolę nad wszystkim, co kiedykolwiek zadzwoni do tego członka i gwarantujesz, że żaden kod nigdy nie użyje:

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

to z pewnością nic się nie stanie, jeśli po prostu zwrócisz kolekcję bezpośrednio. Jednak generalnie staram się być trochę bardziej paranoikiem.

Podobnie, jak mówisz: jeśli tylko potrzebujesz IEnumerable<T> , to po co przywiązywać się do czegoś mocniejszego?

Oryginalna odpowiedź

Jeśli używasz .NET 3.5, możesz uniknąć tworzenia kopii i prostego rzutowania, używając prostego wywołania Skip:

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

(Istnieje wiele innych opcji zawijania w trywialny sposób - fajną rzeczą Skipw przypadku opcji Select / Where jest to, że nie ma delegata do bezcelowego wykonywania dla każdej iteracji).

Jeśli nie używasz .NET 3.5, możesz napisać bardzo prosty wrapper, który zrobi to samo:

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

Jeśli potrzebujesz tylko iterować po kolekcji:

foreach (Foo f in bar.Foos)

wtedy wystarczy zwrócić IEnumerable .

Jeśli potrzebujesz losowego dostępu do przedmiotów:

Foo f = bar.Foos[17];

następnie zawiń go w ReadOnlyCollection .

Jeśli to zrobisz, nic nie powstrzyma twoich rozmówców przed rzutowaniem IEnumerable z powrotem do ICollection, a następnie zmodyfikowaniem go. ReadOnlyCollection usuwa tę możliwość, chociaż nadal można uzyskać dostęp do podstawowej zapisywalnej kolekcji za pośrednictwem odbicia. Jeśli kolekcja jest niewielka, bezpiecznym i łatwym sposobem obejścia tego problemu jest zwrócenie kopii.

Unikam używania ReadOnlyCollection tak bardzo, jak to możliwe, w rzeczywistości jest to znacznie wolniejsze niż zwykłe używanie zwykłej listy. Zobacz ten przykład:

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

Czasami możesz chcieć użyć interfejsu, być może dlatego, że chcesz mockować kolekcję podczas testów jednostkowych. Zobacz mój wpis na blogu, aby dodać własny interfejs do ReadonlyCollection za pomocą adaptera.