In this post, I shall show you a small good practice that I follow and even many books suggests while designing our generic methods which we daily write.
So today I was refactoring a code at my work place and due to privacy rules I will not post the exact code but similar kind below:
public IList<T> GetList<T>()
IList<T> IMyList = new List<T>();
public void DoSomeWorkOnMyCollection<T>(List<T>myList)
For sure there is no flaw in this methods, but there is a slight problem with their design w.r.t extensibility. Upon further refactoring process I happen to see similar method DoSomeWorkOnMyCollection() implemented again somewhere else but this time it was for handling
W.r.t to first method i.e
GetList<T>() the return type is more generic or more base type, which at the caller side i might have some problem.
So upon reading some books and blog i came to a conclusion that its better to have a return type of method to most derived type as shown below:
public List<T> GetList()
return new List<T>();
Such a way I do get flexibility in getting the return value to
IList<T> (more stronger) at the caller side. So its all matter of being flexible or choosy here.
Similarly w.r.t to the second method accepting more derived parameter type, this method is tightly coupled to the
List<T> typed arguments, i wont be able to pass arrays or other types at all to this method, such way forcing me to write other methods or overloaded methods. So to have more of a generic code, i can go for:
public void DoSomeWorkOnMyCollection<T>(IList<T> myList)
Now I can pass Arrays, other types which implements
IList<T> interface, thus again making the code more flexible.
P.S: Any better practice, do let me know. Your valuable suggestions/comments/votes are appreciated