{"id":11531,"date":"2012-01-09T00:01:00","date_gmt":"2012-01-09T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2012\/01\/09\/increase-your-productivity-by-using-the-powershell-pipeline\/"},"modified":"2012-01-09T00:01:00","modified_gmt":"2012-01-09T00:01:00","slug":"increase-your-productivity-by-using-the-powershell-pipeline","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/increase-your-productivity-by-using-the-powershell-pipeline\/","title":{"rendered":"Increase Your Productivity by Using the PowerShell Pipeline"},"content":{"rendered":"

Summary<\/b>: Microsoft Scripting Guy, Ed Wilson, teaches you how to use the Windows PowerShell pipeline to increase your productivity and to avoid writing scripts.<\/p>\n

\"Hey,<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span> Hey, Scripting Guy! I keep hearing about the pipeline <\/i>in Windows PowerShell, but I do not get it. I see commands, but I am not sure what they are actually doing. In addition, why do I need to use a pipeline <\/i>in the first place? Surely, I can store stuff in variables, and use the ForEach<\/b> <\/i>command to walk through collections. I just don’t get it. I guess you can tell that I am an old VBScripter, <\/i>and I guess old habits are hard to break. But really, what’s up with the pipeline?<\/i><\/p>\n

—DG<\/p>\n

\"Hey,<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span> Hello DG,<\/p>\n

Microsoft Scripting Guy, Ed Wilson, is here. Well, this new year is already shaping up to be an exciting one. The Scripting Wife and I are hard at work on a new series of Scripting Wife blogs in preparation for the 2012 Scripting Games. This year’s games will be the biggest and the best ever. I have been talking to various presidents of Windows PowerShell Users Groups from around the world, and I plan to work with them to help them get their groups up to speed for this year’s games. If you are not a member of a Windows PowerShell user group, check the Windows PowerShell Group website to see if there is one near you. If there is not one, and if you would like to start one where you live, contact me via the scripter@microsoft.com<\/a> email address, and I will help point you in the right direction. <\/p>\n

Anyway, DG, you are not the first person to ask me about pipelines in Windows PowerShell. For people who approach Windows PowerShell from a strictly VBScript background, or even from a strict Windows background, the idea of a pipeline is somewhat foreign. At times, the process seems to work seamlessly, and at other times, it does not work at all. In some cases, the command appears to make sense, but in other cases, it does not make sense. And often there is neither rhyme, nor is there reason to the syntax and the commands themselves.<\/p>\n

A basic example of a pipeline<\/h2>\n

A good way to see a pipeline in action is to create an instance of the Notepad<\/b> <\/i>process, retrieve the newly created process, and stop that process. To start a new instance of the Notepad<\/b> <\/i>process, I use the Start-Process <\/b>cmdlet. I then use Get-Process <\/b>to retrieve the process object, and I pipe the object to the Stop-Process <\/b>cmdlet.<\/p>\n

Start-Process notepad<\/p>\n

Get-Process notepad | Stop-Process<\/p>\n

What happens under the covers is that the process object that is retrieved by the Get-Process <\/b>cmdlet, is sent to the InputObject <\/i>parameter of the Stop-Process <\/b>cmdlet. The Stop-Process <\/b>cmdlet then stops each process contained in the process object that comes across the pipeline. If we did not have the pipeline in Windows PowerShell, I would perform this operation, exactly the same as I did in the VBScript days…I would store the objects in a variable, and pass the variable to the InputObject <\/i>parameter of the Stop-Process <\/b>cmdlet. This technique is shown here:<\/p>\n

Start-Process notepad<\/p>\n

$notepad = Get-Process notepad<\/p>\n

Stop-Process -InputObject $notepad<\/p>\n

Examining the pipeline mechanics<\/h2>\n

I can confirm that the process object passes to the InputObject <\/i>parameter by using the Trace-Command <\/b>cmdlet.<\/p>\n

Note<\/b>: Microsoft MVP and Honorary Scripting Guy<\/a>, Don Jones, reminded me about using this cmdlet in his great column, PowerShell with a Purpose<\/a>. (I had not played with it much since I wrote my book, Windows PowerShell 2.0 Best Practices<\/a>). <\/i><\/p>\n

To use the Trace-Command <\/b>cmdlet to display ParameterBinding <\/i>information, I specify ParameterBinding <\/i>to the Name<\/b> <\/i>property—that is the name of the command that I want to trace. I use the PSHost <\/i>switched parameter to tell the cmdlet to monitor the Windows PowerShell host, and I then specify the Expression<\/b> <\/i>I want to trace. The Expression<\/b> goes into a script block (delimited by a pair of curly brackets). The complete command is shown here.<\/p>\n

Trace-Command -Name parameterbinding -PSHost -Expression {get-process notepad | stop-process}<\/p>\n

The command to trace the parameter binding of the Get-Process<\/b> command as it is piped to the Stop-Process<\/b> cmdlet, along with the output associated with this command is shown in the image that follows.<\/p>\n

 \"Image<\/a><\/p>\n

Using different cmdlets in the pipeline<\/h2>\n

A number of cmdlets typically combine with other cmdlets to assist in working with objects on the pipeline. These cmdlets accept input via the pipeline, and then they perform services such as grouping, sorting, or filtering the information that comes through the pipeline, before they pass the input to other cmdlets. These cmdlets are:<\/p>\n