Advanced Windows PowerShell Scripting Video Training

Advanced Windows PowerShell Scripting Video Training
Advanced Windows PowerShell Scripting Video Training

Tuesday, January 15, 2019

What Will a Cmdlet Accept Through the PowerShell Pipeline?

Happy New Year!

Ok, that is a bit late.  I'm getting around to catching up on some questions from my classes last year.  Here is a good one.

What Will a Cmdlet Accept Through the PowerShell Pipeline? Well, that is a good question.  How a object is piped from one cmdlet to another is a touchy subject in my PowerShell classes.  This extremely powerful feature needs to be used, but the research that goes into it for new PowerShell developers can be a bit complex.  To help out, I built a cmdlet to read the help files of a cmdlet or script and determine what parameters accept pipeline input ByValue or ByPropertyName and what data type they require.  All of these are required to help the developer understand if they can pipe their objects to a cmdlet.

Here you go!  Have fun with it.

Function Get-PipelineInfo {
Param (

Write-Verbose "Pipeline informaiton for $Cmdlet."
(Get-Help $Cmdlet).Parameters.Parameter |
    Where-Object PipelineInput -ne "False" |
    Select-Object -Property Name ,
        @{N = "ByValue" ; E = { If ($_.PipelineInput -Like "*ByValue*") {$True}
                                Else {$False} }},
        @{N = "ByPropertyName" ; E = { If ($_.PipelineInput -Like "*ByPropertyName*") {$True}
                                        Else {$False} }},
        @{N = "Type"; E = {$_.Type.Name}}

Gets the pipeline information for cmdlets.

Reads the help files of PowerShell scripts and cmdlets and extracts the
information on all parameters that accept information from the PowerShell

The cmdlet you want to get pipeline information on.

Get-PipelineInfo -Cmdlet 'Get-Process'

name         pipelineInput         Type      Cmdlet    
----         -------------         ----      ------    
ComputerName True (ByPropertyName) String[]  Get-Process
Id           True (ByPropertyName) Int32[]   Get-Process
InputObject  True (ByValue)        Process[] Get-Process
Name         True (ByPropertyName) String[]  Get-Process

== Cmdlet: Get-PipelineInfo                                                  ==
== Author: Jason A. Yoder                                                    ==
== Company: MCTExpert of Arizona                                             ==
== Date: January 15, 2019                                                    ==
== Copyright: All rights reserved.                                           ==
== Version:                                                          ==
== Legal: The user assumes all responsibility and liability for the usage of ==
== this PowerShell code.  MCTExpert of Arizona, Its officers, shareholders,  ==
== owners, and their relatives are not liable for any damages.  As with all  ==
== code, review it and understand it prior to usage.  It is recommended that ==
== this code be fully tested and validated in a test environment prior to    ==
== usage in a production environment.                                        ==
==                                                                           ==
== Does this code make changes: NO                                           ==
} # END: Function Get-PipelineInfo

Friday, February 2, 2018

Overwriting a PowerShell Constant

I have always said that one of the greatest benefit to teaching PowerShell (and Windows) is that different people bring different ideas to the table.  Things get fun for me when someone looks at what we are doing from a different angle and asked an interesting question.

This week’s class in Fort Wayne produced one of those questions.  We were looking at some of the options that are available to use with creating variables with the New-Variable cmdlet.  In particular, we were looking at constants.  Let’s build one.

PS C:\> New-Variable -Name Test1 -Value ([Bool]$True) -Option Constant

Now let’s take a look at the variable object.
Name        : Test1
Description :
Value       : True
Visibility  : Public
Module      :
ModuleName  :
Options     : Constant
Attributes  : {}

We can see from the Options property that we have created a constant.  We are going to attempt to change that value of this constant to FALSE.

PS C:\> Set-Variable -Name Test1 -Value $false
Set-Variable : Cannot overwrite variable Test1 because it is read-only or constant.
At line:1 char:1
+ Set-Variable -Name Test1 -Value $false
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : WriteError: (Test1:String) [Set-Variable], SessionStateU
    + FullyQualifiedErrorId : VariableNotWritable,Microsoft.PowerShell.Commands.SetVar

This is what we expected.  By definition, a constant cannot be changed.  We also attempted to change it with the –Force parameter.

PS C:\> Set-Variable -Name Test1 -Value $false -Force
Set-Variable : Cannot overwrite variable Test1 because it is read-only or constant.
At line:1 char:1
+ Set-Variable -Name Test1 -Value $false -Force
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : WriteError: (Test1:String) [Set-Variable], SessionStateU
    + FullyQualifiedErrorId : VariableNotWritable,Microsoft.PowerShell.Commands.SetVar

Again, the expected results.  Well, this is where that question comes into play.  What if you re-cast the variable?  OK, let’s give this a try.

PS C:\> [Bool]$Test1 = $False

PS C:\> $Test1

Wait… What?  You cannot even get rid of a constant with Remove-Variable but here we changed it.  OK, did we really change the value or did it delete the variable and then recreate it?  Here is another test.

PS C:\> Set-Variable -Name Test3 -Value ([Bool]$True) -Option Constant -Description "This is a test"

Here we included a description which you can see in the variable objects properties.

Name        : Test3
Description : This is a test
Value       : True
Visibility  : Public
Module      :
ModuleName  :
Options     : Constant
Attributes  : {}

We are going to change this variable using the same successful method from above.

PS C:\> [Bool]$Test3 = $False

PS C:\> $Test3

And now let’s look at the properties to see if the description is still there.
PS C:\> Get-Variable -Name Test3 | Select-Object -Property *

PSPath        : Microsoft.PowerShell.Core\Variable::Test3
PSDrive       : Variable
PSProvider    : Microsoft.PowerShell.Core\Variable
PSIsContainer : False
Name          : Test3
Description   : This is a test
Value         : False
Visibility    : Public
Module        :
ModuleName    :
Options       : Constant
Attributes    : {System.Management.Automation.ArgumentTypeConverterAttribute}

The description is still there.  So, I guess there is a way to change the value of a constant without restarting PowerShell

Wednesday, January 31, 2018

What are Positional Parameters?

Often while teaching PowerShell, we get into a discussion about how someone, usually me, types this:

Get-Help Get-Date

Instead of

Get-Help –Name Get-Date

PowerShell parameters utilize positioning.  Good authors of cmdlets will determine which parameter will be the most frequently used and put that parameter in the first position.  That means if the user types a cmdlet, they can immediately provide the data for that parameter without calling the parameter name.  Take a look at the –Name parameter of Get-Help
    Gets help about the specified command or concept. Enter the name of a cmdlet, function, provider,
    script, or workflow, such as `Get-Member`, a conceptual topic name, such as `about_Objects`, or an
    alias, such as `ls`. Wildcard characters are permitted in cmdlet and provider names, but you
    cannot use wildcard characters to find the names of function help and script help topics.
    To get help for a script that is not located in a path that is listed in the Path environment
    variable, type the path and file name of the script.
    If you enter the exact name of a help topic, Get-Help displays the topic contents. If you enter a
    word or word pattern that appears in several help topic titles, Get-Help displays a list of the
    matching titles. If you enter a word that does not match any help topic titles, Get-Help displays
    a list of topics that include that word in their contents.
    The names of conceptual topics, such as `about_Objects`, must be entered in English, even in
    non-English versions of Windows PowerShell.
    Required?                    false
    Position?                    0
    Default value                None
    Accept pipeline input?       True (ByPropertyName)
    Accept wildcard characters?  false

Two things to take note of.  First of all, the type of data that this parameter accepts is [String].  The second is the value of Position which is zero.  That means if the user types the cmdlet Get-Help and then a value of the type string, that value will be the argument for the –Name parameter. 

I often stress the need for full command syntax in scripts so everyone knows what parameters you are using but I am also guilty of using positional parameters for my more common cmdlets like Get-Help and Where-Object.  Here is some code to help you see the parameter in the first position and what type of data it expects.  Just be forwarded, it will load all of your modules into memory.
$Commands = Get-Command

ForEach ($CMD in $Commands) {
    $Obj = [PSCustomObject]@{
        'Cmdlet' = $CMD.Name
        'PositionOne' = (($CMD | Get-Help).parameters.parameter | where position -eq 0).Name
        'Type' = (($CMD | Get-Help).parameters.parameter| where position -eq 0).Type.Name

    Write-OutPut $Obj

Monday, January 29, 2018

How to start a PowerShell Script from a Batch File

How to start a PowerShell Script from a Batch File

In last week’s PowerShell class in Phoenix, we had a last minute question.  It involved trying to simplify the launching of a PowerShell script for users.  Having end users working with PowerShell has long been a cumbersome task.  End users like a GUI.  We can put a GUI interface on top of our code, but it is difficult to do manually or you need a third party solution.  When you build a GUI, it also takes an additional skill set that most IT Pros do not have.

We decided to go with a batch file.  Yes, I know.  Old tech but we will give it new life.  Here is our test code for this project. We saved this file as c:\ps\Test1.ps1.

Write-Host "I work!!!" -BackgroundColor DarkMagenta

Yes, I know.  Not exactly exciting.  The purpose of this is to get it to launch with a batch file.

We looked at the PowerShell.exe Command-Line Help ( to see how to launch PowerShell with a script from the command line at the same time.  We came up with:

PowerShell.exe –File C:\PS\Test1.ps1

We saved this command line into a batch file in the same directory as the script and was able to launch it from a desktop shortcut icon.  Right now, this is a viable option.

What about using parameters?  This is a bit more difficult.  The original objective was to do it from a DOS command prompt, but when we add parameters, the process is just as complex as doing it PowerShell if not more.  Here is our new code.

Param ($ComputerName)
Write-Host "I work!!!" -BackgroundColor DarkMagenta
Write-Host $ComputerName

Again, I know.  Real advanced.  This is what our batch file looks like now:

PowerShell.exe –File C:\PS\Test1.ps1 –ComputerName INDY-DC1
The original goal was to simplify this so the user did not have to type in PowerShell.  At this point, I would actually have the user use PowerShell and turn this script into a cmdlet in an auto-loading module.  To do this new process via batch file, here are the steps:
1.       Open Notepad
2.       Open the batch file in notepad
3.       Manually enter the computer name.
4.       Save the file
5.       Double click the desk shortcut to the batch file.

If this was a cmdlet in an auto-loading module, here is the process:
1.       Open PowerShell
2.       Type CmdletName –ComputerName INDY-DC1
That is it!

Monday, January 22, 2018

How to tell PowerShell which version of .NET to Use

Here is one from this week’s PowerShell class. We just finished a lesson on methods and I passed on “The first rule of Computer Science” to my class that one of my professions, Dan Matthews, passed on to me.  It simply states “Never re-invent the wheel”.  With that, we started to talk about the value of methods.  The question popped us as to which version of .Net is PowerShell using and how to select a different version?  Well, here is how to determine the current installed versions of .Net:

 PS C:\> Get-Childitem "HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP"

    Hive: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP

Name                           Property                                                                                                                            
----                           --------                                                                                                                            
v2.0.50727                     CBS       : 1                                                                                                                       
                               Increment : 4927                                                                                                                     
                               Install   : 1                                                                                                                        
                               OCM       : 1                                                                                                                       
                               SP        : 2                                                                                                                        
                               Version   : 2.0.50727.4927                                                                                                           
v3.0                           CBS       : 1                                                                                                                       
                               Increment : 4926                                                                                                                     
                               Install   : 1                                                                                                                       
                               SP        : 2                                                                                                                       
                               Version   : 3.0.30729.4926                                                                                                           
v3.5                           CBS         : 1                                                                                                                     
                               Install     : 1                                                                                                                     
                               InstallPath : C:\Windows\Microsoft.NET\Framework64\v3.5\                                                                             
                               SP          : 1                                                                                                                     
                               Version     : 3.5.30729.4926                                                                                                        
v4.0                           (default) : deprecated                                                                                                              

As for how to select a different version, I am going to default over to an article on Kris Powell’s blog.  You can view it here

Remember the 1st rule of computer science.  He answered it, let’s not repeat his work and give him the proper credit.