{"id":8448,"date":"2014-12-15T06:00:44","date_gmt":"2014-12-15T14:00:44","guid":{"rendered":"http:\/\/www.sapien.com\/blog\/?p=8448"},"modified":"2016-05-25T10:59:57","modified_gmt":"2016-05-25T17:59:57","slug":"display-output-in-a-gui-application-copy","status":"publish","type":"post","link":"https:\/\/dev.sapien.com\/blog\/2014\/12\/15\/display-output-in-a-gui-application-copy\/","title":{"rendered":"Displaying Output in a GUI Application"},"content":{"rendered":"

After many years of writing scripts for the Windows PowerShell console, I’m now learning the next level of automation — writing GUI applications that run Windows PowerShell commands. PowerShell Studio forms provide a gentle and well-guided introduction to GUI applications, but it’s still taken me some time to break old habits.<\/p>\n

I constantly need to remind myself that things that “just work” in the console don’t make any sense in a GUI. Writing output is one of them.<\/p>\n

Writing Output to the Console<\/h3>\n

When you generate output in the Windows PowerShell console, the output appears as text strings in the console window.<\/p>\n

PS C:> Get-Date\r\nWednesday, December 3, 2014 7:16:38 AM<\/pre>\n
Behind the scenes, Windows PowerShell silently appends an Out-String<\/b><\/a> <\/b>command to the pipeline and sends the results to “standard output” (“stdout”). The process that hosts Windows PowerShell handles the standard output, almost always by writing the output to the console (host behavior might vary).<\/p>\n
So, if you run a cmdlet that returns objects, such as the Get-Process <\/b>cmdlet, (string representations of) the objects appear in the console.<\/p>\n
If you format objects, such as by using Format-List<\/b> or Format-Table<\/b>, (string representations of) the formatted objects appear in the console.<\/p>\n
If you run Write-Host<\/b> or Write-Output<\/b>, Out-Host<\/b> or Out-String<\/b>, the output strings appears in the console.<\/p>\n
And even if you send the output to an alternate output stream by using Write-Warning<\/b>, Write-Verbose<\/b>, or Write-Error<\/b>, by default, the output appears in the console.<\/p>\n
But GUI application don’t have a console. What happens to the output that would otherwise go to the console when there is no console? And, more importantly, how do I manage output without a console?<\/p>\n
<\/h4>\n
Where is my output?<\/h3>\n
GUI applications, like the cool ones that you write in PowerShell Studio, don’t have a console. There is no standard output. There is no auto-appended Out-String<\/b><\/a>.<\/p>\n
So, when you generate output and don’t save it to a file or a variable, the output is just lost.<\/p>\n
Get-Process | ... <Nowhere> ...<\/pre>\n
It’s like a pitcher throwing a baseball when there’s no catcher on the field. The ball just falls to the ground and rolls to a stop .. ignored.<\/p>\n
\"clip_image002\"<\/a><\/p>\n
So, in a GUI application, you can’t just write output and hope for the best. If you want to display cmdlet output or save it, you need to do it explicitly.<\/p>\n
Display output in a text box<\/h3>\n
A GUI application is a collection of controls. To display output, you need to assign the output to a control, such as text box, rich text box, or a data grid.<\/p>\n
For example, to display the name of the local computer in the console, you run an $env:ComputerName command.<\/p>\n
PS C:> $env:ComputerName\r\nJUNEB-TESTBOX<\/pre>\n
When I try the same thing in a GUI application where there is no console, I don’t see any result at all. In this example, I created a form with a button that, when clicked, runs the $env:ComputerName expression.<\/p>\n
$buttonComputerName_Click = {\r\n    $env:ComputerName<\/b>\r\n}<\/pre>\n
But, when I click the button, nothing happens, even if I have a console window open.<\/p>\n
\"GetComputerName\"<\/a><\/p>\n
To display the computer name in a GUI application, I add a display control to my form and assign the output of the command to a method of the display control.<\/p>\n
For example, I can add a Textbox<\/b> control to the form and use the assignment operator (=) to assign the result of the expression to the Text<\/b> property of the TextBox. Now, when you click the button, you see the output in the TextBox.<\/p>\n
$buttonComputerName_Click = {\r\n    $textboxResults.Text = $env:ComputerName\r\n}<\/pre>\n
Here’s the result:<\/p>\n
\"GetComputerName2\"<\/a><\/p>\n
Display Output in a Different Program<\/h3>\n
You can also display the output of commands in objects that are not part of your program. GUI professionals think that this approach is sloppy and not a best practice, but you might find it useful for testing or debugging.<\/p>\n
For example, you can pipe the output to the Out-GridView<\/b> cmdlet.<\/p>\n
$buttonComputerName_Click = {\r\n    $env:ComputerName | Out-GridView\r\n}<\/pre>\n
Here’s the result:<\/p>\n
\"JuneTestBox\"<\/a><\/p>\n
You can also write to a file and open the file. These sample commands create a temporary file, write to the file, and then use Notepad to display the file. Again, this makes real programmers cringe, but it works, at least for testing.<\/p>\n
$buttonComputerName_Click = {\r\n    $TmpFile = [System.IO.Path]::GetTempFileName\r\n    $env:COMPUTERNAME | Set-Content -Path $TmpFile\r\n    Notepad $TmpFile\r\n}<\/pre>\n
Here’s the result:<\/p>\n
\"JuneTestBox2\"<\/a><\/p>\n
Convert to Strings<\/h3>\n
Another task you need to manage in a GUI application is converting objects to text strings. Usually, this just means piping your output to an Out<\/b> cmdlet, such as Out-String<\/b>. Out<\/b> cmdlets, including Out-GridView<\/b>, convert objects to string data.<\/p>\n
When you write output to the console, Windows PowerShell automatically appends an Out-String<\/b> command to the pipeline. But, there is no console and no automatic Out-String<\/b> in a GUI application.<\/p>\n
When you assign non-string objects to a string object or to a control that takes string objects, such as a TextBox, Windows PowerShell calls the toString() method of the object. (In other languages, the assignment would just fail, but it’s trying to help.) With some objects, such as DateTime<\/b> and ErrorRecord<\/b> objects, toString() works just fine, but, in many cases, it produces odd-looking results.<\/p>\n
For example, this command assigns the results of a Get-Process<\/b> command to a text box. Windows PowerShell recognizes that you need text and calls the toString() method of Process objects, but the result is not useful.<\/p>\n
$buttonGetProcess_Click = {\r\n    $textboxResults.Text = Get-Process\r\n}<\/pre>\n
\"GetProcess1\"<\/a><\/p>\n
To get a string representation of the default process table, pipe the output to the Out-String<\/b> cmdlet and then assign it to the text box.<\/p>\n
$buttonGetProcess_Click = {\r\n    $textboxResults.Text = Get-Process | Out-String\r\n}<\/pre>\n
\"GetProcess2\"<\/a><\/p>\n
TIP<\/b>: To make the output easy to read, set the text box (or rich text box) to use a monospace font. In PowerShell Studio, right click the text box, click Apply Property Set<\/b>, and then click Apply Console Font<\/b>.<\/p>\n
Don’t avoid toString() completely. There are a few objects where the toString() method produces a useful result. DateTime<\/b><\/a> objects are the classic example. The toString() method of a DateTime<\/b> object returns a “short-date\/long-time” format string. Out-String<\/b> returns a “long-date\/long-time” format.<\/p>\n
PS C:> (Get-Date).ToString()\r\n12\/6\/2014 10:42:24 AM\r\n\r\nPS C:> Get-Date | Out-String\r\nSaturday, December 6, 2014 10:42:37 AM<\/pre>\n
#Uses toString()\r\n$buttonGetDate_Click = {\r\n    $textboxDate.Text = Get-Date\r\n}<\/pre>\n
\"GetDate3\"<\/a><\/p>\n
#Uses toString()\r\n$buttonGetDate_Click = {\r\n    $textboxDate.Text = Get-Date | Out-String\r\n}<\/pre>\n
\"GetDate2\"<\/a><\/p>\n
You can also use the Format <\/b>and UFormat<\/b> parameters of the Get-Date<\/b><\/a> cmdlet to get a formatted date string in almost any configuration. For example, to get a date in RFC1123 format, use -Format R <\/b>(or “r”). No need to pipe to Out-String<\/b> when you use Format<\/b> or UFormat<\/b>, because these parameters force the cmdlet to return a string.<\/p>\n
PS C:> Get-Date -Format R\r\nTue, 09 Dec 2014 10:46:41 GMT<\/pre>\n
\"GetDate1\"<\/a><\/p>\n
Converting Formatted Objects<\/h3>\n
In the console, Format<\/b> cmdlets, such as Format-Table<\/a>, are usually the last element in a pipeline. The output looks great in the console, because Windows PowerShell appends an Out-String<\/b> command to the pipeline before sending it to the console.<\/p>\n
PS C:> Get-HotFix | Format-Table -Property HotFixID, InstalledOn -AutoSize\r\n\r\nHotFixID     InstalledOn\r\n--------     -----------\r\nKB2693643    10\/7\/2014 12:00:00 AM\r\nKB2769299    9\/5\/2014 12:00:00 AM\r\nKB2883200    10\/7\/2013 12:00:00 AM\r\nKB2883684    9\/5\/2014 12:00:00 AM\r\n...<\/pre>\n
But, in a GUI application, by default, you get the result of calling the toString() method of the format objects that the Format cmdlets return.<\/p>\n
$buttonGetHotfix_Click = {\r\n    $textboxHotFix.Text = Get-HotFix |\r\n    Format-Table -Property HotFixID, InstalledOn -AutoSize\r\n}<\/pre>\n
\"GetHotfix1\"<\/a><\/p>\n
To get a more usable display in your GUI application, pipe the format objects to the Out-String<\/b> cmdlet before assigning them to the Text property of the TextBox.<\/p>\n
$buttonGetHotfix_Click = {\r\n    $textboxHotFix.Text = Get-HotFix |\r\n    Format-Table -Property HotFixID, InstalledOn -AutoSize |\r\n    Out-String\r\n}<\/pre>\n
\"GetHotFix2\"<\/a><\/p>\n
That’s better!<\/p>\n
After a while, the task of managing the output display in your GUI applications become as natural as typing a cmdlet name, but while you’re learning, be sure to test and make sure that all of your output is captured and displayed in a usable format.<\/p>\n
June Blender is a technology evangelist at SAPIEN Technologies, Inc. You can reach her at <\/em>juneb@sapien.com<\/em><\/a> or follow her on Twitter at <\/em>@juneb_get_help<\/em><\/a>.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
After many years of writing scripts for the Windows PowerShell console, I’m now learning the next level of automation — writing GUI applications that run Windows PowerShell commands. PowerShell Studio forms provide a gentle and well-guided introduction to GUI applications, but it’s still taken me some time to break old habits. I constantly need to […]<\/p>\n","protected":false},"author":31,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[946,703,25],"tags":[1022,934,874],"class_list":["post-8448","post","type-post","status-publish","format-standard","hentry","category-guiprogramming","category-powershell-studio","category-windows-powershell","tag-guiprogramming","tag-juneb","tag-powershell-studio-2014"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/8448","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/users\/31"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/comments?post=8448"}],"version-history":[{"count":6,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/8448\/revisions"}],"predecessor-version":[{"id":12156,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/8448\/revisions\/12156"}],"wp:attachment":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/media?parent=8448"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/categories?post=8448"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/tags?post=8448"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}