Possible Duplicate:
C# - List<T> or IList<T>
When I return a list from my method I can do in 2 way. As a List
Private List<datatype> MethodName()
{
Return List
}
As a IList
Private IList<datatype> MethodName()
{
Return IList
}
As I heard we should return it as a IList. Is anyone can explain whys that?
You can't return an IList - you need to return an implementation of that interface (i.e. a List). Of course returning a 'List' will satisfy your method declaration of returning a IList because List implements IList.
Generally best practice is to accept parameters of the most generic type and to return the most specific. However, conventionally programmers tend to not want to tie themselves to the List implementation and normally return the IList interface. You could be returning an IEnumerable if you don't want callers to modify the array (call the .AsReadOnly() extension method on your IList).
If you are exposing your class through a library that others will use, you generally want to expose it via interfaces rather than concrete implementations. This will help if you decide to change the implementation of your class later to use a different concrete class. In that case the users of your library won't need to update their code since the interface doesn't change.
If you are just using it internally, you may not care so much, and using List may be ok.
Read the solution of this question: Why is it considered bad to expose List<T>?
It separates the interface from the implementation. It is not important for the caller how you implement the result object, so using interfaces reduces coupling. If you return IList, you can switch to a different implementation at any time without breaking the caller's code.
Returning the interface allows you to change your implementation later and thus reduces coupling.
However when RETURNING an object this usually is of little practical concern. This is much more relevant when accepting objects (e.g. as function parameter).
If you return as just List. then the caller of your function has to put the return into an instance of class List.
When you return an IList the caller can put it into an instance of anything that implements that interface. Suppose the caller has made an implementation that supports some kind of funky sorting, or maybe they have made an implementation that directly maps the list to a database table.
It's about freedom for the receiver to implement Lists.
