Powershell Define Powershell Objects

I like to define my variables in a structured way. Most MSDN blogs don't do this, however.

For example: [object] myObj = ...

Is this the correct default format for all objects in Powershell?


source to share

6 answers

Use PsObject

like this:

$o = new-Object PsObject -property @{Name='donald'; Kind='duck' }


You are passing a hash table as an argument to a parameter -property

. Alternatively, you can create an empty object and add properties later:

$o = New-Object PsObject
$o | Add-Member NoteProperty project myproj.csproj
$o | Add-Member NoteProperty Success $true


Of course, you can use the pipe in Add-Member

$o = New-Object PsObject
# ...
$o | 
   Add-Member NoteProperty project myproj.csproj -pass |
   Add-Member NoteProperty Success $true




If I understand the question, you are asking a couple of things:

  • Can you specify the type of the variable explicitly?
  • What type does Powershell use if you don't specify it yourself?

Powershell will certainly let you specify the type explicitly, but it will infer the types as well. Please note, since all types inherit from System.Object

, explicitly specifying [object]

in the combined statement / assignment does not matter which I can see. The type system will still infer the corresponding child type. For example:

$x = 3
$x.GetType() # Returns 'Int32'

Remove-Variable x
[object] $x = 3
$x.GetType() # Returns 'Int32'

Remove-Variable x
[valuetype] $x = 3
$x.GetType() # Returns 'Int32'

Remove-Variable x
[int] $x = 3
$x.GetType() # Returns 'Int32'


If you separate declaration and assignment, you can create a variable like Object


Remove-Variable x
$x = new-object -TypeName Object
$x.GetType() # Returns 'Object'


... but as soon as you assign a value, the variable gets the new output type anyway:

$x = 3
$x.GetType() # Returns 'Int32'


While the type system happily deduces Int32

when you specify Object

, explicit types will win when the intended type is incompatible. For example:

$x = 3          # Gets inferred type 'Int32'
[string] $x = 3 # Gets explicit type 'String'

$x = 'x'        # Gets inferred type 'String'
[char] $x = 'x' # Gets explicit type 'Char'


If your question is more focused on defining and using custom object types, Stej's answer is excellent.



Since Powershell 3 can also parse HashTables for Custom Objects such as:

[PSObject] $Piza = [PSCustomObject] @{
    Ingredients = 4


Or if you like to define more detailed types in your object you can use the -AsCustomObject Parameter from New-Module

[PSObject] $Piza = New-Module -AsCustomObject -ScriptBlock {
    [Guid]$id = [Guid]::NewGuid()
    [String] $Name = 'Macaroni' 

    Function TestFunction() {}

    # Dont forget to export your members and functions 
    # as this is built up as a module and stuffed into 
    # an object later
    Export-ModuleMember -Function * -Variable *


As there are no things like classes in chic, you can add custom class names and namespaces for your object which you can request later (pseudo-instance;)

$Piza.PSObject.TypeNames.Insert(0, 'Pizas.Macaroni')




If I understand your question correctly, you are asking

  • How can I create a custom object in powershell?

In powershell, it can instantiate a .Net object using New Object . Like this

$ie = New-Object -ComObject InternetExplorer.Application
$ie.Visible = $true


The above code creates a com object which moves your ie to stackoverflow.

And, if you want to create your own object, PSObject will be your choice. Like below

$obj = New-Object PSObject -Property @{
    Name = "Your Name"
    Age = 30


When you call an object using "$ obj"

Age Name
--- ----
30 Your Name


If you are using powershell 3.0 you can get the same result with less typing as shown below

[PSCustomObject] @{
    Name = "Your Name"
    Age = 30




The PSObject creation is the basis for accessing all objects from the scripting language and provides an abstraction for the cmdlet developer and

It differs in a different version of powershell.

New PSObject -Property [HashTable]

     $Object = New-Object PSObject`                                       
     $Object | add-member Noteproperty LineNumber       $LineNumber                 
     $Object | add-member Noteproperty Date             $TodayDate       




You can also create swift objects:

$ myVar = "" | select column1, column2, column3

this will create an object with 3 NoteProperties and you have access to each property at a normal level like

$ myVar.column1

PS please note that this is Selecte.System.String not System.Management.Automation.PSCustomObject.

Still enough for storing rows of data, exporting, accessing data cells.

Update. A more flexible solution and still easy to implement would be a Hashtable created as shown below.

$ myVar2 = @ {

column1 = value1

column2 = value2

Column3 = value3


This will create a variable of type System.Collections.Hashtable

with some good methods

Regards hermitagup



All Articles