I want to create a List<Tuple<int,string>> in PowerShell, but

does not work. What am I missing?

Lee’s answer is the correct way to create a List of Tuples (although you can make the statement much shorter by omitting the System namespace). However, the better questions to ask in while programming in PowerShell are:

• Why should I return a strongly typed object?
• Do I really want to output a list?

The first one has its pros and cons. Strongly typed objects are useful to return if they have methods or events that will be useful for the next step in the pipeline. If, on the other hand, you just want to return a bunch of items with a name an int, I’d use something like:

This will create a property bag (what most devs know as a Tuple) containing the data you need, with more descriptive names than a .NET tuple will give you on the object. It’s also pretty fast. If, on the other hand, the data is meant for an API, then by all means created the strongly typed object it expects.

The second question is a little bit harder to understand but has a much clearer answer. In many cases, you’ll want to accept input for another function from the output of one function. In this, for many reasons, a strongly typed list is not your best friend. Strongly typed lists do not always clearly convert into arrays (this is especially true for generics), and, as arguments to a function, severely limit the different types of data you can put into the function. They also end up providing a little bit of a misleading and harder to use output (especially when piping in objects and producing multiple results), since the whole list will be displayed as one outputted item, instead of displaying each item on its own. Most annoyingly, strongly typed lists behave differently than arrays in PowerShell when you “over-index” (i.e. ask for item 10000 in a list of 5 items) Arrays will quietly return null. Lists will barf loudly. More practically, accumulating items into a list and then outputting the list will “hold” the pipeline until all items are in. This may be what you want, but in most cases it’s nice to see output coming out of a function as it runs. Finally, lists add to the memory overhead of the function, as you need to accumulate a set of objects in the function’s stack.

What I generally do is simply emit multiple objects. That is, I avoid using the return keyword and I take advantage of PowerShell’s ability to return objects that are not captured into a variable. If I assign the result into a variable, the items will be accumulated within an arraylist and returned to you as an array. This quick little demonstration function shows you how.

It’s worth noting that specialized collections are still quite useful. I very often use Queues and Stacks when the need arises. However, I very rarely find myself using generics or lists unless I am working with a part of .NET that specifically requires generics or lists. This is pretty personally ironic, since I was the person who tested support for generics in PowerShell V2. It’s absolutely required when you want to work with a piece of .NET that can only take a list of tuples. It’s slightly to severely counterproductive in all other cases.