Question

I have always thought it was “best practice” to be explicit in naming my collection variables. So, if I had a collection of Car objects, I would typically name a Car[] carArray and a List<Car> carList.

And then 99% of the time, I end up just doing something like…

foreach (Car car in carArray)
{
    ...
}

…and I’m thinking, I could have just called the array cars, and it wouldn’t have made any difference.

And now that we have IEnumberable<T>, I’m actually faced with the question of whether I might consider writing something like carIEnumerable? or carEnumerable. So far, the answer has been “no”.

My thinking here is that the type of collection often doesn’t matter, and when it does, is still doesn’t matter if the collection type is written into the variable name. I just had a case where I had to switch from an IEnumerable<Car> to a List<Car> because I needed “bracket access” to the items (e.g., carList[3]). In that case, the two collection types do not behave the same, but would naming the variable cars have been a problem here?

Not to add another layer of complexity to this question, what happens if I use var? E.g.,

var cars = GetCars();

I can certainly tell cars is some kind of collection. I can iterate it. If I’m using LINQ, I can use extension methods. More importantly, if I later change up the type of collection, there would be much less code to mess with. var would still be var and cars would still be cars. That seems very appealing to me, and I having trouble seeing much disadvantage.

So, just to make sure my question is clear: How do you name your collection variables and why? Is there a serious readability or clarity cost to just “pluralizing” the name of the item?

Answer 1

The problem with this kind of naming is that it concentrates too much on the actual implementation rather than the purpose of the property. Instead of CarArray, you could use OwnedCars, or whatever tells the user why that enumeration is there.

I think naming the loop variable “car” in a small foreach-loop is just fine.

If you write var cars = GetCars(), the compiler looks at the type on the right side of the assignment, in this case possibly IEnumerable<Car>, and gives cars that type. You can even see it in subsequent uses of the variable if you hover over it with your mouse.

If you change the type of a collection and don’t have to change your code because you are using var, think about the fact that those different types of collections probably have something in common that enables you to perform the same operations on them.
Probably it’s IEnumerable if you use them in foreach loops.

So you could just as well expose those collections as IEnumerable, so users of your class don’t depend too much on a certain implementation.