Chapter 6. Working with Objects

by Mar 14, 2012

In this chapter, you will learn what objects are and how to get your hands on PowerShell objects before they get converted to simple text.

Topics Covered:

Objects = Properties + Methods

In real life, you already know what an object is: everything you can touch. Objects in PowerShell are similar. Let's turn a typical real-world object, like a pocketknife, into a PowerShell object.

How would you describe this object to someone, over the telephone? You would probably carefully examine the object and then describe what it is and what it can do:

  • Properties: A pocketknife has particular properties, such as its color, manufacturer, size, or number of blades. The object is red, weights 55 grams, has three blades, and is made by the firm Idera. So properties< describe what an object is.
  • Methods: n addition, you can do things with this object, such as cut, turn screws, or pull corks out of wine bottles. The object can cut, screw, and remove corks. Everything that an object can is called its methods.

In the computing world, an object is very similar: its nature is described by properties, and the actions it can perform are called its methods. Properties and methods are called members.

Creating a New Object

Let's turn our real-life pocketknife into a virtual pocketknife. Using New-Object, PowerShell can generate new objects, even a virtual pocketknife. First, you will need a new and empty object:

$pocketknife = New-Object Object

This new object is actually pretty useless. If you call for it, PowerShell will return "nothing":


Adding Properties

Next, let's start describing what our object is. To do that, you can add properties to the object.

# Adding a new property:
Add-Member -MemberType NoteProperty -Name Color-Value Red -InputObject $pocketknife

You can uUse the Add-Member cmdlet to add properties. Here, you added the property color with the value red to the object $pocketknife. If you call for the object now, it suddenly has a property telling the world that its color is red:


You can then add more properties to describe the object even better. This time, we use positional parameters to shorten the code necessary to add members to the object:

$pocketknife | Add-Member NoteProperty Weight 55
$pocketknife | Add-Member NoteProperty Manufacturer Idera
$pocketknife | Add-Member NoteProperty Blades 3

By now, you've described the object in $pocketknife with a total of four properties. If you output the object in $pocketknife in the PowerShell console, PowerShell will automatically convert the object into readable text:

# Show all properties of the object all at once:
Color                                    Weight   Manufacturer                      Blades
-----                                    -------  ----------                        -------
Red                                          55   Idera                                   3

You will now get a quick overview of its properties when you output the object to the console. You can access the value of a specific property by either using Select-Object with the parameter -expandProperty, or add a dot, and then the property name:

# Display a particular property:
$pocketknife | Select-Object -expandProperty Manufacturer

Adding Methods

With every new property you added to your object, $pocketknife has been gradually taking shape, but it still really can't do anything. Properties only describe what an object is, not what it can do.

The actions your object can do are called its methods. So let's teach your object a few useful methods:

# Adding new methods:
$pocketknife | Add-Member ScriptMethod cut { "I'm whittling now" }
$pocketknife | Add-Member ScriptMethod screw { "'s in!" }

$pocketknife | Add-Member ScriptMethod corkscrew { "Pop! Cheers!" }

Again, you used the Add-Member cmdlet, but this time you added a method instead of a property (in this case, a ScriptMethod). The value is a scriptblock marked by brackets, which contains the PowerShell instructions you want the method to perform. If you output your object, it will still look the same because PowerShell only visualizes object properties, not methods:

Color                                      Weight Manufacturer                          Blades
-----                                     ------- ----------                           -------
Red                                            55 Idera                                 3

You can add a dot and then the method name followed by two parentheses to use any of the three newly added methods. They are part of the method name, so be sure to not put a space between the method name and the opening parenthesis. Parentheses formally distinguishes properties from methods.

For example, if you'd like to remove a cork with your virtual pocketknife, you can use this code:

Pop! Cheers!

Your object really does carry out the exact script commands you assigned to the corkscrew() method. So, methods perform actions, while properties merely provide information. Always remember to add parentheses to method names. If you forget them, something interesting like this will happen:

# If you don't use parentheses, you'll retrieve information on a method:
Script              : "Pop! Cheers!"
OverloadDefinitions : {System.Object corkscrew()}
MemberType          : ScriptMethod
TypeNameOfValue     : System.Object
Value               : System.Object corkscrew()
Name                : corkscrew
IsInstance          : True

You just received a method description. What's interesting about this is mainly the OverloadDefinitions property. As you'll see later, it reveals the exact way to use a command for any method. In fact, the OverloadDefinitions information is in an additional object. For PowerShell, absolutely everything is an object so you can store the object in a variable and then specifically ask the OverloadDefinitions property for information:

# Information about a method is returned in an object of its own:
$info = $pocketknife.corkscrew
System.Object corkscrew()

The "virtual pocketknife" example reveals that objects are containers that contain data (properties) and actions (methods).

Our virtual pocketknife was a somewhat artificial object with no real use. Next, let's take a look at a more interesting object: PowerShell! There is a variable called $host which represents your PowerShell host.

Properties: What an Object "Is"

There are just two important rules: Properties describe an object. And object properties are automatically turned into text when you output the object to the console. That's enough to investigate any object. Check out the properties in $host!

Name             : ConsoleHost
Version          :
InstanceId       : e32debaf-3d10-4c4c-9bc6-ea58f8f17a8f
UI               : System.Management.Automation.Internal.Host.InternalHostUserInterface
CurrentCulture   : en-US
CurrentUICulture : en-US
PrivateData      : Microsoft.PowerShell.ConsoleHost+ConsoleColorProxy

The object stored in the variable $host apparently contains seven properties. The properties’ names are listed in the first column. So, if you want to find out which PowerShell version you're using, you could access and return the Version property:

Major  Minor  Build  Revision
-----  -----  -----  --------
1      0      0      0

It works—you get back the PowerShell host version. The version isn't displayed as a single number. Instead, PowerShell displays four columns: Major, Minor, Build, and Revision. Whenever you see columns, you know these are object properties that PowerShell has just converted into text. So, the version in itself is again a special object designed to store version numbers. Let's check out the data type that the Version property uses:

$version = $Host.Version

The version is not stored as a String object but as a System.Version object. This object type is perfect for storing versions, allowing you to easily read all details about any given version:


Knowing an object type is very useful because once you know there is a type called System.Version, you can use it for your own purposes as well. Try to convert a simple string of your choice into a rich version object! To do that, simply make sure the string consists of four numbers separated by dots (the typical format for versions), then make PowerShell convert the string into a System.Version type. You can convert things by adding the target type in square brackets in front of the string:

Major  Minor  Build  Revision
-----  -----  -----  --------
12     55     3      28334

The CurrentCulture property is just another example of the same concept. Read this property to find out its type:

LCID             Name             DisplayName
----             ----             -----------
1033             en-US            English (United States)


Country properties are again stored in a highly specialized type that describes a culture with the properties LCID, Name, and DisplayName. If you want to know which international version of PowerShell you are using, you can read the DisplayName property:

English (United States)

Likewise, you can convert any suitable string into a CultureInfo-object. Try this if you wanted to find out details about the 'de-DE' locale:

LCID             Name             DisplayName
----             ----             -----------
1031             de-DE            German (Germany)

You can also convert the LCID into a CultureInfo object by converting a suitable number:

LCID             Name             DisplayName
----             ----             -----------
1033             en-US            English (United States)

Properties Containing Objects

The properties of an object store data. In turn, this data is stored in various other objects.Two properties in $host seem to be special: UI and PrivateData. When you output $host into the console, all other properties will be converted into readable text – except for the properties UI and PrivateData:

Name             : ConsoleHost
Version          :
InstanceId       : e32debaf-3d10-4c4c-9bc6-ea58f8f17a8f
UI               : System.Management.Automation.Internal.Host.InternalHostUserInterface
CurrentCulture   : en-US
CurrentUICulture : en-US
PrivateData      : Microsoft.PowerShell.ConsoleHost+ConsoleColorProxy

This is because both these properties again contain an object. If you'd like to find out what is actually stored in the UI property, you can read the property:


You see that the property UI contains only a single property called RawUI, in which yet another object is stored. Let's see what sort of object is stored in the RawUI property:

ForegroundColor       : DarkYellow
BackgroundColor       : DarkMagenta
CursorPosition        : 0,136
WindowPosition        : 0,87
CursorSize            : 25
BufferSize            : 120,3000
WindowSize            : 120,50
MaxWindowSize         : 120,62
MaxPhysicalWindowSize : 140,62
KeyAvailable          : False
WindowTitle           : PowerShell

"RawUI" stands for "Raw User Interface" and exposes the raw user interface settings your PowerShell console uses. You can read all of these properties, but can you also change them?

Read-Only and Read-Write Properties

Can you actually change properties, too? And if you can, what happens next?

Properties need to accurately describe an object. So, if you modify a property, the underlying object has to also be modified to reflect that change. If this is not possible, the property cannot be changed and is called "read-only."

Console background and foreground colors are a great example of properties you can easily change. If you do, the console will change colors accordingly. Your property changes are reflected by the object, and the changed properties still accurately describe the object.

$Host.ui.rawui.BackgroundColor = "Green"
$Host.ui.rawui.ForegroundColor = "White"

Type cls so the entire console adopts this color scheme.

Other properties cannot be changed. If you try anyway, you'll get an error message:

$Host.ui.rawui.keyavailable = $true
"KeyAvailable" is a ReadOnly-property.
At line:1 char:16
+ $Host.ui.rawui.k <<<< eyavailable = $true

Whether the console receives key press input or not, depends on whether you pressed a key or not. You cannot control that by changing a property, so this property refuses to be changed. You can only read it.

Property Description
ForegroundColor Text color. Optional values are Black, DarkBlue, DarkGreen, DarkCyan, DarkRed, DarkMagenta, DarkYellow, Gray, DarkGray, Blue, Green, Cyan, Red, Magenta, Yellow, and White.
BackgroundColor Background color. Optional values are Black, DarkBlue, DarkGreen, DarkCyan, DarkRed, DarkMagenta, DarkYellow, Gray, DarkGray, Blue, Green, Cyan, Red, Magenta, Yellow, and White.
CursorPosition Current position of the cursor
WindowPosition Current position of the window
CursorSize Size of the cursor
BufferSize Size of the screen buffer
WindowSize Size of the visible window
MaxWindowSize Maximally permissible window size
MaxPhysicalWindowSize Maximum possible window size
KeyAvailable Makes key press input available
WindowTitle Text in the window title bar

Table 6.1: Properties of the RawUI object

Property Types

Some properties accept numeric values. For example, the size of a blinking cursor is specified as a number from 0 to 100 and corresponds to the fill percentage. The next line sets a cursor size of 75%. Values outside the 0-100 numeric range will generate an error:

# A value from 0 to 100 is permitted:
$Host.ui.rawui.cursorsize = 75

# Values outside this range will generate an error:
$Host.ui.rawui.cursorsize = 1000
Exception setting "CursorSize": "Cannot process "CursorSize" because the cursor 
size specified is invalid.
Parameter name: value Actual value was 1000." At line:1 char:16 + $Host.ui.rawui.c <<<< ursorsize = 1000

Other properties expect color settings. However, you cannot specify any color that comes to mind. Instead, PowerShell expects a "valid" color and if your color is unknown, you will receive an error message listing the colors you can use:

# Colors are specified as text (in quotation marks):
$Host.ui.rawui.ForegroundColor = "yellow"

# Not all colors are allowed:
$Host.ui.rawui.ForegroundColor = "pink"
Exception setting "ForegroundColor": "Cannot convert value "pink" to type 
System.ConsoleColor" due to invalid enumeration values. Specify one of the
following enumeration values and try again. The possible enumeration values are
Black, DarkBlue, DarkGreen, DarkCyan, DarkRed, DarkMagenta, DarkYellow, Gray,
DarkGray, Blue, Green, Cyan, Red, Magenta, Yellow, White"." At line:1 char:16 + $Host.ui.rawui.F <<<< oregroundColor = "pink"

If you assign an invalid value to the property ForegroundColor, the error message will list the possible values. If you assign an invalid value to the property CursorSize, you get no hint. Why?

Every property expects a certain object type. Some object types are more specific than others. You can use Get-Member to find out which object types a given property will expect:

$Host.ui.RawUI | Get-Member -MemberType Property
   TypeName: System.Management.Automation.Internal.Host.InternalHostRawUserInterface

Name                  MemberType Definition
----                  ---------- ----------
BackgroundColor       Property   System.ConsoleColor BackgroundColor {get;set;}
BufferSize            Property   System.Management.Automation.Host.Size BufferSize {get;set;}
CursorPosition        Property   System.Management.Automation.Host.Coordinates CursorPosition {get;set;}
CursorSize            Property   System.Int32 CursorSize {get;set;}
ForegroundColor       Property   System.ConsoleColor ForegroundColor {get;set;}
KeyAvailable          Property   System.Boolean KeyAvailable {get;}
MaxPhysicalWindowSize Property   System.Management.Automation.Host.Size MaxPhysicalWindowSize {get;}
MaxWindowSize         Property   System.Management.Automation.Host.Size MaxWindowSize {get;}
WindowPosition        Property   System.Management.Automation.Host.Coordinates WindowPosition {get;set;}
WindowSize            Property   System.Management.Automation.Host.Size WindowSize {get;set;}
WindowTitle           Property   System.String WindowTitle {get;set;}

As you can see, ForegroundColor expects a System.ConsoleColor type. This type is a highly specialized type: a list of possible values, a so-called enumeration:


Whenever a type is an enumeration, you can use a special .NET method called GetNames() to list the possible values defined in that enumeration:


If you do not specify anything contained in the enumeration, the error message will simply return the enumeration’s contents.

CursorSize stores its data in a System.Int32 object, which is simply a 32-bit number. So, if you try to set the cursor size to 1,000, you are actually not violating the object boundaries because the value of 1,000 can be stored in a System.Int32 object. You get an error message anyway because of the validation code that the CursorSize property executes internally. So, whether you get detailed error information will really depend on the property’s definition. In the case of CursorSize, you will receive only an indication that your value is invalid, but not why.

Sometimes, a property expects a value to be wrapped in a specific object. For example, if you'd like to change the PowerShell window size, you can use the WindowSize property. As it turns out, the property expects a new window size wrapped in an object of type System.Management.Automation.Host.Size. Where can you get an object like that?

$Host.ui.rawui.WindowSize = 100,100
Exception setting "WindowSize": "Cannot convert "System.Object[]" 
to "
System.Management.Automation.Host.Size"." At line:1 char:16 + $Host.ui.rawui.W <<<< indowSize = 100,100

There are a number of ways to provide specialized objects for properties. The easiest approach: read the existing value of a property (which will get you the object type you need), change the result, and then write back the changes. For example, here's how you would change the PowerShell window size to 80 x 30 characters:

$value = $Host.ui.rawui.WindowSize
                                      Width                                      Height
                                      -----                                      ------
                                        110                                          64
$value.Width = 80
$value.Height = 30
$Host.ui.rawui.WindowSize = $value

Or, you can freshly create the object you need by using New-Object:

$value = New-Object System.Management.Automation.Host.Size(80,30)
$Host.ui.rawui.WindowSize = $value

Or in a line:

$host.ui.rawui.WindowSize = New-Object System.Management.Automation.Host.Size(80,30)

Listing All Properties

Get-Member will return detailed information about them because properties and methods are all members of an object. Let's use Get-Member to examine all properties defined in $host. To limit Get-Member to only properties, you can use the memberType parameter and specify "property":

$Host | Get-Member -memberType property
Name             MemberType Definition
----             ---------- ----------
CurrentCulture   Property   System.Globalization.CultureInfo CurrentCulture {get;}
CurrentUICulture Property   System.Globalization.CultureInfo CurrentUICulture {get;}
InstanceId       Property   System.Guid InstanceId {get;}
Name             Property   System.String Name {get;}
PrivateData      Property   System.Management.Automation.PSObject PrivateData {get;}
UI               Property   System.Management.Automation.Host.PSHostUserInterface UI {get;}
Version          Property   System.Version Version {get;}

In the column Name, you will now see all supported properties in $host. In the column Definition, the property object type is listed first. For example, you can see that the Name property stores a text as System.String type. The Version property uses the System.Version type.

At the end of each definition, curly brackets will report whether the property is read-only ({get;}) or can also be modified ({get;set;}). You can see at a glance that all properties of the $host object are only readable. Now, take a look at the $host.ui.rawui object:

$Host.ui.rawui | Get-Member -membertype property
BackgroundColor       Property   System.ConsoleColor BackgroundColor {get;set;}
BufferSize            Property   System.Management.Automation.Host.Size BufferSize {get;set;}
CursorPosition        Property   System.Management.Automation.Host.Coordinates CursorPosition {get;set;}
CursorSize            Property   System.Int32 CursorSize {get;set;}
ForegroundColor       Property   System.ConsoleColor ForegroundColor {get;set;}
KeyAvailable          Property   System.Boolean KeyAvailable {get;}
MaxPhysicalWindowSize Property   System.Management.Automation.Host.Size MaxPhysicalWindowSize {get;}
MaxWindowSize         Property   System.Management.Automation.Host.Size MaxWindowSize {get;}
WindowPosition        Property   System.Management.Automation.Host.Coordinates WindowPosition {get;set;}
WindowSize            Property   System.Management.Automation.Host.Size WindowSize {get;set;}
WindowTitle           Property   System.String WindowTitle {get;set;}

This result is more differentiated. It shows you that some properties could be changed, while others could not.

There are different "sorts" of properties. Most properties are of the Property type, but PowerShell can add additional properties like ScriptProperty. So if you really want to list all properties, you can use the -MemberType parameter and assign it a value of *Property. The wildcard in front of "property" will also select all specialized properties like "ScriptProperty."

Methods: What an Object "Can Do"

Methods are things that an object can do.Only its properties are converted into readable text when you output an object to the console. Methods remain invisible. You can use Get-Member and the parameter "memberType" with the value "method" to list the methods of an object:

$Host | Get-Member -memberType Method

   TypeName: System.Management.Automation.Internal.Host.InternalHost

Name                   MemberType Definition
----                   ---------- ----------
EnterNestedPrompt      Method     System.Void EnterNestedPrompt()
Equals                 Method     bool Equals(System.Object obj)
ExitNestedPrompt       Method     System.Void ExitNestedPrompt()
GetHashCode            Method     int GetHashCode()
GetType                Method     type GetType()
NotifyBeginApplication Method     System.Void NotifyBeginApplication()
NotifyEndApplication   Method     System.Void NotifyEndApplication()
PopRunspace            Method     System.Void PopRunspace()
PushRunspace           Method     System.Void PushRunspace(runspace runspace)
SetShouldExit          Method     System.Void SetShouldExit(int exitCode)
ToString               Method     string ToString()

Eliminating "Internal" Methods

Get-Member does not list all methods defined by an object. It will skip methods that are used internally. You can force Get-Member to list all methods by adding the -Force parameter:

PS > $Host | Get-Member -memberType Method -Force

   TypeName: System.Management.Automation.Internal.Host.InternalHost

Name                   MemberType Definition
----                   ---------- ----------
get_CurrentCulture     Method     System.Globalization.CultureInfo get_Curre...
get_CurrentUICulture   Method     System.Globalization.CultureInfo get_Curre...
get_InstanceId         Method     System.Guid get_InstanceId()
get_IsRunspacePushed   Method     bool get_IsRunspacePushed()
get_Name               Method     string get_Name()
get_PrivateData        Method     psobject get_PrivateData()
get_Runspace           Method     runspace get_Runspace()
get_UI                 Method     System.Management.Automation.Host.PSHostUs...
get_Version            Method     System.Version get_Version()

Get_ and Set_ Methods

Any method that starts with "get_" is really designed to retrieve a property value. So the method "get_someInfo()" will retrieve the very same information you could also have gotten with the "someInfo" property.

# Query property:

Major  Minor  Build  Revision
-----  -----  -----  --------
2      0      -1     -1

# Query property value using getter method:
Major  Minor  Build  Revision
-----  -----  -----  --------
2      0      -1     -1

The same is true for Set_ methods: they change a property value and exist for properties that are read/writeable. Note in this example: all properties of the $host object can only be read so there are no Set_ methods. There can be more internal methods like this, such as Add_ and Remove_ methods. Generally speaking, when a method name contains an underscore, it is most likely an internal method.

Standard Methods

In addition, nearly every object contains a number of "inherited" methods that are also not specific to the object but perform general tasks for every object:

Method Description
Equals Verifies whether the object is identical to a comparison object
GetHashCode Retrieves an object's digital "fingerprint"
GetType Retrieves the underlying object type
ToString Converts the object into readable text

Table 6.2: Standard methods of a .NET object

Calling a Method

Before you invoke a method: make sure you know what the method will do. Methods are commands that do something, which could be dangerous. You can add a dot to the object and then the method name to call a method. Add an opened and closed parenthesis, like this:


The PowerShell prompt changes to ">>" (unless you changed your default prompt function). You have used EnterNestedPrompt() to open a nested prompt. Nested prompts are not especially useful in a normal console, so be sure to exit it again using the exit command or call $host.ExitNestedPrompt().

Nested prompts can be useful in functions or scripts because they work like breakpoints. They can temporarily stop a function or script so you can verify variable contents or make code changes, after which you continue the code by entering exit. You'll learn more about this in Chapter 11.

Call Methods with Arguments

There are many useful methods in the UI object. Here's how you get a good overview:

$Host.ui | Get-Member -membertype Method
   TypeName: System.Management.Automation.Internal.Host.InternalHostUserInterface

Name                   MemberType Definition
----                   ---------- ----------
Equals                 Method     System.Boolean Equals(Object obj)
GetHashCode            Method     System.Int32 GetHashCode()
GetType                Method     System.Type GetType()
get_RawUI              Method     System.Management.Automation.Host.PSHostRawUserInterface get_RawUI()
Prompt                 Method     System.Collections.Generic.Dictionary`2[[System.String, mscorlib, Versio...
PromptForChoice        Method     System.Int32 PromptForChoice(String caption, String message, Collection`...
PromptForCredential    Method     System.Management.Automation.PSCredential PromptForCredential(String cap...
ReadLine               Method     System.String ReadLine()
ReadLineAsSecureString Method     System.Security.SecureString ReadLineAsSecureString()
ToString               Method     System.String ToString()
Write                  Method     System.Void Write(String value), System.Void Write(ConsoleColor foregrou...
WriteDebugLine         Method     System.Void WriteDebugLine(String message)
WriteErrorLine         Method     System.Void WriteErrorLine(String value)
WriteLine              Method     System.Void WriteLine(), System.Void WriteLine(String value), System.Voi...
WriteProgress          Method     System.Void WriteProgress(Int64 sourceId, ProgressRecord record)
WriteVerboseLine       Method     System.Void WriteVerboseLine(String message)
WriteWarningLine       Method     System.Void WriteWarningLine(String message)

Most methods require additional arguments from you, which are listed in the Definition column.

Which Arguments are Required?

Pick out a method from the list, and then ask Get-Member to get you more info. Let's pick WriteDebugLine():

# Ask for data on the WriteDebugLine method in $host.ui:
$info = $Host.UI | Get-Member WriteDebugLine

# $info contains all the data on this method:
   TypeName: System.Management.Automation.Internal.Host.InternalHostUserInterface
Name           MemberType Definition
----           ---------- ----------
WriteDebugLine Method     System.Void WriteDebugLine(String message)

# Definition shows which arguments are required and which result will be returned:
System.Void WriteDebugLine(String message)

The Definition property tells you how to call the method. Every definition will begin with the object type that a method returns. In this example, it is System.Void, a special object type because it represents "nothing": the method doesn't return anything at all. A method "returning" System.Void is really a procedure, not a function.

Next, a method’s name follows, which is then followed by required arguments. WriteDebugLine needs exactly one argument called message, which is of String type. Here is how you call WriteDebugLine():


Several Method "Signatures"

Some methods accept different argument types, or even different numbers of arguments. To find out which "signatures" a method supports, you can use Get-Member again and look at the Definition property:

$info = $Host.UI | Get-Member WriteLine
System.Void WriteLine(), System.Void WriteLine(String value), System.Void 
WriteLine(ConsoleColor foregroundColor, ConsoleColor backgroundColor, String value)

The definition is hard to read at first. You can make it more readable by using Replace() to add line breaks.

Remember the "backtick" character ("`"). It introduces special characters; "`n" stands for a line break.

$info.Definition.Replace("), ", ")`n")
System.Void WriteLine()
System.Void WriteLine(String value)
System.Void WriteLine(ConsoleColor foregroundColor, ConsoleColor backgroundColor, String value)

This definition tells you: You do not necessarily need to supply arguments:


The result is an empty line.

To output text, you can specify one argument only, the text itself:

$Host.ui.WriteLine("Hello world!")
Hello world!

The third variant adds support for foreground and background colors:

$host.ui.WriteLine("Red", "White", "Alarm!")

WriteLine() actually is the low-level function of the Write-Host cmdlet:

Write-Host "Hello World!"
Write-Host -ForegroundColor Red -BackgroundColor White Alarm!

Playing with PromptForChoice

So far, most methods you examined have turned out to be low-level commands for cmdlets. This is also true for the following methods: Write() (corresponds to Write-Host -nonewline) or ReadLine()/ReadLineAsSecureString() (read-host -asSecureString) or PromptForCredential() (get-credential).

A new functionality is exposed by the method PromptForChoice(). Let's first examine which arguments this method expects:

$info = $Host.UI | Get-Member PromptForChoice
System.Int32 PromptForChoice(String caption, String message, Collection`1 choices, 
Int32 defaultChoice)

You can get the same information if you call the method without parentheses:

You can get the same information if you call the method without parentheses:
MemberType          : Method
OverloadDefinitions : {System.Int32 PromptForChoice(String caption, String message, 
Collection`1 choices, Int 32 defaultChoice)} TypeNameOfValue : System.Management.Automation.PSMethod Value : System.Int32 PromptForChoice(String caption, String message,
Collection`1 choices, Int32 defaultChoice) Name : PromptForChoice IsInstance : True

The definition reveals that this method returns a numeric value (System.Int32). It requires a heading and a message respectively as text (String). The third argument is a bit strange: Collection`1 choices. The fourth argument is a number (Int32), the standard selection. You may have noticed by now the limitations of PowerShell's built-in description.

This is how you can use PromptForChoice() to create a simple menu:

$yes = ([System.Management.Automation.Host.ChoiceDescription]"&yes") 
$no = ([System.Management.Automation.Host.ChoiceDescription]"&no")
$selection = [System.Management.Automation.Host.ChoiceDescription[]]($yes,$no) 
$answer = $Host.ui.PromptForChoice('Reboot', 'May the system now be rebooted?',$selection,1) 
if ($selection -eq 0) {
} else {
  "OK, then not"

Working with Real-Life Objects

Every PowerShell command will return objects. However, it is not that easy to get your hands on objects because PowerShell converts them to text whenever you output them to the console.

Storing Results in Variables

Save the result to variable to examine the object nature of results you receive from cmdlets.

$listing = Dir $env:windir

When you dump the variable content to the console, the results stored inside of it will be converted to plain text, much like if you had output the information to the console in the first place:

    Directory: Microsoft.PowerShell.CoreFileSystem::C:UsersTobias Weltner
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        20.07.2007     11:37            Application data
d----        26.07.2007     11:03            Backup
d-r--        13.04.2007     15:05            Contacts
d----        28.06.2007     18:33            Debug

To get to the real objects, you can directly access them inside of a variable. Dir has stored its result in $listing. It is wrapped in an array since the listing consists of more than one entry. Access an array element to get your hands on a real object:

# Access first element in listing
$object = $listing[0]

# Object is converted into text when you output it in the console
    Directory: Microsoft.PowerShell.CoreFileSystem::C:UsersTobias Weltner
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        20.07.2007     11:37            Application data

The object picked here happens to match the folder Application Data; so it represents a directory. You can do this if you prefer to directly pick a particular directory or file:

# Address a particular file:
$object = Get-Item $env:windirexplorer.exe

# Address a folder:
$object = Get-Item $env:windir

Using Object Properties

You can use Get-Member again to produce a list of all available properties:

# $object is a fully functional object that describes the "Application Data" directory
# First, list all object properties:
$object | Get-Member -membertype *property
Name              MemberType     Definition
----              ----------     ----------
Mode              CodeProperty   System.String Mode{get=Mode;}
PSChildName       NoteProperty   System.String PSChildName=Windows
PSDrive           NoteProperty   System.Management.Automation.PSDriveInfo PS...
PSIsContainer     NoteProperty   System.Boolean PSIsContainer=True
PSParentPath      NoteProperty   System.String PSParentPath=Microsoft.PowerS...
PSPath            NoteProperty   System.String PSPath=Microsoft.PowerShell.C...
PSProvider        NoteProperty   System.Management.Automation.ProviderInfo P...
Attributes        Property       System.IO.FileAttributes Attributes {get;set;}
CreationTime      Property       System.DateTime CreationTime {get;set;}
CreationTimeUtc   Property       System.DateTime CreationTimeUtc {get;set;}
Exists            Property       System.Boolean Exists {get;}
Extension         Property       System.String Extension {get;}
FullName          Property       System.String FullName {get;}
LastAccessTime    Property       System.DateTime LastAccessTime {get;set;}
LastAccessTimeUtc Property       System.DateTime LastAccessTimeUtc {get;set;}
LastWriteTime     Property       System.DateTime LastWriteTime {get;set;}
LastWriteTimeUtc  Property       System.DateTime LastWriteTimeUtc {get;set;}
Name              Property       System.String Name {get;}
Parent            Property       System.IO.DirectoryInfo Parent {get;}
Root              Property       System.IO.DirectoryInfo Root {get;}
BaseName          ScriptProperty System.Object BaseName {get=$this.Name}

Properties marked with {get;set;} in the column Definition are readable and writeable. You can actually change their value, too, by simply assigning a new value (provided you have sufficient privileges):

# Determine last access date:
Friday, July 20, 2007 11:37:39

# Change Date:
$object.LastAccessTime = Get-Date

# Change was accepted:
Monday, October 1, 2007 15:31:41

PowerShell-Specific Properties

PowerShell can add additional properties to an object. Whenever that occurs, Get-Member will label the property accordingly in the MemberType column. Native properties are just called "Property." Properties that are added by PowerShell use a prefix, such as "ScriptProperty" or "NoteProperty."

A NoteProperty like PSChildName contains static data. PowerShell will add it to tag additional information to an object. A ScriptProperty like Mode executes PowerShell script code that calculates the property’s value.

MemberType Description
AliasProperty Alternative name for a property that already exists
CodeProperty Static .NET method returns property contents
Property Genuine property
NoteProperty Subsequently added property with set data value
ScriptProperty Subsequently added property whose value is calculated by a script
ParameterizedProperty Property requiring additional arguments

Table 6.3: Different property types

Using Object Methods

Use Get-Member to find out the methods that an object supports:

# List all methods of the object:
$object | Get-Member -membertype *method
   TypeName: System.IO.DirectoryInfo

Name                      MemberType Definition
----                      ---------- ----------
Create                    Method     System.Void Create(), System.Void Create(DirectorySecurity DirectoryS...
CreateObjRef              Method     System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType)
CreateSubDirectory        Method     System.IO.DirectoryInfo CreateSubDirectory(String path), System.IO.Di...
Delete                    Method     System.Void Delete(), System.Void Delete(Boolean recursive)
Equals                    Method     System.Boolean Equals(Object obj)
GetAccessControl          Method     System.Security.AccessControl.DirectorySecurity GetAccessControl(), S...
GetDirectories            Method     System.IO.DirectoryInfo[] GetDirectories(), System.IO.DirectoryInfo[]...
GetFiles                  Method     System.IO.FileInfo[] GetFiles(String searchPattern), System.IO.FileIn...
GetFileSystemInfos        Method     System.IO.FileSystemInfo[] GetFileSystemInfos(String searchPattern), ...
GetHashCode               Method     System.Int32 GetHashCode()
GetLifetimeService        Method     System.Object GetLifetimeService()
GetObjectData             Method     System.Void GetObjectData(SerializationInfo info, StreamingContext co...
GetType                   Method     System.Type GetType()
get_Attributes            Method     System.IO.FileAttributes get_Attributes()
get_CreationTime          Method     System.DateTime get_CreationTime()
get_CreationTimeUtc       Method     System.DateTime get_CreationTimeUtc()
get_Exists                Method     System.Boolean get_Exists()
get_Extension             Method     System.String get_Extension()
get_FullName              Method     System.String get_FullName()
get_LastAccessTime        Method     System.DateTime get_LastAccessTime()
get_LastAccessTimeUtc     Method     System.DateTime get_LastAccessTimeUtc()
get_LastWriteTime         Method     System.DateTime get_LastWriteTime()
get_LastWriteTimeUtc      Method     System.DateTime get_LastWriteTimeUtc()
get_Name                  Method     System.String get_Name()
get_Parent                Method     System.IO.DirectoryInfo get_Parent()
get_Root                  Method     System.IO.DirectoryInfo get_Root()
InitializeLifetimeService Method     System.Object InitializeLifetimeService()
MoveTo                    Method     System.Void MoveTo(String destDirName)
Refresh                   Method     System.Void Refresh()
SetAccessControl          Method     System.Void SetAccessControl(DirectorySecurity DirectorySecurity)
set_Attributes            Method     System.Void set_Attributes(FileAttributes value)
set_CreationTime          Method     System.Void set_CreationTime(DateTime value)
set_CreationTimeUtc       Method     System.Void set_CreationTimeUtc(DateTime value)
set_LastAccessTime        Method     System.Void set_LastAccessTime(DateTime value)
set_LastAccessTimeUtc     Method     System.Void set_LastAccessTimeUtc(DateTime value)
set_LastWriteTime         Method     System.Void set_LastWriteTime(DateTime value)
set_LastWriteTimeUtc      Method     System.Void set_LastWriteTimeUtc(DateTime value)
ToString                  Method     System.String ToString()

You can apply methods just like you did in the previous examples. For example, you can use the CreateSubDirectory method if you'd like to create a new sub-directory. First, you should find out which arguments this method requires and what it returns:

$info = $object | Get-Member CreateSubDirectory
$info.Definition.Replace("), ", ")`n")
System.IO.DirectoryInfo CreateSubDirectory(String path)
System.IO.DirectoryInfo CreateSubDirectory(String path, DirectorySecurity DirectorySecurity)

You can see that the method has two signatures. Try using the first to create a sub-directory and the second to add access permissions.

The next line creates a sub-directory called "My New Directory" without any special access privileges:

$object.CreateSubDirectory("My New Directory")
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        01.10.2007     15:49           My New Directory

Because the method returns a DirectoryInfo object as a result and you haven't caught and stored this object in a variable, the pipeline will convert it into text and output it. You could just as well have stored the result of the method in a variable:

$subdirectory = $object.CreateSubDirectory("Another subdirectory")
$subdirectory.CreationTime = "September 1, 1980"
Monday, September 1, 1980 00:00:00

Different Method Types

Similarly to properties, PowerShell can also add additional methods to an object.

MemberType Description
CodeMethod Method mapped to a static .NET method
Method Genuine method
ScriptMethod Method invokes PowerShell code

Table 6.4: Different types of methods

Using Static Methods

By now, you know that PowerShell stores information in objects, and objects always have a type. You know that simple text is stored in objects of type System.String and that a date, for example, is stored in an object of type System.DateTime. You also know by now that each .NET object has a GetType() method with a Fullname property, which tells you the name of the type this object was derived from:

$date = Get-Date

Every type can have its own set of private members called "static" members. You can simply specify a type in square brackets, pipe it to Get-Member, and then use the -static parameter to see the static members of a type.

 [System.DateTime] | Get-Member -static -memberType *method
   TypeName: System.DateTime

Name                  MemberType Definition
----                  ---------- ----------
Compare               Method     static System.Int32 Compare(DateTime t1, DateTime t2)
DaysInMonth           Method     static System.Int32 DaysInMonth(Int32 year, Int32 month)
Equals                Method     static System.Boolean Equals(DateTime t1, DateTime t2), static Sys...
FromBinary            Method     static System.DateTime FromBinary(Int64 dateData)
FromFileTime          Method     static System.DateTime FromFileTime(Int64 fileTime)
FromFileTimeUtc       Method     static System.DateTime FromFileTimeUtc(Int64 fileTime)
FromOADate            Method     static System.DateTime FromOADate(Double d)
get_Now               Method     static System.DateTime get_Now()
get_Today             Method     static System.DateTime get_Today()
get_UtcNow            Method     static System.DateTime get_UtcNow()
IsLeapYear            Method     static System.Boolean IsLeapYear(Int32 year)
op_Addition           Method     static System.DateTime op_Addition(DateTime d, TimeSpan t)
op_Equality           Method     static System.Boolean op_Equality(DateTime d1, DateTime d2)
op_GreaterThan        Method     static System.Boolean op_GreaterThan(DateTime t1, DateTime t2)
op_GreaterThanOrEqual Method     static System.Boolean op_GreaterThanOrEqual(DateTime t1, DateTime t2)
op_Inequality         Method     static System.Boolean op_Inequality(DateTime d1, DateTime d2)
op_LessThan           Method     static System.Boolean op_LessThan(DateTime t1, DateTime t2)
op_LessThanOrEqual    Method     static System.Boolean op_LessThanOrEqual(DateTime t1, DateTime t2)
op_Subtraction        Method     static System.DateTime op_Subtraction(DateTime d, TimeSpan t), sta...
Parse                 Method     static System.DateTime Parse(String s), static System.DateTime Par...
ParseExact            Method     static System.DateTime ParseExact(String s, String format, IFormat...
ReferenceEquals       Method     static System.Boolean ReferenceEquals(Object objA, Object objB)
SpecifyKind           Method     static System.DateTime SpecifyKind(DateTime value, DateTimeKind kind)
TryParse              Method     static System.Boolean TryParse(String s, DateTime& result), static...
TryParseExact         Method     static System.Boolean TryParseExact(String s, String format, IForm...

There are a lot of method names starting with "op_," with "op" standing for "operator." These are methods that are called internally whenever you use this data type with an operator. op_GreaterThanOrEqual is the method that does the internal work when you use the PowerShell comparison operator "-ge" with date values.

The System.DateTime class supplies you with a bunch of important date and time methods. For example, you should use Parse() to convert a date string into a real DateTime object and the current locale:

[System.DateTime]::Parse("March 12, 1999")
Friday, March 12, 1999 00:00:00

You could easily find out whether a certain year is a leap year:


for ($x=2000 $x -lt 2010 $x++) { if( [System.DateTime]::isLeapYear($x) ) { "$x is a leap year!" } }
2000 is a leap year!
2004 is a leap year!
2008 is a leap year!

Or you'd like to tell your children with absolute precision how much time will elapse before they get their Christmas gifts:

[DateTime]"12/24/2007 18:00" - [DateTime]::now
Days              : 74
Hours             : 6
Minutes           : 28
Seconds           : 49
Milliseconds      : 215
Ticks             : 64169292156000
TotalDays         : 74.2700140694444
TotalHours        : 1782,48033766667
TotalMinutes      : 106948,82026
TotalSeconds      : 6416929,2156
TotalMilliseconds : 6416929215,6

Two dates are being subtracted from each other here so you now know what happened during this operation:

  • The first time indication is actually text. For it to become a DateTime object, you must specify the desired object type in square brackets. Important: Converting a String to a DateTime this way always uses the U.S. locale. To convert a String to a DateTime using your current locale, you can use the Parse() method as shown a couple of moments ago!
  • • The second time comes from the Now static property, which returns the current time as DateTime object. This is the same as calling the Get-Date cmdlet (which you'd then need to put in parenthesis because you wouldn't want to subtract the Get-Date cmdlet, but rather the result of the Get-Date cmdlet).
  • • The two timestamps are subtracted from each other using the subtraction operator ("-"). This was possible because the DateTime class defined the op_Subtraction() static method, which is needed for this operator.

Of course, you could have called the static method yourself and received the same result:

[DateTime]::op_Subtraction("12/24/2007 18:00", [DateTime]::Now)

Now it's your turn. In the System.Math class, you'll find a lot of useful mathematical methods. Try to put some of these methods to work.

Function Description Example
Abs Returns the absolute value of a specified number (without signs). [Math]::Abs(-5)
Acos Returns the angle whose cosine is the specified number. [Math]::Acos(0.6)
Asin Returns the angle whose sine is the specified number. [Math]::Asin(0.6)
Atan Returns the angle whose tangent is the specified number. [Math]::Atan(90)
Atan2 Returns the angle whose tangent is the quotient of two specified numbers. [Math]::Atan2(90, 15)
BigMul Calculates the complete product of two 32-bit numbers. [Math]::BigMul(1gb, 6)
Ceiling Returns the smallest integer greater than or equal to the specified number. [Math]::Ceiling(5.7)
Cos Returns the cosine of the specified angle. [Math]::Cos(90)
Cosh Returns the hyperbolic cosine of the specified angle. [Math]::Cosh(90)
DivRem Calculates the quotient of two numbers and returns the remainder in an output parameter. $a = 0
Exp Returns the specified power of e (2.7182818). [Math]::Exp(12)
Floor Returns the largest integer less than or equal to the specified number. [Math]::Floor(5.7)
IEEERemainder Returns the remainder of division of two specified numbers. [Math]::IEEERemainder(5,2)
Log Returns the natural logarithm of the specified number. [Math]::Log(1)
Log10 Returns the base 10 logarithm of the specified number. [Math]::Log10(6)
Max Returns the larger of two specified numbers. [Math]::Max(-5, 12)
Min Returns the smaller of two specified numbers. [Math]::Min(-5, 12)
Pow Returns a specified number raised to the specified power. [Math]::Pow(6,2)
Round Rounds a value to the nearest integer or to the specified number of decimal places. [Math]::Round(5.51)
Sign Returns a value indicating the sign of a number. [Math]::Sign(-12)
Sin Returns the sine of the specified angle. [Math]::Sin(90)
Sinh Returns the hyperbolic sine of the specified angle. [Math]::Sinh(90)
Sqrt Returns the square root of a specified number. [Math]::Sqrt(64)
Tan Returns the tangent of the specified angle. [Math]::Tan(45)
Tanh Returns the hyperbolic tangent of the specified angle. [Math]::Tanh(45)
Truncate Calculates the integral part of a number. [Math]::Truncate(5.67)

Table 6.5: Mathematical functions from the [Math] library

Finding Interesting .NET Types

The .NET framework consists of thousands of types, and maybe you are getting hungry for more. Are there other interesting types? There are actually plenty! Here are the three things you can do with .NET types:

Converting Object Types

For example, you can use System.Net.IPAddress to work with IP addresses. This is an example of a .NET type conversion where a string is converted into a System.Net.IPAddress type:


IPAddressToString :
Address           : 16777343
AddressFamily     : InterNetwork
ScopeId           :
IsIPv6Multicast   : False
IsIPv6LinkLocal   : False
IsIPv6SiteLocal   : False

Using Static Type Members

Or you can use System.Net.DNS to resolve host names. This is an example of accessing a static type method, such as GetHostByAddress():


HostName          Aliases           AddressList
--------          -------           -----------
PCNEU01           {}                {}

Using Dynamic Object Instance Members

Or you can derive an instance of a type and use its dynamic members. For example, to download a file from the Internet, try this:

# Download address of a file:
$address = ""

# Save the file to this location:
$target = "$"

# Carry out download:
$object = New-Object Net.WebClient
$object.DownloadFile($address, $target)
"File was downloaded!"

Creating New Objects

Most of the time, PowerShell cmdlets deliver objects. In addition, you can create new objects (instances) that are derived from a specific type. To get new instances, you can either convert an existing object to a new type or create a new instance using New-Object:

$datetime = [System.DateTime] '1.1.2000'
$datetime = New-Object System.DateTime
$datetime = Get-Date
$datetime = [System.DateTime]::Parse('1.1.2000')

Creating New Objects with New-Object

You can create a .NET object with New-Object,t which gives you full access to all type "constructors." These are invisible methods that create the new object. the type needs to have at least one constructor to create a new instance of a type. If it has none, you cannot create instances of this type.

The DateTime type has one constructor that takes no argument. If you create a new instance of a DateTime object, you will get back a date set to the very first date a DateTime type can represent, which happens to be January 1, 0001:

New-Object System.DateTime
Monday, January 01, 0001 12:00:00 AM

You can use a different constructor to create a specific date. There is one that takes three numbers for year, month, and day:

New-Object System.DateTime(2000,5,1)
Monday, May 01, 2000 12:00:00 AM

If you simply add a number, yet another constructor is used which interprets the number as ticks, the smallest time unit a computer can process:

New-Object System.DateTime(568687676789080999)
Monday, February 07, 1803 7:54:38 AM

Using Constructors

When you create a new object using New-Object, you can submit additional arguments by adding argument values as a comma separated list enclosed in parentheses. New-Object is in fact calling a method called ctor, which is the type constructor. Like any other method, it can support different argument signatures.

Let's check out how you can discover the different constructors, which a type will support. The next line creates a new instance of a System.String and uses a constructor that accepts a character and a number:

New-Object System.String(".", 100)

To list the available constructors for a type, you can use the GetConstructors() method available in each type. For example, you can find out which constructors are offered by the System.String type to produce System.String objects:

[System.String].GetConstructors() | ForEach-Object { $_.toString() }
Void .ctor(Char*)
Void .ctor(Char*, Int32, Int32)
Void .ctor(SByte*)
Void .ctor(SByte*, Int32, Int32)
Void .ctor(SByte*, Int32, Int32, System.Text.Encoding)
Void .ctor(Char[], Int32, Int32)
Void .ctor(Char[])
Void .ctor(Char, Int32)

In fact, there are eight different signatures to create a new object of the System.String type. You just used the last variant: the first argument is the character, and the second a number that specifies how often the character will be repeated. PowerShell will use the next to last constructor so if you specify text in quotation marks, it will interpret text in quotation marks as a field with nothing but characters (Char[]).

New Objects by Conversion

Objects can often be created without New-Object by using type casting instead. You've already seen how it's done for variables in Chapter 3:

# PowerShell normally wraps text as a System.String:
$date = "November 1, 2007"
November 1, 2007

# Use strong typing to set the object type of $date:
[System.DateTime]$date = "November 1, 2007"
Thursday, November 1, 2007 00:00:00

So, if you enclose the desired .NET type in square brackets and put it in front of a variable name, PowerShell will require you to use precisely the specified object type for this variable. If you assign a value to the variable, PowerShell will automatically convert it to that type. That process is sometimes called "implicit type conversion." Explicit type conversion works a little different. Here, the desired type is put in square brackets again, but placed on the right side of the assignment operator:

$value = [DateTime]"November 1, 2007"
Thursday, November 1, 2007 00:00:00

PowerShell would first convert the text into a date because of the type specification and then assign it to the variable $value, which itself remains a regular variable without type specification. Because $value is not limited to DateTime types, you can assign other data types to the variable later on.

$value = "McGuffin"

Using the type casting, you can also create entirely new objects without New-Object. First, create an object using New-Object:

New-Object system.diagnostics.eventlog("System")
  Max(K) Retain OverflowAction        Entries Name
  ------ ------ --------------        ------- ----
  20,480      0 OverwriteAsNeeded      64,230 System

You could have accomplished the same thing without New-Object:

  Max(K) Retain OverflowAction        Entries Name
  ------ ------ --------------        ------- ----
  20,480      0 OverwriteAsNeeded      64,230 System

In the second example, the string System is converted into the System.Diagnostics.Eventlog type: The result is an EventLog object representing the System event log.

So, when can you use New-Object and when type conversion? It is largely a matter of taste, but whenever a type has more than one constructor and you want to select the constructor, you should use New-Object and specify the arguments for the constructor of your choice. Type conversion will automatically choose one constructor, and you have no control over which constructor is picked.

# Using New-Object, you can select the constructor you wish of the type yourself:
New-Object System.String(".", 100)

# When casting types, PowerShell selects the constructor automatically 
# For the System.String type, a constructor will be chosen that requires no arguments
# Your arguments will then be interpreted as a PowerShell subexpression in which
# a field will be created
# PowerShell will change this field into a System.String type
# PowerShell changes fields into text by separating elements from each other with whitespace:
. 100
# If your arguments are not in round brackets, they will be interpreted as a Field
# and the first field element # Cast in the System.String type:
[system.string]".", 100

Type conversion can also include type arrays (identified by "[]") and can be a multi-step process where you convert from one type over another type to a final type. This is how you would convert string text into a character array:


You could then convert each character into integers to get the character codes:

[Int[]][Char[]]"Hello World!"

Conversely, you could make a numeric list out of a numeric array and turn that into a string:

$OFS = ","

Just remember: if arrays are converted into a string, PowerShell uses the separator in the $ofs automatic variable as a separator between the array elements.

Loading Additional Assemblies: Improved Internet Download

To get access to even more functionality, you can load additional assemblies with more types and members. If you have ever written VBScript scripts, you may want to get back some of your beloved VisualBasic methods, such as MsgBox() or InputBox(). Simply load the Microsoft.VisualBasic assembly, which is located in the global assembly cache:

# Load required assembly:

Once you do that, you have access to a whole bunch of new types:

[Microsoft.VisualBasic.Interaction] | Get-Member -static

   TypeName: Microsoft.VisualBasic.Interaction

Name            MemberType Definition
----            ---------- ----------
AppActivate     Method     static System.Void AppActivate(Int32 Proces...
Beep            Method     static System.Void Beep()
CallByName      Method     static System.Object CallByName(Object Obje...
Choose          Method     static System.Object Choose(Double Index, P...
Command         Method     static System.String Command()
CreateObject    Method     static System.Object CreateObject(String Pr...
DeleteSetting   Method     static System.Void DeleteSetting(String App...
Environ         Method     static System.String Environ(Int32 Expressi...
Equals          Method     static System.Boolean Equals(Object objA, O...
GetAllSettings  Method     static System.String[,] GetAllSettings(Stri...
GetObject       Method     static System.Object GetObject(String PathN...
GetSetting      Method     static System.String GetSetting(String AppN...
IIf             Method     static System.Object IIf(Boolean Expression...
InputBox        Method     static System.String InputBox(String Prompt...
MsgBox          Method     static Microsoft.VisualBasic.MsgBoxResult M...
Partition       Method     static System.String Partition(Int64 Number...
ReferenceEquals Method     static System.Boolean ReferenceEquals(Objec...
SaveSetting     Method     static System.Void SaveSetting(String AppNa...
Shell           Method     static System.Int32 Shell(String PathName, ...
switch          Method     static System.Object switch(Params Object[]...
[microsoft.VisualBasic.Interaction]::InputBox("Enter Name", "Name", "$env:username")

Or, you can use a much-improved download method, which shows a progress bar while downloading files from the Internet:

# Reload required assembly:

# Download address of a file:
$address = ""

# This is where the file should be saved:
$target = "$"

# Download will be carried out:
$object = New-Object Microsoft.VisualBasic.Devices.Network
$object.DownloadFile($address, $target, "", "", $true, 500, $true, "DoNothing")

Using COM Objects

In addition to .NET, PowerShell can also load and access most COM objects, which work similar to .NET types and objects, but use an older technology.

Which COM Objects Are Available?

COM objects each have a unique name, known as ProgID or Programmatic Identifier, which is stored in the registry. So, if you want to look up COM objects available on your computer, you can visit the registry:

Dir REGISTRY::HKEY_CLASSES_ROOTCLSID -include PROGID -recurse | foreach {$_.GetValue("")}

How Do You Use COM Objects?

Once you know the ProgID of a COM component, you can use New-Object to put it to work in PowerShell. Just specify the additional parameter -COMObject:

$object = New-Object -ComObject WScript.Shell

You'll get an object which behaves very similar to .NET objects. It will contain properties with data and methods that you can execute. And, as always, Get-Member finds all object members for you. Let's look at its methods:

# Make the methods of the COM objects visible:
$object | Get-Member -memberType *method
   TypeName: System.__ComObject#{41904400-be18-11d3-a28b-00104bd35090}

Name                     MemberType Definition
----                     ---------- ----------
AppActivate              Method     bool AppActivate (Variant, Variant)
CreateShortcut           Method     IDispatch CreateShortcut (string)
Exec                     Method     IWshExec Exec (string)
ExpandEnvironmentStrings Method     string ExpandEnvironmentStrings (string)
LogEvent                 Method     bool LogEvent (Variant, string, string)
Popup                    Method     int Popup (string, Variant, Variant, Variant)
RegDelete                Method     void RegDelete (string)
RegRead                  Method     Variant RegRead (string)
RegWrite                 Method     void RegWrite (string, Variant, Variant)
Run                      Method     int Run (string, Variant, Variant)
SendKeys                 Method     void SendKeys (string, Variant)

The information required to understand how to use a method may be inadequate. Only the expected object types are given, but not why the arguments exist. The Internet can help you if you want to know more about a COM command. Go to a search site of your choice and enter two keywords: the ProgID of the COM components (in this case, it will be WScript.Shell) and the name of the method that you want to use.

Some of the commonly used COM objects are WScript.Shell, WScript.Network, Scripting.FileSystemObject, InternetExplorer.Application, Word.Application, and Shell.Application. Let’s create a shortcut to powershell.exe using WScript.Shell Com object and its method CreateShorcut():

# Create an object:
$wshell = New-Object -comObject WScript.Shell 
# Assign a path to Desktop to the variable $path
$path = [system.Environment]::GetFolderPath('Desktop')

# Create a link object $link = $wshell.CreateShortcut("$pathPowerShell.lnk") 
# $link is an object and has the properties and methods
$link | Get-Member

   TypeName: System.__ComObject#{f935dc23-1cf0-11d0-adb9-00c04fd58a0b}

Name             MemberType   Definition
----             ----------   ----------
Load             Method       void Load (string)
Save             Method       void Save ()
Arguments        Property     string Arguments () {get} {set}
Description      Property     string Description () {get} {set}
FullName         Property     string FullName () {get}
Hotkey           Property     string Hotkey () {get} {set}
IconLocation     Property     string IconLocation () {get} {set}
RelativePath     Property      {get} {set}
TargetPath       Property     string TargetPath () {get} {set}
WindowStyle      Property     int WindowStyle () {get} {set}
WorkingDirectory Property     string WorkingDirectory () {get} {set}

# We can populate some of the properties
$link.TargetPath = 'powershell.exe'
$link.Description = 'Launch Windows PowerShell console' 
$link.WorkingDirectory = $profile
$link.IconLocation = 'powershell.exe' # And save the changes using Save() method $link.Save()


Everything in PowerShell is represented by objects that have exactly two aspects: properties and methods, which both form the members of the object. While properties store data, methods are executable commands.

Objects are the result of all PowerShell commands and are not converted to readable text until you output the objects to the console. However, if you save a command’s result in a variable, you will get a handle on the original objects and can evaluate their properties or call for their commands. If you would like to see all of an object’s properties, then you can pass the object to Format-List and type an asterisk after it. This allows all—not only the most important—properties to be output as text.

The Get-Member cmdlet retrieves even more data, enabling you to output detailed information on the properties and methods of any object.

All the objects that you will work with in PowerShell originate from .NET framework, which PowerShell is layered. Aside from the objects that PowerShell commands provide to you as results, you can also invoke objects directly from the .NET framework and gain access to a powerful arsenal of new commands. Along with the dynamic methods furnished by objects, there are also static methods, which are provided directly by the class from which objects are also derived.

If you cannot perform a task with the cmdlets, regular console commands, or methods of the .NET framework, you can resort to the unmanaged world outside the .NET framework. You can directly access the low-level API functions, the foundation of the .NET framework, or use COM components.