How to Use Tuple in PowerShell


In PowerShell, a tuple is an ordered, immutable sequence of elements of possibly different types. Tuples are commonly used to store multiple values in a single object.

In this blog post, we will walk you through how to use Tuple in PowerShell as well as the reasons to use Tuple and its downsides.


You can use Create static method from System.Tuple class to define a tuple in PowerShell. To access the element, you use item number such as Item1, Item2 and so on until the last element. The item number is one-based, so the first element must be Item1.

$t = [Tuple]::Create("John", "Doe")


Note that tuples are immutable, meaning you cannot modify their elements once they are created. If you need to modify the elements of a tuple, you will need to create a new tuple with the updated values.

You can store tuples in lists or other data structures just like any other object in PowerShell.

$list = New-Object 'Collections.Generic.List[Tuple[int,string]]'
$list.Add([Tuple]::Create(1, "John Doe"))
$list.Add([Tuple]::Create(2, "Rick Carlisle"))

$list | ForEach-Object {
    Write-Host "Employee $($_.Item1) is $($_.Item2)"

Why we should use Tuple instead of other data structures in PowerShell

Tuples are useful in PowerShell for several reasons:

Grouping values

Tuples allow you to group multiple values of different types into a single object. This can be useful when you need to pass multiple values around as a single unit, without having to create a custom class or struct.


Tuples are immutable, which means that once they are created, their values cannot be changed. This can be useful in scenarios where you want to ensure that the values of the tuple remain constant throughout your code.


Tuples are light-weight data structures that do not require a lot of memory. This makes them useful in scenarios where you need to store a lot of small, fixed-size objects.

The downsides of Tuple

While tuples are a useful data structure in many scenarios, they also have some downsides that you should be aware of:

Lack of readability

Because tuples are often defined with a generic type syntax that does not provide any context or meaning to the values stored within, they can sometimes be less readable than other data structures like classes or structs.

Limited functionality

Tuples are immutable and do not provide any methods or functionality beyond simple element access. This means that they may not be the best choice for more complex scenarios where you need to perform operations or calculations on the data stored within.

Type safety

While tuples can help you group multiple values of different types into a single object, they do not provide any type safety or compile-time checks to ensure that the values stored within are of the correct type.


Tuples can be a useful tool, but it’s important not to overuse them. In some cases, creating a custom class or struct may be a better choice, as it can provide more context and functionality beyond simple element access.


Overall, tuples can be a useful tool in many scenarios, but like any data structure, they have their limitations and trade-offs. It’s important to consider the specific requirements of your scenario when choosing which data structure to use.