ReadOnlyCollection or IEnumerable for exposing member collections?

by

More modern solution

Unless you need the internal collection to be mutable, you could use the System.Collections.Immutable package, change your field type to be an immutable collection, and then expose that directly – assuming Foo itself is immutable, of course.

Updated answer to address the question more directly

Is there any reason to expose an internal collection as a ReadOnlyCollection rather than an IEnumerable if the calling code only iterates over the collection?

It depends on how much you trust the calling code. If you’re in complete control over everything that will ever call this member and you guarantee that no code will ever use:

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

then sure, no harm will be done if you just return the collection directly. I generally try to be a bit more paranoid than that though.

Likewise, as you say: if you only need IEnumerable<T>, then why tie yourself to anything stronger?

Original answer

If you’re using .NET 3.5, you can avoid making a copy and avoid the simple cast by using a simple call to Skip:

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

(There are plenty of other options for wrapping trivially – the nice thing about Skip over Select/Where is that there’s no delegate to execute pointlessly for each iteration.)

If you’re not using .NET 3.5 you can write a very simple wrapper to do the same thing:

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

More Related Contents:

  1. How to check if IEnumerable is null or empty?
  2. IEnumerable and order
  3. Creating a blocking Queue in .NET?
  4. The order of elements in Dictionary
  5. Count the items from a IEnumerable without iterating?
  6. .NET HashTable Vs Dictionary – Can the Dictionary be as fast?
  7. C# Set collection?
  8. Collection versus List what should you use on your interfaces?
  9. Pair-wise iteration in C# or sliding window enumerator
  10. Passing a single item as IEnumerable
  11. Is there anything like asynchronous BlockingCollection?
  12. What .NET collection provides the fastest search
  13. Does List guarantee insertion order?
  14. The opposite of Intersect()
  15. When a class is inherited from List, XmlSerializer doesn’t serialize other attributes
  16. IEnumerable to string [duplicate]
  17. C# Sortable collection which allows duplicate keys
  18. What is the difference between IEnumerator and IEnumerable? [duplicate]
  19. Does the Enumerator of a Dictionary return key value pairs in the order they were added?
  20. IEnumerable vs IReadonlyCollection vs ReadonlyCollection for exposing a list member
  21. Difference between IEnumerable Count() and Length
  22. Initial capacity of collection types, e.g. Dictionary, List
  23. What is the purpose of AsQueryable()?
  24. C# List – Removing items while looping / iterating [duplicate]
  25. Is it possible to create some IGrouping object
  26. What’s Wrong with an ArrayList?
  27. Why do arrays in .net only implement IEnumerable and not IEnumerable?
  28. How to get random values from array in C# [duplicate]
  29. Map two lists into a dictionary in C#
  30. generic NOT constraint where T : !IEnumerable

Leave a Comment