Collection versus List what should you use on your interfaces?

by

To answer the “why” part of the question as to why not List<T>, The reasons are future-proofing and API simplicity.

Future-proofing

List<T> is not designed to be easily extensible by subclassing it; it is designed to be fast for internal implementations. You’ll notice the methods on it are not virtual and so cannot be overridden, and there are no hooks into its Add/Insert/Remove operations.

This means that if you need to alter the behavior of the collection in the future (e.g. to reject null objects that people try to add, or to perform additional work when this happens such as updating your class state) then you need to change the type of collection you return to one you can subclass, which will be a breaking interface change (of course changing the semantics of things like not allowing null may also be an interface change, but things like updating your internal class state would not be).

So by returning either a class that can be easily subclassed such as Collection<T> or an interface such as IList<T>, ICollection<T> or IEnumerable<T> you can change your internal implementation to be a different collection type to meet your needs, without breaking the code of consumers because it can still be returned as the type they are expecting.

API Simplicity

List<T> contains a lot of useful operations such as BinarySearch, Sort and so on. However if this is a collection you are exposing then it is likely that you control the semantics of the list, and not the consumers. So while your class internally may need these operations it is very unlikely that consumers of your class would want to (or even should) call them.

As such, by offering a simpler collection class or interface, you reduce the number of members that users of your API see, and make it easier for them to use.

More Related Contents:

  1. Creating a blocking Queue in .NET?
  2. CA2202, how to solve this case
  3. What’s the best way of implementing a thread-safe Dictionary?
  4. Bidirectional 1 to 1 Dictionary in C#
  5. .NET HashTable Vs Dictionary – Can the Dictionary be as fast?
  6. C# Set collection?
  7. Is there a built-in method to compare collections?
  8. ReadOnlyCollection or IEnumerable for exposing member collections?
  9. How to check if IEnumerable is null or empty?
  10. Is there anything like asynchronous BlockingCollection?
  11. What .NET collection provides the fastest search
  12. Does List guarantee insertion order?
  13. The opposite of Intersect()
  14. C# Sortable collection which allows duplicate keys
  15. Does the Enumerator of a Dictionary return key value pairs in the order they were added?
  16. Does C# have a way of giving me an immutable Dictionary?
  17. Thread safe collections in .NET
  18. Is there a tool for finding unreferenced functions (dead, obsolete code) in a C# app? [closed]
  19. Initial capacity of collection types, e.g. Dictionary, List
  20. C# List – Removing items while looping / iterating [duplicate]
  21. Returning ‘IList’ vs ‘ICollection’ vs ‘Collection’
  22. Is it possible to create some IGrouping object
  23. IEnumerable and order
  24. What’s Wrong with an ArrayList?
  25. How to get random values from array in C# [duplicate]
  26. Interprocess communication for Windows in C# (.NET 2.0)
  27. Application.OpenForms.Count = 0 always
  28. Parse Math Expression [duplicate]
  29. Currency format for display
  30. What’s the best strategy for Equals and GetHashCode?

Leave a Comment