Powershell array's ForEach doesn't return a System.array?

Question

I noticed that when running ForEach on an array object and capturing the output to a new variable, the new variable is not of type System.array:

PS D:\Playground> $Arr = 1, 2, 3
PS D:\Playground> $Arr2 = $Arr.ForEach({$_})
PS D:\Playground> $Arr2.Gettype()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Collection`1                             System.Object

Rather, it is of type Collection'1.

What is this type? Is it equivalent to an array?

BTW, this is not the same as with ForEach-Object:

PS D:\Playground> $Arr3 = $($Arr | ForEach-Object { $_ })
PS D:\Playground> $Arr3.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

I started writing an answer but stopped again, because I'm not really sure what a satisfying answer would look like. When you ask "What is this type?", what exactly are you hoping to learn? It's namespace? Finding the documentation? — Mathias R. Jessen
– Mathias R. Jessen, Commented Dec 30, 2021 at 15:19
This uses the "magic" ForEach method that returns a Collection<PSObject> (which is a very weird type to use, since it's intended as a base class -- but since it's not abstract, it is indeed possible to use it directly). No, this is not equivalent to an array, but because PowerShell mostly only cares if things are enumerable (not what the exact type is) and since Collection is indexable just like an array, that doesn't usually matter much. — Jeroen Mostert
– Jeroen Mostert, Commented Dec 30, 2021 at 15:20
$i = { 'asd' }.Invoke() => $i.GetType() => Collection`1 => $i[0].GetType() => string — Santiago Squarzon
– Santiago Squarzon, Commented Dec 30, 2021 at 15:23

mklement0 · Accepted Answer · 2022-03-11 00:29:39Z

6

Let me build on Jeroen Mostert's excellent comment:

The .ForEach() array method, and its sister method, .Where(), return [System.Collections.ObjectModel.Collection[psobject]] collection instances rather than regular PowerShell arrays ([object[]]).
- Unlike the related ForEach-Object / Where-Object cmdlets, these methods always return a collection, even with only a single object:
```
# .ForEach() method:
# Collection result even with single object.
@(1).ForEach({ $_ }).GetType().Name # -> Collection`1

# ForEach-Object cmdlet:
# Single output object: received as-is.
(@(1) | ForEach { $_ }).GetType().Name # -> Int32
# Two or more output objects: array result (if captured / used in expression)
(1, 2 | ForEach { $_ }).GetType().Name # -> Object[]
```
- Note: These methods are examples of intrinsic members, i.e. properties and methods PowerShell exposes on all objects, irrespective of their type (unless a type-native member of the same name exists, which takes precedence).
In essence, this collection type behaves like an array in PowerShell (due to implementing the [System.Collections.Generic.IList[psobject]] interface):
- Its elements are enumerated in the pipeline, just as an array's elements are.
- Positional indexing (e.g. [0]) is supported, just as with arrays.
- Unlike an array, however:
  - It is resizable; that is, its instances allow you to add (.Add()) and remove (.Remove()) elements.
  - Its element type is [psobject] (not [object]), the usually invisible helper type capable of wrapping any .NET object, which PowerShell employs (largely) behind the scenes.
    - Typically, this difference won't matter, but - unfortunately - there are edge cases where it does - see GitHub issue #5579.

The .ForEach() method vs. the ForEach-Object cmdlet:

Note: The following applies analogously to .Where() vs. Where-Object.

Use ForEach-Object on command output, in order to benefit from the streaming behavior of the PowerShell pipeline (one-by-one processing, as input is being received, no need for up-front collection of input); e.g.:
```
Get-ChildItem -Name *.txt| ForEach-Object { "[$_]" }
```
Use .ForEach() on arrays (collections) that are already are / can be collected in memory as a whole first, if faster processing is called for; e.g.:
```
('foo.txt', 'bar.txt').ForEach({ "[$_]" })
```

Beware of the differences in single-object behavior and output-collection type discussed above, however.

See this answer for a detailed juxtaposition of .ForEach(), ForEach-Object, the foreach statement, as well as member-access enumeration.

edited Mar 11, 2022 at 0:29

answered Dec 30, 2021 at 18:46

mklement0

452k68 gold badges727 silver badges986 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Santiago Squarzon Over a year ago

I learnt the foreach method can be used on any object just a few days ago, also didn't know .foreach({ begin {...} process {...} end {...} }) was possible. Another reason to not use ForEach-Object ever again lol

mklement0 Over a year ago

@Santiago, and I didn't know that something like (1, 2).foreach({ begin { 0 } process { "[$_]" } end { 3 } }) works - thanks! Note that for streaming (memory-throttling) processing you'll still need ForEach-Object. Also, ForEach-Object and Where-Object could be much less of an execution-speed concern if they were implemented efficiently - see GitHub feature request #10982.

Collectives™ on Stack Overflow

Powershell array's ForEach doesn't return a System.array?

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related