Suppose I have a method public List<User> GetBatchOfUsers(IEnumerable<int> userI

Question

Suppose I have a method

public List<User> GetBatchOfUsers(IEnumerable<int> userIDs)
{
    List<User> users = new List<User>();

    // some database stuff

    return users;
}
I have read that it would be better to return an interface (either IList or IEnumerable) as opposed to returning a List. Some arguments I have heard for doing so is that it hides data, and gives the API developer the flexibility of changing the internal representation of the data at a later date.

My concern about just returning an IEnumerable is that you lose functionality, such as random access and the Count property.

I know that accepting an IEnumerable as a parameter makes sense, as it gives the consumer the best flexibility to send data to my method, the minimalist set of requirements for the method to operate.

What is the best practice for the return type?

Explanation / Answer

Generally speaking, you may start with interfaces, and only move to put the concrete type as the return type if you find that you use the extra methods more frequently than expected.

Well, if you return an interface, you retain more flexibility. You can change the implementation later to return a different concrete type. On the other hand, it obviously gives the caller less information, so they may not be able to perform certain operations. (For example: if you return List<T>, the caller can use ConvertAll etc... which they can't if you only declare that you return IList<T>.) In some situations it's worth specifying the concrete type.

Regarding Count or Sort method, there is no standard collection interfaces for that . However, you could write an extension method to sort or count any IList.

Related Questions

Navigate

• Browse (All)
• Browse S
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.