When using the $array.Add()-method, you're trying to add the element into the existing array. An array is a collection of fixed size, so you will receive an error because it can't be extended.

$array += $element creates a new array with the same elements as old one + the new item, and this new larger array replaces the old one in the $array-variable

You can use the += operator to add an element to an array. When you use it, Windows PowerShell actually creates a new array with the values of the original array and the added value. For example, to add an element with a value of 200 to the array in the $a variable, type:

Copy    $a += 200

Source: about_Arrays

+= is an expensive operation, so when you need to add many items you should try to add them in as few operations as possible, ex:

Copy$arr = 1..3    #Array
$arr += (4..5) #Combine with another array in a single write-operation

$arr.Count
5

If that's not possible, consider using a more efficient collection like List or ArrayList (see the other answer).

It is important to note that what you are doing is creating a new object, $stuff, with 2 properties: data1 and data2.

What you are showing in your example output is actually what you would be getting from a collection of objects. So, first we will create a collection object. For simplicity's sake, we will just make a standard empty array object to hold the objects in the collection:

$collection = @()

Now, we will add the items one at a time into the collection:

$collection += new-object psobject -property @{data1="foo1";data2="bar1"}
$collection += new-object psobject -property @{data1="foo2";data2="bar2"}
$collection += new-object psobject -property @{data1="foo3";data2="foo3"}

Showing the contents of collection will give us:

$collection
data2           data1
-----            -----
bar1            foo1
bar2            foo2
bar3            foo3

There are ways to make this faster, for instance create the collection as an arraylist and use the .add() method to add objects into the collection: [edit for clarity: By 'faster', I mean in instances where you are working with a large amount of data, not necessarily faster to create the script. For most uses that I'm aware of / have tried, the standard empty array @() will work just fine.]

$collection = new-object system.collections.arraylist
$collection.add(new-object psobject -property @{data1="foo";data2="bar"})

The only downside to using an arraylist is that the .add() method returns the current index that the item is being added at, so adding 5 objects into the collection would show the following in the console:

0
1
2
3
4

To circumvent this, pipe the $collection.add() method to out-null, so that it eats the output:

$collection.add(new-object pscustomobject -property @{data1="foo";data2="bar"}) | out-null

Hope this helps!

The problem is that you're updating the very same object, $Table, over and over, and adding references to that same object to the output array, $ToWrite - all of whose elements therefore end up pointing to the one and only $Table object, whose property values at that point contain the ones that were assigned in the last iteration.

The problem is explained in detail in this answer, which shows a possible solution using custom classes, available in PowerShell v5 and above.

A solution without custom classes requires you to clone your custom $Table object in each iteration:

# Create a new instance with the same properties:
$Table = $Table.psobject.Copy()

Note: This cloning technique only works as expected with custom objects, i.e., instances of [System.Management.Automation.PSCustomObject], such as created by the Select-Object cmdlet and literal syntax [pscustomobject] @{ ... }

That said, since you're assigning to all properties of your custom object in your loop, there is no benefit to creating a template object up front - instead, simply use literal custom-object creation syntax [pscustomobject] @{ ... } (PSv3+) inside your loop, which implicitly creates a new instance in every iteration.

Additionally, your solution can be streamlined, because it is both simpler and more efficient to let PowerShell create arrays for you, simply by collecting the output from commands that output multiple objects in a variable.

Here's a simplified example that puts it all together:

# Loop over the input and instantiate a new custom object
# in each iteration, then let PowerShell collect the results
# in array variable $ToWrite
[array] $ToWrite = 1..3 | ForEach-Object {
  # Instantiate and output a new custom object in each iteration.
  [pscustomobject] @{
    PropA = "ValueA-$_"
    PropB = "ValueB-$_"
  }
}

# Output the resulting array
$ToWrite

^{Note: The [array] type constraint is only needed if you need to ensure that $ToWrite is always an array; without it, if there happened to be just a single loop iteration and therefore output object, $ToWrite would store that output object as-is, not wrapped in an array (this behavior is fundamental to PowerShell's pipeline).}

The above yields the following, showing that distinct objects were created:

PropA    PropB
-----    -----
ValueA-1 ValueB-1
ValueA-2 ValueB-2
ValueA-3 ValueB-3