{"id":53,"date":"2009-02-07T22:37:19","date_gmt":"2009-02-08T05:37:19","guid":{"rendered":"http:\/\/jameskovacs.com\/2009\/02\/08\/PowerShell+Processes+And+Piping"},"modified":"2009-02-07T22:37:19","modified_gmt":"2009-02-08T05:37:19","slug":"powershell-processes-and-piping","status":"publish","type":"post","link":"https:\/\/www.jameskovacs.com\/index.php\/2009\/02\/07\/powershell-processes-and-piping\/","title":{"rendered":"PowerShell, Processes, and Piping"},"content":{"rendered":"

Last time<\/a>, I discussed why you as a developer might be interested in PowerShell and gave you some commands to start playing with. I said we\u2019d cover re-usable scripts, but I\u2019m going to delay that until next post as I want to talk more about life in the shell\u2026<\/p>\n

PowerShell feels a lot like cmd.exe, but with a lot more flexibility and power. If you\u2019re an old Unix hack like me, you\u2019ll appreciate the ability to combine (aka pipe) commands together to do more complex operations. Even more powerful than Unix command shells is the fact that rather than inputting\/outputting strings as Unix shells do, PowerShell inputs and outputs objects. Let me prove it to you\u2026<\/p>\n

    \n
  1. At a PowerShell prompt, run \u201cget-process\u201d to get a list of running processes. (Remember that PowerShell uses single nouns for consistency.)<\/li>\n
  2. Use an array indexer to get the first process: \u201c(get-process)[0]\u201d (The parentheses tell PowerShell to run the command.)<\/li>\n
  3. Now let\u2019s get really crazy\u2026 \u201c(get-process)[0].GetType().FullName\u201d<\/li>\n<\/ol>\n

    As a .NET developer, you should recognize \u201c.GetType().FullName\u201d. You\u2019re getting the class object (aka System.Type) for the object returned by (get-process)[0] and then asking it for its type name. What does this command return?<\/p>\n

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

    That\u2019s right! The PowerShell command, get-process, returns an array of System.Diagnostics.Process objects. So anything you can do to a Process object, you can do in PowerShell. To figure out what else we can do with a Process object, you can look up your MSDN docs or just ask PowerShell itself.<\/p>\n

    get-member \u2013inputObject (get-process)[0]<\/p>\n

    Out comes a long list of methods, properties, script properties, and more. Methods and properties are the ones defined on the .NET object. Script properties, alias properties, property sets, etc. are defined as object extensions by PowerShell to make common .NET objects friendlier for scripting.<\/p>\n

    Let\u2019s try something more complex and find all processes using more than 200MB of memory:<\/p>\n

    get-process | where { $_.PrivateMemorySize \u2013gt 200*1024*1024 }<\/p>\n

    Wow. We\u2019ve got a lot to talk about. The pipe (|) takes the objects output from get-process and provides them as the input for the next command, where \u2013 which is an alias for Where-Object. Where requires a scriptblock denoted by {}, which is PowerShell\u2019s name for a lambda function (aka anonymous delegate). The where command evaluates each object with the scriptblock and passes along any objects that return true. $_ indicates the current object. So we\u2019re just looking at Process.PrivateMemorySize for each process and seeing if it is greater than 200 MB.<\/p>\n

    Now why does PowerShell use \u2013gt, \u2013lt, \u2013eq, etc. for comparison rather than >, <, ==, etc.? The reason is that for decades shells have been using > and < for input\/output redirection. Let\u2019s write to the console:<\/p>\n

    \u2018Hello, world!\u2019<\/p>\n

    Rather than writing to the console, we can redirect the output to a file like this:<\/p>\n

    \u2018Hello, world!\u2019 > Hello.txt<\/p>\n

    You\u2019ll notice that a file is created called Hello.txt. We can read the contents using Get-Content (or its alias, type).<\/p>\n

    get-content Hello.txt<\/p>\n

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

    Since > and < already have a well-established use in the shell world, the PowerShell team had to come up with another syntax for comparison operators. They turned to Unix once again and the test command. The same operators that have been used by the Unix test command for 30 years are the same ones as used by PowerShell.*<\/p>\n

    So helpful tidbits about piping and redirection\u2026<\/p>\n