C:\PS> ipconfig -all

C:\PS> tf.exe status . /workspace:HILLR1;hillr /r
There are no pending changes.
The term 'hillr' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the
spelling of the name, or if a path was included, verify that the path is correct and try again.
At line:1 char:35
+ tf.exe status . /workspace:HILLR1;hillr /r
+                                   ~~~~~
    + CategoryInfo          : ObjectNotFound: (hillr:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException

C:\PS> echoargs.exe status . /workspace:HILLR1;hillr /r
Arg 0 is <status>
Arg 1 is <.>
Arg 2 is </workspace:HILLR1>

C:\PS> tf.exe status . /r /workspace:HILLR1`;hillr
File name     Change Local path
------------- ------ -----------------------------------------
$/Foo/Trunk/Tools/Bin
TfsTools.psm1 edit   C:\Tfs\Foo\Trunk\Tools\Bin\TfsTools.psm1

1 change(s)

C:\PS> sqlcmd -S .\SQLEXPRESS -v lname="Gates" -Q "SELECT FirstName,LastName FROM
AdventureWorks.Person.Contact WHERE LastName = '$(lname)'"
The term 'lname' is not recognized as the name of a cmdlet, function, script
file, or operable program. Check the spelling of the name, or if a path was
included, verify that the path is correct and try again.
At line:1 char:126
+ ...  LastName = '$(lname)'"
+                    ~~~~~
    + CategoryInfo          : ObjectNotFound: (lname:String) [], CommandNotFou
   ndException
    + FullyQualifiedErrorId : CommandNotFoundException

In this case the V2 solution is to escape the $ character in the last part of the command line e.g.: ‘`$(lname)’ but if you don’t want to spend the time to figure this out you can easily use –% like so:

C:\PS> sqlcmd --% -S .\SQLEXPRESS -v lname="Gates" -Q "SELECT FirstName,LastName F
ROM AdventureWorks.Person.Contact WHERE LastName = '$(lname)'"
FirstName                                          LastName

---------------------------------- -----------------------------------
Janet                              Gates

(1 rows affected)

C:\PS> $env:colname = "LastName"
C:\PS> sqlcmd -S .\SQLEXPRESS -v lname="Gates" --% -Q "SELECT FirstName,LastName F
ROM AdventureWorks.Person.Contact WHERE %colname% = '$(lname)'"
FirstName                                          LastName

---------------------------------- -----------------------------------
Janet                              Gates

(1 rows affected)

I believe this new command line parsing feature will greatly simplify interacting with exes that have a complex command line parameter syntax.  Thanks to the PowerShell team for listening to the community feedback on this issue and providing a solution.

C:\PS> Get-Command Where-Object | Select -Expand ParameterSets | Format-Table Name

Name
----
EqualSet
ScriptBlockSet
CaseSensitiveGreaterThanSet
CaseSensitiveNotEqualSet
LessThanSet
CaseSensitiveEqualSet
NotEqualSet
GreaterThanSet
CaseSensitiveLessThanSet
GreaterOrEqualSet
CaseSensitiveGreaterOrEqualSet
LessOrEqualSet
CaseSensitiveLessOrEqualSet
LikeSet
CaseSensitiveLikeSet
NotLikeSet
CaseSensitiveNotLikeSet
MatchSet
CaseSensitiveMatchSet
NotMatchSet
CaseSensitiveNotMatchSet
ContainsSet
CaseSensitiveContainsSet
NotContainsSet
CaseSensitiveNotContainsSet
InSet
CaseSensitiveInSet
NotInSet
CaseSensitiveNotInSet
IsSet
IsNotSet

Now where this syntax can lead you astray if you don’t understand how it works, is if you make the assumption that this is a parsed expression.  In that case, folks might expect this to work:

 

There is a Threads collection on each Process object.  We might think that we can access a property on that collection but in effect, what happens is that the Where-Object Property parameter gets the value “Threads.Count” and there is no property on a Process object called “Threads.Count”. This silently fails which might lead you to believe there are no processes with greater than 100 threads.  But reverting back to the standard syntax we see that isn’t the case:

 

So when you are using the simplified syntax be sure to keep in mind that you can only specify property names and you cannot access sub-properties.  Keep your property names simple and you should be copasetic with the new, simplified syntax.  While I’m a little unsure about the new simplified syntax given how quickly you can fall off the “simple” path into the sharp rocks and lava below, I will say this.  As I wrote this blog post, I used the simplified syntax quite a bit and I have to say that it is growing on me.

 

One final item to mention about simplified syntax.  It turns out that some folks have a hard time grokking $_ but when they’re presented with $PSItem it apparently makes more sense to them.  So in PowerShell v3, wherever you can use $_ you can also use $PSItem.  $PSItem is not an alias. It seems to be a duplicate variable defined in all the same scopes as $_ and its value tracks that of $_ e.g.:

 

C:\PS> 1 | Foreach {Get-Variable _,psitem; $_ = 4; Get-Variable _,psitem}

Name                           Value
----                           -----
_                              1
PSItem                         1
_                              4
PSItem                         4

Occasionally folks want to be able to create an EXE from PoweShell.  PowerShell can’t do this by itself but this can be done with PowerShell script.  Essentially what you can do is create a simple console EXE program that embeds the script as a resource and the EXE, upon loading retrieves the script and throws it at a PowerShell runspace to execute.  Here’s the script for a feasibility test of doing this very thing.

Note that this script depends on Write-GZip from the PowerShell Community Extensions.

Update 6-21-2011: The migration from Windows Live Spaces to WordPress seems to have messed with the formatting of the script.  You can now download the script from my SkyDrive.

#requires -version 2.0
<#
.SYNOPSIS
Creates an EXE wrapper from a PowerShell script by compressing the script and embedding into
a newly generated assembly.
.DESCRIPTION
Creates an EXE wrapper from a PowerShell script by compressing the script and embedding into
a newly generated assembly.
.PARAMETER Path
The path to the .
.PARAMETER LiteralPath
Specifies a path to one or more locations. Unlike Path, the value of LiteralPath is used exactly as it
is typed. No characters are interpreted as wildcards. If the path includes escape characters, enclose
it in single quotation marks. Single quotation marks tell Windows PowerShell not to interpret any
characters as escape sequences.
.PARAMETER OutputAssembly
The name (including path) of the EXE to generate.
.PARAMETER IconPath
The path to an optional icon to be embedded as the application icon for the EXE.
.EXAMPLE
C:\PS> .\Make-PS1ExeWrapper.ps1 .\MyScript.ps1 .\MyScript.exe .\app.ico
This creates an console application called MyScript.exe that internally hosts the PowerShell
engine and runs the script specified by MyScript.ps1.  Optionally the file app.ico is
embedded into the EXE as the application’s icon.
.NOTES
Author: Keith Hill
Date:   Aug 7, 2010
Issues: This implementation is more of a feasibility test and isn’t fully functional.  It doesn’t
support an number of PSHostUserInterface members as well as a number of PSHostRawUserInterface
members.  This approach also suffers from the same problem of running script “interactively”
and not loading it from a file. That is, the entire script output is run through Out-Default
and PowerShell gets confused.  It formats the first types it sees correctly but after that the
formatting is off.  To correct this, you have to append | Out-Default where you script outputs
to the host without using a Write-* cmdlet e.g.:

MyScript.ps1:
——————————-
Get-Process svchost
Get-Date | Out-Default
Dir C:\  | Out-Default
Dir c:\idontexist | Out-Default
$DebugPreference = ‘Continue’
$VerbosePreference = ‘Continue’
Write-Host    “host”
Write-Warning “warning”
Write-Verbose “verbose”
Write-Debug   “debug”
Write-Error   “error”
#>
[CmdletBinding(DefaultParameterSetName="Path")]
param(
[Parameter(Mandatory=$true, Position=0, ParameterSetName="Path",
ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true,
HelpMessage="Path to bitmap file")]
[ValidateNotNullOrEmpty()]
[string[]]
$Path,

[Alias("PSPath")]
[Parameter(Mandatory=$true, Position=0, ParameterSetName="LiteralPath",
ValueFromPipelineByPropertyName=$true,
HelpMessage="Path to bitmap file")]
[ValidateNotNullOrEmpty()]
[string[]]
$LiteralPath,

    [Parameter(Mandatory = $true, Position = 1)]
[string]
$OutputAssembly,

[Parameter(Position = 2)]
[string]
$IconPath
)

Begin {
Set-StrictMode -Version latest

$src = @’
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Management.Automation;
using System.Management.Automation.Host;
using System.Management.Automation.Runspaces;
using System.Reflection;
using System.Security;
using System.Text;
using System.Threading;

namespace PS1ToExeTemplate
{
class Program
{
private static object _powerShellLock = new object();
private static readonly Host _host = new Host();
private static PowerShell _powerShellEngine;

        static void Main(string[] args)
{
Console.CancelKeyPress += Console_CancelKeyPress;
Console.TreatControlCAsInput = false;

            string script = GetScript();
RunScript(script, args, null);
}

        private static string GetScript()
{
string script = String.Empty;

            Assembly assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(“Resources.Script.ps1.gz”))
{
var gZipStream = new GZipStream(stream, CompressionMode.Decompress, true);
var streamReader = new StreamReader(gZipStream);
script = streamReader.ReadToEnd();
}

            return script;
}

        private static void RunScript(string script, string[] args, object input)
{
lock (_powerShellLock)
{
_powerShellEngine = PowerShell.Create();
}

            try
{
_powerShellEngine.Runspace = RunspaceFactory.CreateRunspace(_host);
_powerShellEngine.Runspace.Open();
_powerShellEngine.AddScript(script);
_powerShellEngine.AddCommand(“Out-Default”);
_powerShellEngine.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);

                if (input != null)
{
_powerShellEngine.Invoke(new[] { input });
}
else
{
_powerShellEngine.Invoke();
}
}
finally
{
lock (_powerShellLock)
{
_powerShellEngine.Dispose();
_powerShellEngine = null;
}
}
}

        private static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
{
try
{
lock (_powerShellLock)
{
if (_powerShellEngine != null && _powerShellEngine.InvocationStateInfo.State == PSInvocationState.Running)
{
_powerShellEngine.Stop();
}
}
e.Cancel = true;
}
catch (Exception ex)
{
_host.UI.WriteErrorLine(ex.ToString());
}
}
}

    class Host : PSHost
{
private PSHostUserInterface _psHostUserInterface = new HostUserInterface();

        public override void SetShouldExit(int exitCode)
{
Environment.Exit(exitCode);
}

        public override void EnterNestedPrompt()
{
throw new NotImplementedException();
}

        public override void ExitNestedPrompt()
{
throw new NotImplementedException();
}

        public override void NotifyBeginApplication()
{
}

        public override void NotifyEndApplication()
{
}

        public override string Name
{
get { return “PSCX-PS1ToExeHost”; }
}

        public override Version Version
{
get { return new Version(1, 0); }
}

        public override Guid InstanceId
{
get { return new Guid(“E4673B42-84B6-4C43-9589-95FAB8E00EB2″); }
}

        public override PSHostUserInterface UI
{
get { return _psHostUserInterface; }
}

        public override CultureInfo CurrentCulture
{
get { return Thread.CurrentThread.CurrentCulture; }
}

        public override CultureInfo CurrentUICulture
{
get { return Thread.CurrentThread.CurrentUICulture; }
}
}

    class HostUserInterface : PSHostUserInterface, IHostUISupportsMultipleChoiceSelection
{
private PSHostRawUserInterface _psRawUserInterface = new HostRawUserInterface();

        public override PSHostRawUserInterface RawUI
{
get { return _psRawUserInterface; }
}

        public override string ReadLine()
{
return Console.ReadLine();
}

        public override SecureString ReadLineAsSecureString()
{
throw new NotImplementedException();
}

        public override void Write(string value)
{
string output = value ?? “null”;
Console.Write(output);
}

        public override void Write(ConsoleColor foregroundColor, ConsoleColor backgroundColor, string value)
{
string output = value ?? “null”;
var origFgColor = Console.ForegroundColor;
var origBgColor = Console.BackgroundColor;
Console.ForegroundColor = foregroundColor;
Console.BackgroundColor = backgroundColor;
Console.Write(output);
Console.ForegroundColor = origFgColor;
Console.BackgroundColor = origBgColor;
}

        public override void WriteLine(string value)
{
string output = value ?? “null”;
Console.WriteLine(output);
}

        public override void WriteErrorLine(string value)
{
string output = value ?? “null”;
var origFgColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(output);
Console.ForegroundColor = origFgColor;
}

        public override void WriteDebugLine(string message)
{
WriteYellowAnnotatedLine(message, “DEBUG”);
}

        public override void WriteVerboseLine(string message)
{
WriteYellowAnnotatedLine(message, “VERBOSE”);
}

        public override void WriteWarningLine(string message)
{
WriteYellowAnnotatedLine(message, “WARNING”);
}

        private void WriteYellowAnnotatedLine(string message, string annotation)
{
string output = message ?? “null”;
var origFgColor = Console.ForegroundColor;
var origBgColor = Console.BackgroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.BackgroundColor = ConsoleColor.Black;
WriteLine(String.Format(CultureInfo.CurrentCulture, “{0}: {1}”, annotation, output));
Console.ForegroundColor = origFgColor;
Console.BackgroundColor = origBgColor;
}

        public override void WriteProgress(long sourceId, ProgressRecord record)
{
throw new NotImplementedException();
}

        public override Dictionary<string, PSObject> Prompt(string caption, string message, Collection<FieldDescription> descriptions)
{
if (String.IsNullOrEmpty(caption) && String.IsNullOrEmpty(message) && descriptions.Count > 0)
{
Console.Write(descriptions[0].Name + “: “);
}
else
{
this.Write(ConsoleColor.DarkCyan, ConsoleColor.Black, caption + “\n” + message + ” “);
}
var results = new Dictionary<string, PSObject>();
foreach (FieldDescription fd in descriptions)
{
string[] label = GetHotkeyAndLabel(fd.Label);
this.WriteLine(label[1]);
string userData = Console.ReadLine();
if (userData == null)
{
return null;
}

                results[fd.Name] = PSObject.AsPSObject(userData);
}

            return results;
}

        public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName)
{
throw new NotImplementedException();
}

        public override PSCredential PromptForCredential(string caption, string message, string userName, string targetName, PSCredentialTypes allowedCredentialTypes, PSCredentialUIOptions options)
{
throw new NotImplementedException();
}

        public override int PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, int defaultChoice)
{
// Write the caption and message strings in Blue.
this.WriteLine(ConsoleColor.Blue, ConsoleColor.Black, caption + “\n” + message + “\n”);

            // Convert the choice collection into something that is
// easier to work with. See the BuildHotkeysAndPlainLabels
// method for details.
string[,] promptData = BuildHotkeysAndPlainLabels(choices);

            // Format the overall choice prompt string to display.
var sb = new StringBuilder();
for (int element = 0; element < choices.Count; element++)
{
sb.Append(String.Format(CultureInfo.CurrentCulture, “|{0}> {1} “, promptData[0, element], promptData[1, element]));
}

            sb.Append(String.Format(CultureInfo.CurrentCulture, “[Default is ({0}]“, promptData[0, defaultChoice]));

            // Read prompts until a match is made, the default is
// chosen, or the loop is interrupted with ctrl-C.
while (true)
{
this.WriteLine(sb.ToString());
string data = Console.ReadLine().Trim().ToUpper(CultureInfo.CurrentCulture);

                // If the choice string was empty, use the default selection.
if (data.Length == 0)
{
return defaultChoice;
}

                // See if the selection matched and return the
// corresponding index if it did.
for (int i = 0; i < choices.Count; i++)
{
if (promptData[0, i] == data)
{
return i;
}
}

                this.WriteErrorLine(“Invalid choice: ” + data);
}
}

        #region IHostUISupportsMultipleChoiceSelection Members

        public Collection<int> PromptForChoice(string caption, string message, Collection<ChoiceDescription> choices, IEnumerable<int> defaultChoices)
{
this.WriteLine(ConsoleColor.Blue, ConsoleColor.Black, caption + “\n” + message + “\n”);

            string[,] promptData = BuildHotkeysAndPlainLabels(choices);

            var sb = new StringBuilder();
for (int element = 0; element < choices.Count; element++)
{
sb.Append(String.Format(CultureInfo.CurrentCulture, “|{0}> {1} “, promptData[0, element], promptData[1, element]));
}

            var defaultResults = new Collection<int>();
if (defaultChoices != null)
{
int countDefaults = 0;
foreach (int defaultChoice in defaultChoices)
{
++countDefaults;
defaultResults.Add(defaultChoice);
}

                if (countDefaults != 0)
{
sb.Append(countDefaults == 1 ? “[Default choice is " : "[Default choices are ");
foreach (int defaultChoice in defaultChoices)
{
sb.AppendFormat(CultureInfo.CurrentCulture, "\"{0}\",", promptData[0, defaultChoice]);
}
sb.Remove(sb.Length – 1, 1);
sb.Append(“]”);
}
}

            this.WriteLine(ConsoleColor.Cyan, ConsoleColor.Black, sb.ToString());

            var results = new Collection<int>();
while (true)
{
ReadNext:
string prompt = string.Format(CultureInfo.CurrentCulture, “Choice[{0}]:”, results.Count);
this.Write(ConsoleColor.Cyan, ConsoleColor.Black, prompt);
string data = Console.ReadLine().Trim().ToUpper(CultureInfo.CurrentCulture);

                if (data.Length == 0)
{
return (results.Count == 0) ? defaultResults : results;
}

                for (int i = 0; i < choices.Count; i++)
{
if (promptData[0, i] == data)
{
results.Add(i);
goto ReadNext;
}
}

                this.WriteErrorLine(“Invalid choice: ” + data);
}
}

        #endregion

        private static string[,] BuildHotkeysAndPlainLabels(Collection<ChoiceDescription> choices)
{
// Allocate the result array
string[,] hotkeysAndPlainLabels = new string[2, choices.Count];

            for (int i = 0; i < choices.Count; ++i)
{
string[] hotkeyAndLabel = GetHotkeyAndLabel(choices[i].Label);
hotkeysAndPlainLabels[0, i] = hotkeyAndLabel[0];
hotkeysAndPlainLabels[1, i] = hotkeyAndLabel[1];
}

            return hotkeysAndPlainLabels;
}

        private static string[] GetHotkeyAndLabel(string input)
{
string[] result = new string[] { String.Empty, String.Empty };
string[] fragments = input.Split(‘&’);
if (fragments.Length == 2)
{
if (fragments[1].Length > 0)
{
result[0] = fragments[1][0].ToString().
ToUpper(CultureInfo.CurrentCulture);
}

                result[1] = (fragments[0] + fragments[1]).Trim();
}
else
{
result[1] = input;
}

            return result;
}
}

    class HostRawUserInterface : PSHostRawUserInterface
{
public override KeyInfo ReadKey(ReadKeyOptions options)
{
throw new NotImplementedException();
}

        public override void FlushInputBuffer()
{
}

        public override void SetBufferContents(Coordinates origin, BufferCell[,] contents)
{
throw new NotImplementedException();
}

        public override void SetBufferContents(Rectangle rectangle, BufferCell fill)
{
throw new NotImplementedException();
}

        public override BufferCell[,] GetBufferContents(Rectangle rectangle)
{
throw new NotImplementedException();
}

        public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill)
{
throw new NotImplementedException();
}

        public override ConsoleColor ForegroundColor
{
get { return Console.ForegroundColor; }
set { Console.ForegroundColor = value; }
}

        public override ConsoleColor BackgroundColor
{
get { return Console.BackgroundColor; }
set { Console.BackgroundColor = value; }
}

        public override Coordinates CursorPosition
{
get { return new Coordinates(Console.CursorLeft, Console.CursorTop); }
set { Console.SetCursorPosition(value.X, value.Y); }
}

        public override Coordinates WindowPosition
{
get { return new Coordinates(Console.WindowLeft, Console.WindowTop); }
set { Console.SetWindowPosition(value.X, value.Y); }
}

        public override int CursorSize
{
get { return Console.CursorSize; }
set { Console.CursorSize = value; }
}

        public override Size BufferSize
{
get { return new Size(Console.BufferWidth, Console.BufferHeight); }
set { Console.SetBufferSize(value.Width, value.Height); }
}

        public override Size WindowSize
{
get { return new Size(Console.WindowWidth, Console.WindowHeight); }
set { Console.SetWindowSize(value.Width, value.Height); }
}

        public override Size MaxWindowSize
{
get { return new Size(Console.LargestWindowWidth, Console.LargestWindowHeight); }
}

        public override Size MaxPhysicalWindowSize
{
get { return new Size(Console.LargestWindowWidth, Console.LargestWindowHeight); }
}

        public override bool KeyAvailable
{
get { return Console.KeyAvailable; }
}

        public override string WindowTitle
{
get { return Console.Title; }
set { Console.Title = value; }
}
}
}
‘@
}   

Process {
if ($psCmdlet.ParameterSetName -eq “Path”)
{
# In the -Path (non-literal) case we may need to resolve a wildcarded path
$resolvedPaths = @($Path | Resolve-Path | Convert-Path)
}
else
{
# Must be -LiteralPath
$resolvedPaths = @($LiteralPath | Convert-Path)
}

foreach ($rpath in $resolvedPaths)
{
Write-Verbose “Processing $rpath”

        $gzItem = Get-ChildItem $rpath | Write-GZip -Quiet
$resourcePath = “$($gzItem.Directory)\Resources.Script.ps1.gz”
if (Test-Path $resourcePath) { Remove-Item $resourcePath }
Rename-Item $gzItem $resourcePath

# Configure the compiler parameters
$referenceAssemblies = ‘System.dll’,([psobject].Assembly.Location)
$outputPath = $OutputAssembly
if (![IO.Path]::IsPathRooted($outputPath))
{
$outputPath = [io.path]::GetFullPath((Join-Path $pwd $outputPath))
}
if ($rpath -eq $outputPath)
{
throw ‘Oops, you don”t really want to overwrite your script with an EXE.’
}

        $cp = new-object System.CodeDom.Compiler.CompilerParameters $referenceAssemblies,$outputPath,$true
$cp.TempFiles = new-object System.CodeDom.Compiler.TempFileCollection ([IO.Path]::GetTempPath())
$cp.GenerateExecutable = $true
$cp.GenerateInMemory   = $false
$cp.IncludeDebugInformation = $true
if ($IconPath)
{
$rIconPath = Resolve-Path $IconPath
$cp.CompilerOptions = ” /win32icon:$rIconPath”
}
[void]$cp.EmbeddedResources.Add($resourcePath)

# Create the C# codedom compiler
$dict = new-object ‘System.Collections.Generic.Dictionary[string,string]‘
$dict.Add(‘CompilerVersion’,'v3.5′)
$provider = new-object Microsoft.CSharp.CSharpCodeProvider $dict

# Compile the source and report errors
$results = $provider.CompileAssemblyFromSource($cp, $src)
if ($results.Errors.Count)
{
$errorLines = “”
foreach ($error in $results.Errors)
{
$errorLines += “`n`t” + $error.Line + “:`t” + $error.ErrorText
}
Write-Error $errorLines
}
}
}

If you are dealing with an native executable that outputs UTF8 with no BOM (byte order marker) you will find that PowerShell garbles the input.  This is most likely an issue with how the .NET console code interprets the incoming byte stream.  Without a BOM it isn’t exactly easy to determine the proper encoding for a stream of bytes.  For example take the following simple native exe source code that is supposed to output this (BTW ignore the fact that the text says ‘ASCII’ – it is really UTF8):

ASCII outputᾹ

Contents of stdout.cpp:

#include <stdio.h>

main()
{
    bytes[] = { 0x41, 0x53, 0x43, 0x49,
                0x49, 0x20, 0x6F, 0x75,
                0xE1, 0xBE, 0xB9};

    for (int i = 0; i < 15; i++)
    {
        printf("%c", bytes[i]);
    }
}

If you pipe the output of this program into a PSCX utility called Format-Hex (alias is fhex), you can see the actual unicode byte stream that was created by .NET’s interpretation of the incoming byte stream.

PS> .\stdout.exe | fhex

Address:  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F ASCII
-------- ----------------------------------------------- ----------------
00000000 41 00 53 00 43 00 49 00 49 00 20 00 6F 00 75 00 A.S.C.I.I. .o.u.
00000010 74 00 70 00 75 00 74 00 DF 00 5B 25 63 25       t.p.u.t...[%c%

You might think you could pipe the output to Out-File –Encoding Utf8 but by the time the .NET strings hit the Out-File cmdlet the damage is already done.  As can be seen if you view the subsequent output in Notepad.exe:

ASCII outputᾹ

The solution to this problem is to provide a hint to the .NET console functionality about the encoding of the incoming bytes.  You can do this very simply:

PS> [System.Console]::OutputEncoding = [System.Text.Encoding]::UTF8

And it works:

6> .\stdout.exe | fhex

Address:  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F ASCII
-------- ----------------------------------------------- ----------------
00000000 41 00 53 00 43 00 49 00 49 00 20 00 6F 00 75 00 A.S.C.I.I. .o.u.
00000010 74 00 70 00 75 00 74 00 B9 1F                   t.p.u.t...

7> .\stdout.exe | Out-File good.txt -Encoding UTF8

If you open good.txt in notepad you get:

ASCII outputᾹ

And is as it should be.  However this may seem somewhat counter-intuitive (it did to me) since the problem is with PowerShell/.NET “reading” console input and not writing it.  Well one of the good folks on the PowerShell team pointed out to me that the Console OutputEncoding is probably inherited by child processes and a quick little experiment reveals this to be true.  So by setting the OutputEncoding this determines how .NET encodes console output which helps PowerShell/.NET determine the correct encoding when reading in this information via console input.

One last point on this approach is that you should stash the original value of [Console]::OutputEncoding and restore it after you’ve run a problematic exe like in this example.  I’ve found that the C# compiler will crash if you run it in PowerShell with the [Console]::OutputEncoding set to UTF8.