Windows PowerShell for .NET Developers - Second Edition

Before we explore the PowerShell console host and the PowerShell ISE, let's install Windows Management Framework 5.0 April 2015 Preview (Latest Build). Windows Management Framework 5.0 is now supported on Windows 7 and Windows Server 2008 R2 SP1—this will be covered in Chapter 3, Exploring Desired State Configuration in detail. Windows Management Framework is shipped out of the box in the Windows 10 operating system and Windows Server Technical Preview. So, there is no need for manual installation.

To start the demo, we need to perform the following functions in our machine environment:

To open Windows PowerShell, perform the following functions:

Here, ISE is short for Integrated Scripting Environment.

It's best practice to know your PowerShell version before you start doing an exercise or start using scripts from the Internet.

To check the current version of PowerShell, you can simply run the following code:

$PSVersionTable

The following screenshot illustrates the output:

Windows Server 2012 R2 has WMF Version 4.0 by default. Let's upgrade it to WMF 5.0. If you are performing this task on Windows 7 or Windows 2008 R2 with SP1, install WMF 4.0 prior to WMF 5.0.

Following are the links where you can download the .NET framework and WMF from:

Once the .NET framework 4.0 is in place, update it to the .NET framework 4.5.

As per the Microsoft Document, the .NET framework 4.5 is included in Windows 8 and Windows Server 2012. We can skip the .NET framework 4.5 installation.

We need to identify and install the correct package of WMF 5.0. For Windows Server 2012, we need to download the 64-bit version of it, which is WindowsBlue-KB3055381-x64.msu.

Open the MSU package and you will see the prompt, as shown in the following screenshot:

We have successfully installed WMF 5.0. As an outcome of this upgrade, now we also have the updated versions of Windows PowerShell, Windows PowerShell Desired State Configuration (DSC), and the Windows PowerShell ISE. Package manager and network switches cmdlets are included with this version.

The following image illustrates the Windows PowerShell 5.0 ISE:

Windows PowerShell has two different consoles: the console host and the Windows PowerShell ISE host, which is GUI. To verify this, click on the start icon and search for PowerShell on Windows Server 2012.

The following image illustrates the results of PowerShell:

The Windows PowerShell console host

This is where we begin with the PowerShell cmdlets. It's easy for on-the-fly cmdlet executions. The following image illustrates the PowerShell 5.0 console host:

By default, the background color is blue, and in the foreground, the color of the text is white.

There is no need to type out the complete command; the PowerShell console allows Tab Completion. For example, Get-Se + Tab completes the Get-Service command. Tab completion is not only for the commands and parameters; we can also select the properties using tab key.

To execute the following PowerShell code:

Get-Service -Name BITS | Select -Property Name , Status

Windows PowerShell allows tab completion like this:

Get-Ser + Tab -N + Tab BITS | sel + Tab -Pro + Tab N + Tab , S + Tab

There are multiple ways to start a PowerShell console: we could either use the Run dialog box, or type PowerShell in an open command-line window. These techniques allow you to pass arguments to Windows PowerShell, including the switches that control how Windows PowerShell works and the parameters that execute additional commands. For example, you can start Windows PowerShell in the no-logo mode (which means that the logo banner is turned off) using the startup command, PowerShell -nologo. By default, when you start Windows PowerShell via the command shell, Windows PowerShell runs and then exits. If you want Windows PowerShell to execute a command and not terminate, type PowerShell /noexit, followed by the command text.

We can use this to schedule our script in task schedulers. To see all the switches, run the following command:

PowerShell.exe /?

Tip

Downloading the example code

You can download the example code files from your account at http://www.packtpub.com for all the Packt Publishing books you have purchased. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

Setting up the console host using GUI

We can change the look and feel of the console host using GUI. To do this, we need to perform the following steps:

Click on the Windows PowerShell icon, which appears in the upper-left corner and select Properties. This has four tabs—Options, Font, Layout, and Colors. Let's explore each tab.

• Options: Using the Options tab, we can see Cursor Size, Command History, and Edit Options, and adjust them as we require.

  While setting the cursor size, we have three options: Small, Medium, and Large. Here, small is 25 pixels, medium is 50 pixels, and large is 100 pixels.

  The following image illustrates the Options tab:

  

  By default, the command history retains the last 50 commands in a buffer. We can customize this by increasing or decreasing the Buffer Size value.

  Tip

  $MaximumHistoryCount is a built-in variable that returns the actual value of the command's history. This takes precedence over GUI.

• Font: Using the Font tab, we can change the size, style, and type. Before applying changes, we can preview the console host using the preview window.

  The following image illustrates the Font tab:

  

• Layout: Using the Layout tab, we can set the screen buffer size, window size, and window position. Similarly to the Font tab, this also has preview window.

  The following image illustrates the Layout tab:

  

• Colors: Using the Colors tab, we can set the screen text, screen background, pop up text, and popup background values. The current RGB values are shown in the Selected Color Values section. The modifications can be previewed before applying.

  The following image illustrates the Colors tab:

  

Tip

Press F7 to see the history; this pops up a tiny window as shown in the following image:

Setting up the console host using PowerShell

The steps we explored under Graphical User Interface (GUI) are limited; we can actually do more using PowerShell. Here comes the importance of objects. In this exercise, we will adjust our console settings. To do all this, we need to know is Get-Host command-let.

The Get-Host cmdlet is used to do more of the Windows PowerShell console setup. In this exercise let's change the title of the PowerShell console host.

The default console host title is shown in the following image:

Administrator: Windows PowerShell is the default title. Now let's change this to Windows PowerShell 5.0 April 2015 Preview. Run the following commands:

(Get-Host).UI.RawUI
(Get-Host).UI.RawUI | GM

The preceding code returns the current settings and its members.

The output is illustrated in the following image:

WindowTitle is a property for which we can get and set a value and whose datatype is String. We will discuss this in detail in the Understanding Objects section. Now, let's execute the following code to change the title of the console host:

(Get-Host).UI.RawUI.WindowTitle = "Windows PowerShell 5.0 April 2015 Preview"

The change appears as illustrated in the following image:

Using GUI, we can set the cursor size to small, medium, or large, which allows only 25, 50, or 100 respectively. But, PowerShell allows us to customize more by executing the following command:

(Get-Host).UI.RawUI.CursorSize

The previous command returns the current cursor size. Run the following command:

(Get-Host).UI.RawUI.CursorSize.GetType()

This command returns the type as shown in the following image:

Now, let's change the cursor size to 72 by executing the following command:

(Get-Host).UI.RawUI.CursorSize = 72

The output is illustrated in the following image:

Exploring the Windows PowerShell ISE host using GUI

The Windows PowerShell ISE host is enhanced and exciting in version 5.0. This version has lots of new features and is user friendly. The ISE helps us to write scripts faster than a console. We will explore the features of ISEs in Chapter 3, Exploring Desired State Configuration.

Opening the PowerShell ISE is similar to opening the console host. Click on the start icon, search for PowerShell, and open PowerShell ISE. The executable file for the PowerShell ISE resides in the same location as console host:

%windir%\system32\WindowsPowerShell\v1.0\PowerShell_ISE.exe

The following image illustrates the PowerShell ISE:

The PowerShell ISE host is divided into the following sections:

• 1: Script pane

• 2: Command pane

• 3: Commands add-on

The script pane's visibility can be adjusted using the keyboard shortcuts, Ctrl + 1, Ctrl + 2, Ctrl + 3, which sets the script pane to top, right, and maximized, respectively. This makes it easy for us to view the command and result that we need.

The command pane will be hidden if we maximize the script pane.

Let us learn more about commands add-on pane:

1. By default, all the available modules will be shown. Click on the drop-down list to view the modules.

2. Click on Refresh if any new modules are loaded.

3. Type the command name, and it will show the output as illustrated in the following image:

   

4. Enter the command.

5. Select the command.

6. Click on the help icon, and this opens up the help in GUI.

7. Enter the parameters as required. The * sign denotes mandatory.

8. The common parameters are not always required, but we will use them in the next chapters.

9. We can run the code, copy it, or click on Insert, which appears in the command pane. Ensure that you haven't maximized the Script Pane.

An ISE allows us to cut, copy, paste, start IntelliSense, and start the snippets. Similarly to other windows operations, Ctrl + X, Ctrl + C, and Ctrl + Y will cut, copy, and paste, respectively.

IntelliSense gives us a better discoverability of cmdlets. A bunch of related commands will be shown in the drop-down menu, so we can easily choose the cmdlet we need. The Syntax tooltip lists the parameters to be used with the command, as shown in the following image:

1. As soon as we start typing, IntelliSense shows us the list of commands that begin with the text that is typed. We can scroll down and choose the command we need to execute.

2. The syntax tooltip shows the syntax of the command that we choose.

To get help about the command, simply type the command, select it, and press F1.

The output is illustrated in the following image:

The points marked in the figure are explained in the following list:

• 1: Select the command.

• 2: Press F1, which brings up the help window.

• 3: Click on Settings.

• 4: Select the sections you need to know. For example, unselect Examples to hide the example section in the help window.

Benefits of an ISE

In comparison with the PowerShell console host, an ISE has a lot of benefits, and I will list a few of them here:

• It's easy to use

• It's very user friendly

• There are shortcut keys to manage the script

• Writing the DSC configuration code is easy

• The snippets make our job much easier

• There is a script browser

• We have the Command add-on

• It shows a squiggly line in case of errors

The PowerShell ISE script browser

PowerShell ISE has a script browser feature that allows us to search for the script in TechNet's script gallery. This is optional but worth using! This is because using Script Browser, we can download and use the scripts available in TechNet's script gallery.

The following image illustrates Script Browser:

Following are a few options in Script Browser:

• You can search for the script you need. Type the script's name in the textbox provided, right-click on the script, and select either Add to favorites or the Download option.

• Your favorite scripts appears in the Favorites tab.

• The scripts that you download will appear in the Downloads tab.

• You can set the language, download locations and network settings by clicking on the settings icon in the upper-right corner.

The following image shows the Settings window of Script Browser:

Some benefits of Script Browser are as follows:

• Script Browser allows us to filter the search based on technologies

• Script Browser allows us to sort the script by popularity, ratings, and so on

Note

The link to download Script Browser is http://www.microsoft.com/en-us/download/details.aspx?id=42525.

In this topic, we will cover the following:

Windows PowerShell is designed to execute four kinds of named commands:

The internal commands of Windows PowerShell are called cmdlets. Cmdlets are always named in the verb-and-noun combination. This appears as Verb-Noun, for example Get-Service and Stop-Service, where Get and Stop are verbs, and Service is a noun.

(Verb)—Action

(Noun)—Something to be acted on

For example, Get-Service

Let's execute the following command:

Get-Command

The output of this command is illustrated in the following image:

The previous command will list all the installed commands from the computer and retrieve only the cmdlets, functions, and aliases.

To retrieve only cmdlets, we can use the CommandType parameter, as shown in the following command:

Get-Command -CommandType Cmdlet

Get-Command -CommandType Cmdlet

Now, let's explore the commands. In the following example, we will take a look at the cmdlet Get-Service. Since we know the cmdlet up front, let's collect more information such as the cmdlet version and source, as follows:

Get-Command Get-Service

The output of the preceding command is illustrated in the following image:

The points marked in the figure are explained in the following list:

To retrieve the commands for a specific module, we need to use the Module parameter, which accepts the module name (Source) as we saw in bullet 4. The following is an example of the command:

Get-Command -Module Microsoft.PowerShell.Management

This outputs all the commands available in the Microsoft.PowerShell.Management module.

The Get-Service command will retrieve all the services running on your local computer.

Let's see the alternate of the Get-Service cmdlet using the .NET class. To do this, let's find the TypeName of the Get-Service cmdlet by executing Get-Service | Get-Member and this gives the TypeName as System.ServiceProcess.ServiceController. Windows PowerShell allows us to use this directly as follows:

[System.ServiceProcess.ServiceController]::GetServices()

Now, let's take a look at how the command that we just discussed works.

Here, we will consume the .NET ServiceController class in PowerShell and invoke the GetServices() method.

The GetServices method has an overload with a machineName parameter. To find this, we will execute the following command:

[System.ServiceProcess.ServiceController]::GetServices

The difference is that here, we did not use parentheses. The output of OverloadDefinitions is as follows:

OverloadDefinitions
-------------------
static System.ServiceProcess.ServiceController[] GetServices()

static System.ServiceProcess.ServiceController[] GetServices(string machineName)

We can query the service information of a remote computer by passing the host name of the remote computer as the machineName parameter, as follows:

 [System.ServiceProcess.ServiceController]::GetServices('RemoteServer')

This is the most important and interesting topic. No matter what technology we consume, all we need to know is the way to get help for it. Most IT professionals and developers say that they use Google to find this.

For PowerShell, help is much more focused. It's very difficult to remember all the commands. So, we can search for a command and find help for the same. Let's take a look at how to seek help for Windows PowerShell cmdlets.

Get-Help Get-Service

The output is illustrated in the following image:

The sections in the image are explained as follows:

If more information than that fitting the page view is to be displayed, the console is paginated. For example, if we execute the Get-Help Get-Service -Detailed | more command, the details will output as shown in the following image:

If we press Enter, we can view one line after another, whereas pressing the space key will give a page view.

Note

Keep your files updated using the Update-Help cmdlet as shown in the following command. Ensure that your machine has internet connectivity and execute the following command:

Update-Help –Verbose

This cmdlet is designed to download and install help files on our computer.

The output is illustrated in the following image:

Ensure that you have an Internet connection while updating your help. The reason for updating help is to keep the help document up-to-date. Let us learn more about the Get-Help cmdlet:

Using aliases in Windows PowerShell is not advised by many. The reason for this is readability and understandability. Developers are comfortable using an alias because it's easier, but the difficulty is in remembering the alias for each cmdlet.

The bottom line is that aliases are shortcuts for Windows PowerShell cmdlets.

Windows PowerShell has two types of aliases:

The following command retrieves all the commands available in the Microsoft.PowerShell.Management module:

Get-Command -Module Microsoft.PowerShell.Management

The following image shows the output of the previous command:

Using the following alias, we can achieve the same output as with –like:

gcm -Module Microsoft.PowerShell.Management

Here, gcm is an alias or shortcut for the Get-Command cmdlet.

Let's explore all the commands related to an alias. The module name for aliases' commands is Microsoft.PowerShell.Utility:

Get-Command -Name '*Alias*' 

The output of this command is illustrated in the following image:

For now, ignore the PoshBoard module; we will discuss modules in Chapter 2, Unleashing Development Skills Using Windows PowerShell 5.0.

To find an alias of any given command, we can simply execute the following code:

Get-Alias -Definition Get-Alias

The output of this command is as follows:

PS C:\> Get-Alias -Definition Get-Alias

CommandType     Name                                               Version    Source
-----------     ----                                               -------    ------
Alias           gal -> Get-Alias

Here, gal is an alias of the Get-Alias cmdlet. The Get-Alias cmdlet will retrieve all the available aliases in your local computer.

PowerShell allows us to create aliases for any given valid cmdlet. To create a new alias, we execute the following command:

New-Alias -Name W -Value Get-WmiObject -Description "Learning PowerShell" -Verbose

The output of the command we just discussed is as follows:

VERBOSE: Performing the operation "New Alias" on target "Name: W Value: Get-WmiObject"

Now, let's take a look at how the command we just discussed works.

The New-Alias command is used to create an alias.

The W part is a friendly name. You can choose any name you need, but you can't create a new alias with the existing, used names.

The Value command is used here. We also used the Get-WmiObject command, and that's our definition.

The Description parameter is for our reference.

The Verbose parameter just shows the action performed by the message.

The output of the preceding command is illustrated in the following image:

The sections in the image are explained as follows:

Using the Set-Alias command, we can do the same, but it allows us to change the association later. In the preceding example, we created an alias named W for the Get-WmiObject command. If we try to create an alias with the same name for another command, the following error appears:

In this scenario, we can use the Set-Alias command to change the alias' association. Run the following code:

PS C:\> Set-Alias -Name W -Value Get-Service -Description 'Change Association' -Verbose
VERBOSE: Performing the operation "Set Alias" on target "Name: W Value: Get-Service" 

If you create more aliases in your machine, you can move them to other machines using the following two cmdlets:

In this exercise, we will create an alias for the Test-Connection cmdlet and use it in other machines. The Test part will be the alias of Test-Connection. Following is the command to set the alias' name:

New-Alias -Name Test -Value Test-Connection -Description "Testing" -Verbose

Let's test the functionality using the following command:

test localhost

This command returns the following output:

Let's use the Export-Alias cmdlet and export only this alias using the following command:

Export-Alias -Name test C:\Temp\CustomAlias.txt –Verbose

We will get the following output:

# Alias File
# Exported by : ChenV
# Date/Time : Tuesday, August 25, 2015 1:57:28 PM
# Computer : CHENV
"Test","Test-Connection","Testing","None"

Move this text file to another computer and use the Import-Alias cmdlet to do this.

Look at the following image:

The steps marked in the image we just discussed are explained as follows:

Note

There is no direct cmdlet to remove an alias, such as Remove-Alias. So, how do we do this?

Alias is one of the items in the PowerShell drive. Yes! We can use the Remove-Item cmdlet to remove the alias. Execute the following command:

Get-Item Alias:\test

The command that we just discussed returns the following output:

So, you can simply use Remove-Item to delete the alias. Execute the command as shown in the following image:

Windows PowerShell supports regular expressions. We know that PowerShell is built using the .NET framework. So, it strongly supports the regular expressions in .NET.

Developers prefer to use regular expressions to solve complex tasks such as formatting display names, manipulating files, and so on.

Regex can either be used by comparing operators or implementing the .NET class.

In this topic, we will cover the following:

Before we proceed with regular expressions, let's explore a few things about operators.

To know about operators, we can run the following code:

help about_Operators -ShowWindow

The output is illustrated in the following image:

To retrieve help for all the operators in Windows PowerShell, you can run each of the following lines of code and explore their usage:

help about_Arithmetic_Operators
help about_Assignment_Operators
help about_Comparison_Operators
help about_Logical_Operators
help about_Type_Operators
help about_Split
help about_Join
help about_Redirection

Windows PowerShell has operators such as arithmetic operators, assignment operators, comparison operators, logical operators, redirection operators, split and join operators, type operators, format operators, static member operators, and so on.

As we are exploring regular expressions, we will focus only on the comparison operators.

Comparison operators are used to compare values and to find the matching pattern. By default, comparison operators are not case sensitive.

We can also perform case-sensitive pattern matching using C before the operators.

Let's consider both these in the following example:

#Case In-Sensitive
"PowerShell" -match "PowerShell"

This command returns the output as true.

#Case Sensitive
"PowerShell" -cmatch "powershell"

This command returns the output as false.

Now, it's time for us to use the .NET regular expressions in Windows PowerShell with the comparison operators

Here is a command that uses a regular expression to check whether the first three characters are digits in a given string.

For example, the given string is 123-456-ABC. Then, the command would be as follows:

"123-245-ABC" -match '^\d{3}'

This command returns the output as true.

"EFG-245-ABC" -match '^\d{3}'

This command returns the output as false.

Now, let's take a look at how the command that we just discussed works, in the following list:

Use the following regular expression to remove the white space characters from any given string:

"Power Shell" -replace '\s' , ''

This returns PowerShell.

 "Power Shell" -replace '\s' 

The given input string is Power Shell. The expression removes the white space between Power and Shell in the string and outputs the Powershell word. The white space is removed as explained in the following steps:

We can swap strings using regular expressions.

Consider the given string as FirstName LastName:

#Given Name: FirstName LastName
#Required Output: LastName, FirstName
"FirstName LastName" -replace "([a-z]+)\s([a-z]+)" ,'$2, $1'

The commands that we just discussed return the output as LastName, FirstName.

Consider the given string as FirstName12345 LastName:

#Given Name: FirstName12345 LastName
#Required Output: LastName, FirstName
'FirstName12345 LastName' -replace "\d+" -replace "([a-z]+)\s([a-z]+)" ,'$2, $1'

The commands that we just discussed return the output as LastName, FirstName.

The output of the previous two expressions is illustrated in the following image:

Similarly, PowerShell allows us to use the regex class to perform the same tasks. Execute the following code:

[Regex]::IsMatch('PowerShell' , 'PowerShell')

The IsMatch method is a member of the regex class. This method is overloaded, which indicates whether the regular expression finds a match in the input string. This is a simple example to check whether a string contains another string.

Developers can easily understand and implement regex. However, IT professionals or system administrators may have difficulties in understanding the arguments to be passed.

What arguments should we pass for members? It's not always necessary to refer to the MSDN article. Instead, we can use PowerShell to find the overloaded definitions.

In the following example, we will use the Replace method (the public method of the regex class):

[Regex]::Replace

The output of the code that we just discussed is illustrated in the following image:

To remove the numbers from the given string using regex, we execute the following command:

[Regex]::Replace('12String' , '\d{2}' , '')

The command that we just considered returns the output as String. We get this output as explained in the following steps:

In general, a term object is something that we can touch and feel, and the same is applicable for PowerShell as well. An object in PowerShell is a combination of methods and properties:

Objects = Properties + Methods

A property is something that we can get or set. In short, properties store information about the object.

A method is an action to be invoked on a particular object.

Objects are constructed using their types, properties, and methods.

In this section, we will cover the following topics:

Before we explore objects, let's have a look at the help documentation using the following commands:

help about_Objects
help about_Properties
help about_Methods

The objects that we see in PowerShell are a part of the .NET framework, and PowerShell will allow us to create custom objects as well.

Now, let's explore objects in detail. In the following example, we will use the Get-Date command:

$Date = Get-Date

Here, $Date is a variable in Windows PowerShell and Get-Date is a cmdlet to get the current date and time.

Once we run the preceding code, $date will be a DateTime object. Let's take a look at the type of the $Date variable:

$Date.GetType()

The output of this command is as follows:

The Get-Member cmdlet is our friend, and helps us to explore the members and properties. To take a look at the available properties and methods, we can run the following code:

Get-Date | Get-Member -MemberType All -Force

The preceding command retrieves all the properties and methods.

The list will be huge; so, to view the properties and methods, we can change the MemberType value to either Property or Method. Let's execute the following code:

Get-Date | Get-Member -MemberType Property -Force

The output of this code is illustrated as follows:

The definitions of the property is shown as {get;}. Let's explore the property now, as follows:

(Get-Date).DateTime

The command that we just considered displays the current date and time of the local machine.

Now, let's take a look at how the command that we just discussed works, in the following list:

Alternatively, we can use the DateTime object, as follows:

[DateTime]::Now

We will get current date and time as output. For example, Tuesday, June 02, 2015 12:15:51 PM.

The operator used here is the static member operator, ::.

To invoke the methods of an object, we will follow the same procedure. But, if the method needs arguments, we need to pass it accordingly, as shown in the following command:

Get-Date | Get-Member -MemberType Method –Force

Execute the following code:

(Get-Date).AddDays(1)

Here, we added one day to the current day and the output is as follows:

Wednesday, June 03, 2015 12:55:35 PM

Alternatively, we can write ([DateTime]::Now).AddDays(1).

The $psISE object is the root object of the Integrated Scripting Environment. Using this we can toggle settings of the ISE, as follows:

$psISE | GM -Force

The output of the command we just discussed retrieves all the members of $PSISE. One of the property options that hold all the options of the ISE is as follows:

$psISE.Options

To modify the zoom, use the following code:

$psISE.Options.Zoom = 150

To modify the Intellisense timeout seconds, we execute the following code:

$psISE.Options.IntellisenseTimeoutInSeconds = 5

To change the script pane's background color, we execute the following code:

$psISE.Options.ScriptPaneBackgroundColor = 'Green'

A Windows PowerShell pipeline is used to join two or more statements with a pipeline operator. The Pipeline operator is '|'.

We have used pipelines in previous examples; let's know about pipeline use case scenario.

In this section, we will cover the following:

Windows PowerShell is designed to use pipeline. Here's an example of pipelines:

Command1 | Command2 | Command3

Here, Command1 sends the object to Command2; the processed object will then be sent to Command3, which will output the results. Take a look at the following command:

help about_Pipelines -ShowWindow

A pipeline works in the following way:

Now, let's take a look at the following example:

PS C:\> Get-Service -Name BITS
Status   Name               DisplayName                           
------   ----               -----------                           
Running  BITS               Background Intelligent Transfer Ser...

The Get-Service cmdlet gets the object representing the BITS service.

Using the Stop-Service cmdlet, we can stop the service. The -Verbose parameter is to show the operation handled, as shown in the following code:

Get-Service -Name BITS | Stop-Service -Verbose

The output of the command we just discussed is illustrated in the following image:

Using pipeline, we can do many more tasks, such as sorting, grouping, looping, and so on.

How do we find the parameter that accepts pipeline? Using help and pipeline, we can do this as shown in the following code:

help Get-Service -Parameter * | Select name , PipelineInput

The output of the command we just discussed is illustrated in the following image:

To retrieve the Windows services of the remote machine, SharePoint001, we can write the command as follows:

'SharePoint001' | %{Get-Service -ComputerName $_}

In short, the pipeline passes the output to another command so that the next command has something to work with or simply connects the output to other commands. This helps IT professionals automate tasks such as inventorying, reporting, and so on.

Exporting a running process to a CSV file

Let's take a look at the following command:

Get-Process | Export-csv C:\Temp\Process.csv `
-NoTypeInformation -Encoding UTF8

Refer to the following image:

The points marked in the image are explained as follows:

• 1: The Get-Process cmdlet is used to retrieve a running process in your local machine. Alternatively, the gps alias can be used

• 2: This is the pipeline operator used to pass the output to the next command

• 3: The Export-csv cmdlet is used to save the output in the CSV format

• 4: This is the complete path of the output file

• 5: This is the PowerShell line continuation character

• 6: The NotypeInformation switch parameter is used to avoid #TypeInformation in the CSV header

• 7: The Export-CSV cmdlet has an encoding parameter, which can be ASCII, UTF7, UTF8, BigEndianUnicode, OEM, or so on

The CSV output is shown in following image:

I prefer to export data in the XML format using the Export-Clixml cmdlet because it holds a lot more information. Take a look at the following command:

Get-Process | Export-Clixml C:\Temp\Process.xml

The output is shown in the following image:

Using Import-Clixml and Import-Csv, we can view the output we exported:

Import-Clixml C:\Temp\Process.xml

The output of the command we just discussed is shown in the following image:

Using pipelines, we can connect multiple commands and get effective solutions, as explained in the following list:

• We can start, stop, or set a service

• We can export the output to report, for inventories, and so on.

• They connect commands and display the output as required

• They help in sorting, filtering, and formatting objects

In Windows PowerShell, filtering and formatting are used in most places to get the output in the desired format. Select-Object is very useful cmdlet to filter.

In this section, we will cover the following topics:

Consider the following command:

Get-Command -Noun Object

The output is as shown in the following image:

Use the following Help commands:

Help Select-Object -Examples
Help Where-Object -Examples

Using the Select-Object cmdlet, we can select the first and last n items from the collection of objects. The Select-Object cmdlet can be used to retrieve only unique values (ignoring duplicates).

Now, let's explore Select-Object for filtering. Let's consider that we have a set of objects from 65 to 90; to select the first 10, we need to pipe and use Select-Object, as shown in the following command:

65..90 | Select -First 10

We will get the output as 65 to 74.

Consider the following command:

1,2,2,3 | Select -Unique

Here, we will get the output as 1, 2, and 3.

Take a look at the following command:

1,2,2,3 | Select -Last 1 

Here, we will get the output as 3.

Consider the following command:

1,2,2,3 | Select -SkipLast 1 

We will get the output as 1, 2, and 2.

Take a look at the following command:

1,2,2,3 | Select -Skip 2  

Here, we will get the output as 2 and 3.

To get help for all the parameters in Select-Object, use the following code:

help Select-Object -Parameter *

The Where-Object cmdlet is used to filter data returned by the other cmdlet. This cmdlet accepts comparison operators.

Let's explore the syntax of the Where-Object cmdlet, as follows:

(help Where-Object).Syntax

The output of the command we just considered is illustrated in the following image:

Consider an array from 1 to 5. To select values greater than 3, we use the Where-Object alias, ?, next to the pipeline operator, as shown in the following command:

1..5 | ? {$_ -gt 3}

From Windows PowerShell 4.0 onward, we can avoid pipelines for the ForEach and Where objects, as follows:

(65..90).ForEach({[char][int]$_})

The output of the code we just discussed is shown in the following image:

Now, let's take a look at how this works in the following list:

Now, let's take a look at the following code:

(1..10).Where({$_ -ge 5})

The output of this code is shown in the following image:

Now, let's take a look at how this works in the following list:

We can use the Where statement with different modes. In the following example, we will select the first three values, where the number is greater than or equal to 5. Now, let's consider the following code:

(1..10).Where({$_ -ge 5}, 'First' , 3)

The output of this code is illustrated in the following image:

Now, let's take a look at how this works in the following list:

Similarly, we can use the Split mode as well. Using this, we can split the given collection of objects, as shown in the following code:

$section1 , $section2 = (1..100).Where({$_ -le 50} , 'Split' , 0)
$section1
$section2

The $section1 variable contains values from 1 to 50, and the $section2 variable contains values from 51 to 100.

Here is a table comparing commands using pipeline with those that don't use a pipeline:

PowerShell formatting

Windows PowerShell has a set of cmdlets that allows us to format the output. To find the cmdlets to format, use Verb Format to search, as shown in the following code:

Get-Command -Verb Format

Let's take a look at the default formatting of Windows PowerShell by executing the following the cmdlet:

Get-Process | Select –First 5

The output of this code is as follows:

The headers are not exactly property names. This formatting is done using the file name, DOTNETTYPES.FORMAT.PS1XML.

The location of the file is $PSHome. Take a look at the following image:

The following list explains the points marked in the preceding image:

• 1: The type name of Get-Process is System.Diagnostics.Process

• 2: For NPM(K), refer to the image preceding the previous image

• 3: For PM(K), refer to the image preceding the previous image

The first thing we see in the XML file is the following warning:

Do not edit or change the contents of this file directly. Please see the Windows PowerShell documentation or type.

Use the following command to obtain more information:

Get-Help Update-TypeData

So, let's not make any kind of modifications. Instead, let's take a look at the cmdlets to make minor modifications as desired, as shown in the following image:

In the following example, we will use the Where method to select n items required to keep the output precise and short.

The help command to format the table is as follows:

help Format-Table -ShowWindow

Let's select the first five running services and format them as follows:

(Get-Service).Where({$_.Status -eq 'Running'},'First',5) | Format-Table

This code outputs the default formatting.

Using the Format-Table cmdlet, we can hide the headers, auto size the table, use the expression, and much more. Let's consider the following command:

(Get-Service).Where({$_.Status -eq 'Running'},'First',5) | Format-Table -HideTableHeaders

The output of the command we just discussed is shown in the following image:

The default formatting of Windows PowerShell is not great, but it allows us to customize the format as required. The report we deliver to IT Management should be precise and readable. Using Windows PowerShell, we can achieve this.

Reports can be in the HTML, XML, CSV, or other desired formats.

Using an expression is allowed in Format-Table inside the {} script block token. Run the following command:

Get-WmiObject -Class Win32_LogicalDisk -Filter "DriveType=3" | 
Format-Table Name,@{n="Freespace(byte)";e={"{0:N0}" -f $_.FreeSpace};a="center"} 

The following image shows all three alignments: left, right, and center:

Here is another example of a command to format the date in the day/month/year format using a format operator:

"Custom Date Format: {0},{1},{2}" -F (Get-Date).Day , (Get-Date).Month , (Get-Date).Year

To view the LastWriteTime.DayOfWeek file, run the following command:

Get-ChildItem C:\Temp | Ft name , @{n="Day of Week" ; E = {$_.LastWriteTime.DayOfWeek}}

The following is the command to custom format using the Format-Custom cmdlet:

Get-Service | Format-Custom

The default output of the command we just discussed is as follows:

Use the Get-FormatData cmdlet to view the formatting data from the Format.ps1xml formatting files. In this demo, we will try to customize the default format in the current session, as follows:

help Get-FormatData -ShowWindow
help Export-FormatData -ShowWindow
help Update-FormatData -ShowWindow

Perform the following steps:

Note

In this demo, we will change the column header to test. This will break the output ONLY in the current session.

1. Identify the type name of the command. For example, here, we will use the Get-Process | GM command.

2. The TypeName parameter is System.Diagnostics.Process, as shown in the following command:

   Get-FormatData -TypeName System.Diagnostics.Process | 
   Export-FormatData -Path C:\Temp\TestView.Format.PS1XML 
   

3. Now, append the text of the column header in the PS1XML file in the Temp folder, as shown in the following command:

   Update-FormatData -PrependPath C:\Temp\TestView.Format.PS1XMl
   

4. The Get-Process command returns the output as shown in the following image:

   

Exploring snippets in the PowerShell ISE

There is a cool way in the PowerShell ISE to reduce typing; however, before discussing PowerShell scripting, let's take a look at snippets.

Snippets are nothing but commonly used code. In PowerShell, we very often use functions, advanced functions, comment blocks, and so on.

Using an ISE, we don't type out the structure of the function. Instead, we can right-click on Script Pane and select Start Snippets or press Ctrl + J. This shows a menu of the available snippets.

The following image illustrates the snippets in the PowerShell ISE:

We need not be limited to only the available snippets; we can create our own snippets. In this demo, we will try to create a snippet. This is a simple snippet to add a mandatory parameter, which we can reuse in any of our functions.

This helps developers and IT professionals do the scripting faster.

There is no need for more typing; we just need to add a snippet wherever we need reusable codes, as shown in the following code:

$m = @'
Param(
[Parameter(Mandatory=$true)]
[String]
$String
)
'@
New-IseSnippet -Text $m -Title Mandatory -Description 'Adds a Mandatory function parameter' -Author "Chen V" -Force

Let's take a look at how this works:

• The $m variable holds the skeleton code

• The New-IseSnippet command is the one available in the module's ISE

• We used a few parameters with Text , which is the skeleton code; Title, which can be any friendly name; Description, which describes the snippet in short; and Author, which is the author's name

• After the code is executed, it creates a PS1XML file in the location, $home\Documents\WindowsPowerShell\Snippets\

• The file name will be your title—in this case it's Mandatory.Snippets.PS1XML

Note

We can copy and place it any machine—pressing Ctrl + J will show Mandatory in the snippets.

The following image illustrates the output of the newly created snippet:

The following are the steps that explain the points marked in the preceding image:

• 1: The name Mandatory is the title of our new snippet

• 2: The Description field is shown in the pop-up box

• 3: The Path field is the path of the PS1XML file

• 4: This is the snippet code or skeleton code

Let's take a look at scripting in the cmdlet style.

We've arrived at a place from where we can explore PowerShell scripting with the knowledge of the previous topics. Wait! We haven't covered all that we need for scripting in PowerShell. Before we begin discussing scripting, we should know more about the scripting principles, using variables, commenting, writing help, and so on.

Here are a few principles of scripting:

If you want to deliver scripts to your organization or community, it's good to create the variables and follow the standard naming conventions. Do not use plain text passwords in the scripts, and avoid technical jargon in the comment blocks. Ensure that the script is readable for others.

Using Windows PowerShell scripting, we can perform complex tasks with the help of imperative commands. The scripting language supports branching, variables, and functions.

From now on, we will use the PowerShell ISE for its ease of use and benefits.

In this section, we will cover the following topics:

Let's now discuss using variables.

A variable is used to store information, and it is the result of a running script.

Here's an example:

$value = Read-Host "Enter Value 1"

This script prompts for user input; once the value is entered, it stores it in the $value variable, as shown in the following image:

Using the New-Variable cmdlet, a variable can be created along with a scope definition. In the following example, let's create a variable name, ws, which holds the value of the Windows service, and sets the scope to Global:

New-Variable -Name 'ws' -Value (Get-Service) -Scope Global

Using Remove-Variable, it can be removed, as shown in the following code:

Remove-Variable -Name ws -Verbose

Windows PowerShell scripting is used to automate your daily tasks. It may be anything such as reporting, server health checkup, performing tasks such as restarting services, stopping services, deploying solutions, installing Windows features, and much more.

The following points need to be considered while creating PowerShell scripting:

Let's write a simple script that prints hello world on the screen:

#Windows PowerShell Script to Retrieve Windows Services
Write-Host "Hello, World!" -ForegroundColor Green

To run the PowerShell script, you need to call the script using a dot (.) operator followed by backward (\) slash.

The extension of the PowerShell script file should be .PS1.

The output of the preceding code is illustrated in the following image:

Let's create a script that does a basic system inventory.

This PowerShell script will create a CSS file for styles, query the basic system information, convert to an HTML file, and open up after the script is completely executed, as shown in the following code:

$UserName = (Get-Item  env:\username).Value 
$ComputerName = (Get-Item env:\Computername).Value
$filepath = (Get-ChildItem env:\userprofile).value
Add-Content  "$Filepath\style.CSS"  -Value " body {
font-family:Calibri;
 font-size:10pt;
}
th { 
background-color:black;
color:white;
}
td {
 background-color:#19fff0;
color:black;
}"
Write-Host "CSS File Created Successfully... Executing Inventory Report!!! Please Wait !!!" -ForegroundColor Yellow 
#ReportDate
$ReportDate = Get-Date | Select -Property DateTime |ConvertTo-Html -Fragment
#General Information
$ComputerSystem = Get-WmiObject -Class Win32_ComputerSystem | 
Select -Property Model , Manufacturer , Description , PrimaryOwnerName , SystemType |ConvertTo-Html -Fragment
#Boot Configuration
$BootConfiguration = Get-WmiObject -Class Win32_BootConfiguration |
Select -Property Name , ConfigurationPath | ConvertTo-Html -Fragment
#BIOS Information
$BIOS = Get-WmiObject -Class Win32_BIOS | Select -Property PSComputerName , Manufacturer , Version | ConvertTo-Html -Fragment
#Operating System Information
$OS = Get-WmiObject -Class Win32_OperatingSystem | Select -Property Caption , CSDVersion , OSArchitecture , OSLanguage | ConvertTo-Html -Fragment
#Time Zone Information
$TimeZone = Get-WmiObject -Class Win32_TimeZone | Select Caption , StandardName |
ConvertTo-Html -Fragment
#Logical Disk Information
$Disk = Get-WmiObject -Class Win32_LogicalDisk -Filter DriveType=3 |
Select SystemName , DeviceID , @{Name="size(GB)";Expression={"{0:N1}" -f($_.size/1gb)}}, @{Name="freespace(GB)";Expression={"{0:N1}" -f($_.freespace/1gb)}} |
ConvertTo-Html -Fragment
#CPU Information
$SystemProcessor = Get-WmiObject -Class Win32_Processor  | 
Select SystemName , Name , MaxClockSpeed , Manufacturer , status |ConvertTo-Html -Fragment
#Memory Information
$PhysicalMemory = Get-WmiObject -Class Win32_PhysicalMemory |
Select -Property Tag , SerialNumber , PartNumber , Manufacturer , DeviceLocator , @{Name="Capacity(GB)";Expression={"{0:N1}" -f ($_.Capacity/1GB)}} | ConvertTo-Html -Fragment
#Software Inventory
$Software = Get-WmiObject -Class Win32_Product |
Select Name , Vendor , Version , Caption | ConvertTo-Html -Fragment
ConvertTo-Html -Body "<font color = blue><H4><B>Report Executed On</B></H4></font>$ReportDate
<font color = blue><H4><B>General Information</B></H4></font>$ComputerSystem
<font color = blue><H4><B>Boot Configuration</B></H4></font>$BootConfiguration
<font color = blue><H4><B>BIOS Information</B></H4></font>$BIOS
<font color = blue><H4><B>Operating System Information</B></H4></font>$OS
<font color = blue><H4><B>Time Zone Information</B></H4></font>$TimeZone
<font color = blue><H4><B>Disk Information</B></H4></font>$Disk
<font color = blue><H4><B>Processor Information</B></H4></font>$SystemProcessor
<font color = blue><H4><B>Memory Information</B></H4></font>$PhysicalMemory
<font color = blue><H4><B>Software Inventory</B></H4></font>$Software" -CssUri  "$filepath\style.CSS" -Title "Server Inventory" | Out-File "$FilePath\$ComputerName.html"
Write-Host "Script Execution Completed" -ForegroundColor Yellow
Invoke-Item -Path "$FilePath\$ComputerName.html"

The output of this code is illustrated in the following image:

Let's take a look at how to write PowerShell functions with comments:

<#
.Synopsis
  To add two integer values
.DESCRIPTION
  Windows PowerShell Script Demo to add two values
  This accepts pipeline values
.EXAMPLE
  Add-Values -Param1 20 -Param2 30
.EXAMPLE
  12,23 | Add-Values
#>
function Add-Values
{
    [CmdletBinding()]
    [Alias()]
    [OutputType([int])]
    Param
    (
        # Param1 help description
        [Parameter(Mandatory=$true,
            ValueFromPipeline = $true,
            ValueFromPipelineByPropertyName=$true,
            Position=0)]
        #Accepts Only Integer
        [int]$Param1,
        #Accepts only integer
        [Parameter(Mandatory=$true,
            ValueFromPipeline = $true,
            ValueFromPipelineByPropertyName=$true,
            Position=0)]
        [int]$Param2
    )
    Begin
    {
        "Script Begins"
    }
    Process
    {
        $result = $Param1 + $Param2
    }
    End
    {
        $result
    }
}

This is not a good script, but I will use this to demonstrate a PowerShell function with comments in order to help explore the use of help.

The following is an explanation of how this code works:

To execute this script, we need to use the .\Filename.PS1 command. Take a look at the following image:

The following is an explanation of the steps marked in the image we just considered:

To view only the examples, we will use the following command:

Get-Help Add-Values -Examples

The output of this code is illustrated in the following image:

The following is an explanation of the points marked in the preceding image:

Similarly, we can view only parameters. The help description given above each parameter appears using the following code:

Get-Help Add-Values -Parameter * 

Take a look at the following image:

The following are a few commands that use the help command:

help about_Functions
help about_Functions_Advanced_Methods    
help about_Functions_Advanced_Parameters 
help about_Functions_CmdletBindingAttribute
help about_Functions_OutputTypeAttribute 

Let's take a look at how to write advanced functions.

Advanced functions are similar to compiled cmdlets but not exactly the same.

Here is a table comparing advanced functions and compiled cmdlets:

In this section, we will discuss both writing an advanced function code using the PowerShell ISE and a compiled cmdlet using the Visual Studio C# class library.

Let's take a look at how to create a compiled cmdlet using the Visual Studio C# class library. Execute the following code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management;
using System.Management.Automation;
using System.IO;
namespace Windows_Management
{
    [Cmdlet(VerbsCommon.Clear, "TemporaryInternetFiles")]
    public class WindowsManagement : PSCmdlet
    {
        protected override void ProcessRecord()
        {
            //Delete Internet Cache Files and Folders
            string path = Environment.GetFolderPath(Environment.SpecialFolder.InternetCache);
            Console.ForegroundColor = ConsoleColor.DarkYellow;
            Console.WriteLine("Clearing Temporary Internet Cache Files and Directories....." + path);
            System.IO.DirectoryInfo folder = new DirectoryInfo(path);
            foreach (FileInfo files in folder.GetFiles())
            {
                try
                {
                    files.Delete();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex);
                }
            }
            foreach (DirectoryInfo Directory in folder.GetDirectories())
            {
                try
                {
                    Directory.Delete();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex);
                }
            }
            Console.WriteLine("Done Processing!!!");
            Console.ResetColor();
        }
    }
}
namespace clearInternetexplorerHistory
{
    [Cmdlet(VerbsCommon.Clear, "IEHistory")]
    public class clearInternetexplorerHistory : PSCmdlet
    {
        protected override void ProcessRecord()
        {
            // base.ProcessRecord();
            string path = Environment.GetFolderPath(Environment.SpecialFolder.History);
            Console.ForegroundColor = ConsoleColor.DarkYellow;
            Console.WriteLine("Clearing Internet Explorer History....." + path);
            System.IO.DirectoryInfo folder = new DirectoryInfo(path);
            foreach (FileInfo files in folder.GetFiles())
            {
                try
                {
                    files.Delete();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex);
                }
            }
            foreach (DirectoryInfo Directory in folder.GetDirectories())
            {
                try
                {
                    Directory.Delete();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex);
                }
            }
            Console.WriteLine("Done Processing!!!");
            Console.ResetColor();
        }
    }
}
namespace UserTemporaryFiles
{
    [Cmdlet(VerbsCommon.Clear, "UserTemporaryFiles")]
    public class UserTemporaryFiles : PSCmdlet
    {
        protected override void ProcessRecord()
        {
            //base.ProcessRecord();
            string temppath = System.IO.Path.GetTempPath();
            System.IO.DirectoryInfo usertemp = new DirectoryInfo(temppath);
            Console.WriteLine("Clearing Your Profile Temporary Files..." + temppath);
            foreach (FileInfo tempfiles in usertemp.GetFiles())
            {
                try
                {
                    tempfiles.Delete();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex);
                }
            }
            Console.WriteLine("Done Processing!!!");
            foreach (DirectoryInfo tempdirectory in usertemp.GetDirectories())
            {
                try
                {
                    tempdirectory.Delete();
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex);
                }
            }
        }
    }
}

Once the DLL is compiled, we can import it as a module in Windows PowerShell.

The output of the command we just discussed is illustrated in the following image:

Now, let's consider the advanced functions in Windows PowerShell.

Advanced functions are more robust, can handle errors, support verbose and dynamic parameters, and so on.

Let's take a look at the small advanced functions used to retrieve system information, as follows:

function Get-SystemInformation
{
    [CmdletBinding()]
    [Alias()]
    [OutputType([int])]
    Param
    (
        # Param1 help description
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   ValueFromPipeline = $true,
                   HelpMessage = "Enter Valid Host Names",
                   Position=0)]
        [Alias('Host')]
        [ValidateCount(0,15)]
        [String[]]$ComputerName,
        # Param2 help description
        [int]
        $Param2
    )
    Begin
    {
    }
    Process
    {
        foreach($cn in $ComputerName)
        {
            $cs = Get-CimInstance -ClassName Win32_ComputerSystem -ComputerName $cn 
            $baseboard = Get-CimInstance -ClassName Win32_BaseBoard -ComputerName $cn
            $properties = New-Object psobject -Property @{
            ComputerName = $cs.Caption
            Model = $cs.Model
            ComputerOwner = $cs.PrimaryOwnerName
            Bootupsate = $cs.BootupState
            BaseBoardSerialNumber = $baseboard.SerialNumber
            BaseBoardManufacturer = $baseboard.Manufacturer
            }
            $properties
        }
    }
    End
    {
    }
}
'localhost' , 'localhost' | %{Get-SystemInformation -ComputerName $_} 

The output of the code we just discussed is illustrated in the following image:

As we have already covered the topic of adding help for PowerShell functions, I ignored it in the advanced functions section. Remember, we do have snippets in the ISE to create advanced functions. It's simple; just right-click on the script pane, select Start snippet, and then choose the Advanced function complete option.

Start documenting the synopsis, description, and help for parameters and build your code in the process block. This is very easy and handy to build advanced scripts using PowerShell.

Before building scripts, use the Measure-Command cmdlet and think about optimization. This will help in performance.