In this post, I shall show you a small good practice that I follow and even many books suggest it while designing our generic methods which we daily write.
So today, I was refactoring a code at my work place. 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 method, but there is a slight problem with their design with respect to extensibility. Upon further refactoring process, I happen to see similar method
DoSomeWorkOnMyCollection() implemented again somewhere else, but this time it was for handling
Regarding the 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 the conclusion that it is better to have a return type of method to most derived type as shown below:
public List<T> GetList()
return new List<T>();
In such a way, I do get flexibility in getting the return value to
IList<T> (more stronger) at the caller side. So it's all a matter of being flexible or choosy here.
Similarly, with respect to the second method accepting more derived parameter type, this method is tightly coupled to the
List<T> typed arguments. I won't 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 implement
interface, thus again making the code more flexible.
Thanks for reading!
P.S.: If you know of any better practice, please do let me know. Your valuable suggestions/comments/votes are appreciated.