I got the following query in one of my Google hits today: "pipeline.Invoke() "Read-Host" Cannot invoke this function because the current host does not implement it."

I believe that this query was in reference to the lack of host functionality in the default settings for a runspace in Windows Powershell. I don't recall ever actually taking much about this, yet I am known for having abstracted the runspace API for use as a multi threading interface in Powershell. Now is a good time to talk some about this.

A runspace in Powershell is a big blob of information that pertains to a particular shell within Powershell. The runspace has several components within it, such as the cmdlets, aliases, functions, providers, etc. The host component specificly is ment to be used as an abstract interface to the console. The default host object used by a runspace doesn't have much functionality, so you may encounter error messages like the one above when you are using a generic host object.

It is possible to tell Powershell what host object should be used when the runspace is initialized. I do know that version 1.0 of powershell.exe will use a host that writes to the console used by the powershell.exe process. Since most other instances of Powershell don't have a console the host object will often be the default host object, that doesn't provide any functionality on its own, or a very simple host object, using only implementing a few methods in the PSHostUserInterface class.

From the query above it looks like this googler was trying to use Read-Host within an asynchronous runspace. The easy solution to this is to just not do so. It's easier, in most cases, to simply pass the needed information into the asynchronous runspace from the parent runspace. However, there are still some cases where you must use Read-Host from an asynchronous runspace. In that case you'll have to code and compile your own host class, and use that when initializing the runspace.

Write-EncryptedString message secret -gnupg

Write-EncryptedString message -gnupg

Write-EncryptedString message -gnupg -recipient 'John Doe'

After writing my last post I realized that I didn't have a script that would simplify the process of generating event handlers down to a single line task.

I quickly wrote a script that wraps C# method code into a delegate. The script allows delegates of any signature to be created. The result has four parameters, three of witch have default values, and only 17 lines of actual code. This script should be fairly easy to use.

The default values are set to use the EventHandler delegate. I chose this type of delegate because Powershell script blocks can be cast to EventHandler. I wanted to be able to easily generate a compiled delegate and be able to combine it with a script block.

Get-CDelegate.ps1

Here is an example of its use.

PS> $handler = Get-CDelegate 'Console.WriteLine("Hello world!");'
PS> $handler.Invoke($null,$null)
Hello world!

Simple! Right? Think of the compiled delegate as if it were a script block that runs really fast.

You can also make delegates of different types.

PS> $callback = Get-CDelegate 'Console.WriteLine("Hello world!");' -DelegateType AsyncCallback -Signature void, IAsyncResult

Here's the cool part. Combine a script block with an event handler to make a new event hander.

PS> $eh1 = get-cdelegate 'Console.WriteLine("Compiled EventHandler!");'
PS> $eh2 = [eventhandler]{write-host 'ScriptBlock!'}
PS> $eh3 = [delegate]::combine($eh1, $eh2)
PS> $eh3.invoke($null,$null)
Compiled EventHandler!
ScriptBlock!

There is also a using parameter. Add any namespaces that you want to use there. The default is 'System'.

Now, take it, have it, play with it, enjoy it, and remember, the key making this useful is to keep in mind that the result of this script is a reusable function that can do something that is hard much faster than an ordinary script block. Now go find an interesting use for this and post about it!

Update

I expanded the script so that the delegate can receive an object from the script that made it and also be able to remember past invocations. Script blocks store all their context information as variables, but that's not so easy in this case. Here there is no guarantee that there is even a Runspace associated with the thread that invokes the delegate. Now you can provide an initialization object, optional initialization code, and define the types for any values that should remain present between invocations.

PS> $eh = get-cdelegate 'context0++; Console.WriteLine(context0);' -contexttypes int -initobject 50 -initcode 'context0 = (int)init.BaseObject;'
PS> $eh.invoke($null,$null)
51
PS> $eh.invoke($null,$null)
52
PS> $eh.invoke($null,$null)
53
PS> $eh.invoke($null,$null)
54

I have seen this a few times in my Google referrals. People want to know how to how to add events to PresentationFramework controls in Powershell.
I'm sorry to tell you this, but, as of Powershell v1.0, you can't use script blocks generated in Powershell as event handlers in any STA style user interface, including WPF. This has to do with how Powershell currently handles threading. That's why I had to make three really long scripts just to show a single window.
If you really want to be able to add event handlers to WPF controls have a look at my New-CAssembly script. That will make it easier to include compiled code, such as event handlers, into a Powershell script. Then, look at my Library-PresentationInterface script. That will help you pack a custom user interface into a script as XAML.
Alternatively you may look at a few of Team Powershell's recent posts about controlling WPF through Powershell v2.0 CTP 2. They added an STA flag to CTP 2. This helps to resolve some of the threading issues in regards to controlling STA style user interfaces.

As you will see the last WPF and PowerShell example is a little over complicated when used with the currently released version of Library-PresentationInterface, but I will likely update the library at some point and then scripts like this could then be made more concise.

To make the script easier to read I will list the few basic steps taken by the script.

1. Generate a special collection class that can inform any WPF window displaying it when it is updated. When a window displays a normal collection any updates will likely not be noticed. This part may eventually be added to the library.
2. Create two collections and make the first element of the first collection the string "Loading..." and the second element of the first collection the second collection.
3. Display a window to display the content of the collections. The first collection becomes the tag of the window. A TextBlock is bound to the first element of the first collection(i.e. "Loading...") and a ListBox is bound the content of the second collection.
4. Add the numbers 1 to 5 to the second collection pausing one second between each number.
5. Wait for the user to close the window.

I have used a modified version of this script to monitor the log file of an IRC chat room in real time, effectively making the resulting window another chat window(minus the ability to respond). Any amount of information could be added like other chat rooms, RSS feeds, or any other information you can get your hands on, and any filters can be added to that information.

Requirements:

• New-CAssembly
• Library-PresentationInterface

It's probably time that I post the third example of how to use Library-PresentationInterface. I am sorry about the delay. I had the code for all the examples compiled before even posting the first example. The only thing keeping me from posting the example scripts is that I have to write the commentary. So I have no valid excuse for the delay.

The purpose of this example is to show that Library-PresentationInterface can be used to load a custom compiled window class using only that class's type name. The script includes a call to New-CAssembly to compile a new window class. A call to Start-PresentationInterface is then made with the new classes name passed to the WindowType parameter.

You may wish to save this code! I have found it very useful for debugging! The result of this script is a GUI representation of any exception or error record passed to the script! Also the Wait switch parameter may be used to halt script execution while the window is open, the dialog buttons then may be used to return a true/false value from the script witch may be used by any error trapping code.

Here it is, all 145 lines of it...

param ($ErrorInfo, [Switch]$Wait)

. Library-PresentationInterface

[void](new-cassembly @'
using System;
using System.Management.Automation;
using System.Windows;
using System.Windows.Controls;

namespace ErrorWindow {
	public class ErrorWindowClass : Window {
		bool IsErrorRecord;
		ErrorRecord Error;
		Exception Ex;
		protected override void OnInitialized(EventArgs e) {
			base.OnInitialized(e);
			this.Title = "ErrorWindow";
			if ((this.Tag is ErrorRecord) || (this.Tag is Exception)) {
				this.Height = 400;
				this.Width = 800;
				
				StackPanel Stack = new StackPanel();
				if (this.Tag is ErrorRecord) {
					IsErrorRecord = true;
					Error = (ErrorRecord)(this.Tag);
					Ex = Error.Exception;
				}
				else {
					IsErrorRecord = false;
					Ex = (Exception)(this.Tag);
				}
				
				Label MessageLabel = new Label();
				MessageLabel.Content = Ex.Message;
				Stack.Children.Add(MessageLabel);
				
				if (IsErrorRecord) {
					Label IdLabel = new Label();
					IdLabel.Content = String.Format("Error ID: {0}",Error.FullyQualifiedErrorId);
					Stack.Children.Add(IdLabel);

					Label CategoryLabel = new Label();
					CategoryLabel.Content = String.Format("Error Category: {0}",Error.CategoryInfo.Category.ToString());
					Stack.Children.Add(CategoryLabel);

					if (Error.CategoryInfo.Activity != "") {
						Label ActivityLabel = new Label();
						ActivityLabel.Content = String.Format("Error Activity: {0}",Error.CategoryInfo.Activity);
						Stack.Children.Add(ActivityLabel);
					}

					if (Error.CategoryInfo.Reason != "") {
						Label ReasonLabel = new Label();
						ReasonLabel.Content = String.Format("Error Reason: {0}",Error.CategoryInfo.Reason);
						Stack.Children.Add(ReasonLabel);
					}

					if (Error.CategoryInfo.TargetName != "") {
						Label TargetNameLabel = new Label();
						TargetNameLabel.Content = String.Format("Target Name: {0}",Error.CategoryInfo.TargetName);
						Stack.Children.Add(TargetNameLabel);
					}

					if (Error.CategoryInfo.TargetType != "") {
						Label TargetTypeLabel = new Label();
						TargetTypeLabel.Content = String.Format("Target Type: {0}",Error.CategoryInfo.TargetType);
						Stack.Children.Add(TargetTypeLabel);
					}

					Label PositionLabel = new Label();
					PositionLabel.Content = String.Format("Error Position: {0}",Error.InvocationInfo.PositionMessage);
					Stack.Children.Add(PositionLabel);
				}
				
				Label TypeLabel = new Label();
				TypeLabel.Content = String.Format("Error Type: {0}",Ex.GetType().FullName);
				Stack.Children.Add(TypeLabel);
				
				if (Ex.InnerException != null) {
					StackPanel InnerStack = new StackPanel();
					InnerStack.Orientation = Orientation.Horizontal;
					Label InnerExLabel = new Label();
					InnerExLabel.Content = String.Format("Inner Exception: {0}",Ex.InnerException.Message);
					InnerStack.Children.Add(InnerExLabel);
					
					Button InnerExButton = new Button();
					InnerExButton.Content = "More Info";
					InnerExButton.Click += this.InnerExceptionInfoClick;
					InnerStack.Children.Add(InnerExButton);
					Stack.Children.Add(InnerStack);
				}
				
				TextBlock StackBlock = new TextBlock();
				StackBlock.Text = String.Format("Stack:\n{0}",Ex.StackTrace);
				Stack.Children.Add(StackBlock);
				
				if (this.Owner == null) {
					StackPanel DialogStack = new StackPanel();
					DialogStack.Orientation = Orientation.Horizontal;
					DialogStack.HorizontalAlignment = HorizontalAlignment.Center;
					Button ContinueButton = new Button();
					ContinueButton.Content = "Continue/Retry";
					ContinueButton.Click += this.ContinueClick;
					DialogStack.Children.Add(ContinueButton);
					
					Button BreakButton = new Button();
					BreakButton.Content = "Break/Fail";
					BreakButton.Click += this.BreakClick;
					DialogStack.Children.Add(BreakButton);
					Stack.Children.Add(DialogStack);
				}
				
				ScrollViewer ScrollView = new ScrollViewer();
				ScrollView.Content = Stack;
				ScrollView.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
				this.Content = ScrollView;
			}
			else {
				this.Height = 100;
				this.Width = 500;
				this.Content="Target object is not an ErrorRecord.";
			}
		}

		public void InnerExceptionInfoClick(object sender, RoutedEventArgs e) {
			ErrorWindowClass ChildWindow = new ErrorWindowClass();
			ChildWindow.Tag = Ex.InnerException;
			ChildWindow.Owner = this;
			ChildWindow.Show();
		}

		public void ContinueClick(object sender, RoutedEventArgs e) {
			this.DialogResult = true;
		}

		public void BreakClick(object sender, RoutedEventArgs e) {
			this.DialogResult = false;
		}
	}
}
'@)

$result = start-PresentationInterface -WindowType ([ErrorWindow.ErrorWindowClass]) -WindowTag $ErrorInfo
if ($Wait) {(stop-PresentationInterface $result).DialogResult}

I suggest saving it as Get-ErrorDialog.

To use it simply perform any action that would cause an exception. Then, you may read the exception straight from the $error variable.

Get-ErrorDialog $Error[0]

Here is another example of how to use WPF with Powershell. This example shows how to use a custom control in WPF. This example is somewhat esoteric and does not pertain directly to Powershell, but custom types can make it easier to create different interfaces. Knowing how to do this is important because many of the base WPF types do not expose much useful functionality(e.g. a Button doesn't do anything on it's own and needs to have code added to it's events).

The first half of the example script compiles a new WPF class derived from the Button class. This new class does not necessarily need to be defined in the script. XAML can use any WPF class from any loaded assembly. This class could be part of a library of custom controls.

The new class, CountButton, is derived from the Button class in the System.Windows.Controls namespace. The button functionality is extended by making the button count the number of times it is clicked by overriding the OnClick method. The number of times the button is clicked is then exposed by the read only dependancy property ClickCount.

The second half of the example script contains XAML that will use the new WPF class. In the XAML the "t" xml namespace corresponds to the Test namespace in the embedded C# code. The element name for our CountButton class is then t:CountButton. The example XAML defines a CountButton with the name "countbutton" and the display text as "Click this!" The example XAML also defines a label with it's content bounded to the ClickCount property of the named button.

When this example script is invoked, the button will keep track of the number of times it is clicked and the label will automatically update it's content.

Combining example one and this example, a person could display some properties of a collection of objects, and have buttons available to invoke methods on those objects.

. Library-PresentationInterface

[void](new-cassembly @'
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;

[assembly:System.Windows.Markup.XmlnsDefinition("http://testschema/test","Test")]

namespace Test {
	public class CountButton : Button {
		int _ClickCount = 0;
		public int ClickCount {get {return _ClickCount;}}
		internal static readonly DependencyPropertyKey ClickCountKey = DependencyProperty.RegisterReadOnly(
			"ClickCount", typeof(int), typeof(CountButton),new PropertyMetadata(0));
		public static readonly DependencyProperty ClickCountProperty = ClickCountKey.DependencyProperty;
		
		protected override void OnClick() {
			this._ClickCount++;
			base.OnClick();
			this.SetValue(ClickCountKey, this._ClickCount);
		}
	}
}
'@)

$result = start-PresentationInterface -xaml ([xml]@'
<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:t="http://testschema/test"
	Title="Example 2" SizeToContent="WidthAndHeight">
	<StackPanel>
		<t:CountButton Name="countbutton" Width="150" HorizontalAlignment="Left">Click this!</t:CountButton>
		<StackPanel Orientation="Horizontal">
			<Label>Button click event count:</Label>
			<Label Content="{Binding ElementName=countbutton, Path=ClickCount}" />
		</StackPanel>
	</StackPanel>
</Window>
'@)
[void](stop-PresentationInterface $result)

This is the first real example of how WPF could be used by Powershell. It shows how to display a few properties of a collection of objects using XAML and no compiled parts. The XAML in the example script tells WPF how to display the data type we are using(WPF will actually only see the PSObjects that are passed, not the content), and the collection is then handed over to the window.

This is not the only way to do this. It would also be possible to construct the XAML for each object in the collection individually and not need to use a template.

. Library-PresentationInterface

function Get-ProcessDialog {
	$Xaml = [Xml](
	@"
		<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
			xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
			xmlns:ps="clr-namespace:System.Management.Automation;assembly=System.Management.Automation"
			Name="ThisWindow"
			Title="Formated Process List">
			<Window.Resources>
				<DataTemplate DataType="{x:Type ps:PSObject}">
					<Border BorderThickness='0,0,0,1' BorderBrush='Gray' Padding='3'>
						<StackPanel>
							<TextBlock FontSize='14' FontWeight='Bold' Text="{Binding Properties[ProcessName].Value}" />
							<StackPanel Orientation="Horizontal">
								<StackPanel.Style>
									<Style TargetType="StackPanel">
										<Style.Triggers>
											<DataTrigger Binding="{Binding Properties[CPU].Value}" Value="{x:Null}">
												<Setter Property="Visibility" Value="Collapsed" />
											</DataTrigger>
										</Style.Triggers>
									</Style>
								</StackPanel.Style>
								<TextBlock FontSize='12' Text="CPU: " />
								<TextBlock FontSize='12' Text="{Binding Properties[CPU].Value}" />
							</StackPanel>
							<StackPanel Orientation="Horizontal">
								<StackPanel.Style>
									<Style TargetType="StackPanel">
										<Style.Triggers>
											<DataTrigger Binding="{Binding Properties[WorkingSet].Value}" Value="{x:Null}">
												<Setter Property="Visibility" Value="Collapsed" />
											</DataTrigger>
										</Style.Triggers>
									</Style>
								</StackPanel.Style>
								<TextBlock FontSize='12' Text="Working Set: " />
								<TextBlock FontSize='12' Text="{Binding Properties[WorkingSet].Value}" />
							</StackPanel>
							<StackPanel Orientation="Horizontal">
								<StackPanel.Style>
									<Style TargetType="StackPanel">
										<Style.Triggers>
											<DataTrigger Binding="{Binding Properties[Description].Value}" Value="{x:Null}">
												<Setter Property="Visibility" Value="Collapsed" />
											</DataTrigger>
										</Style.Triggers>
									</Style>
								</StackPanel.Style>
								<TextBlock FontSize='12' Text="Description: " />
								<TextBlock FontSize='12' Text="{Binding Properties[Description].Value}" />
							</StackPanel>
							<StackPanel Orientation="Horizontal">
								<StackPanel.Style>
									<Style TargetType="StackPanel">
										<Style.Triggers>
											<DataTrigger Binding="{Binding Properties[Path].Value}" Value="{x:Null}">
												<Setter Property="Visibility" Value="Collapsed" />
											</DataTrigger>
										</Style.Triggers>
									</Style>
								</StackPanel.Style>
								<TextBlock FontSize='12' Text="Path: " />
								<TextBlock FontSize='12' Text="{Binding Properties[Path].Value}" />
							</StackPanel>
						</StackPanel>
					</Border>
				</DataTemplate>
			</Window.Resources>
			<ScrollViewer>
				<ItemsControl ItemsSource="{Binding ElementName=ThisWindow, Path=Tag}" />
			</ScrollViewer>
		</Window>
	"@
	)
	
	$result = Start-PresentationInterface -xaml ($Xaml) -WindowTag (
		@($input | select ProcessName, CPU, WorkingSet, Description, Path))
	[void](stop-PresentationInterface $result)
}

Get-Process | Get-ProcessDialog

In the past, when it came to generating a GUI using Powershell, the only option was to use System.Windows.Forms.dll to generate the GUI. This method required lots of verbose script, and the result was not always pretty. The PresentationFramework.dll library provided the XAML loader, but the Presentation classes required an STA thread to initialize while the threads that interpreted Powershell scripts are always MTA.

I really wanted to be able to create WPF windows in Powershell so I created a library script that will define several classes that will handle the initialization of an STA thread that can then handle the initialization of a WPF window.

Here are a list of a few of the major features of the library script.

• Windows can be initialized from XAML.
• Windows can be initialized using the default constructor of a class that derives from the window type.
• The Tag property can be set prior to initialization. Arguments for the window can be passed here.
• The value of the Tag property is returned when the window is closed. This can be useful in the case that a bool dialog result is not enough.
• The window threads operate asynchronously to Powershell. Synchronization is done useing an IAsyncResult object.
• The Dispatch object that is associated with the window's UI thread is attached to the IAsyncResult object. External threads cannot interact with user interface elements, but can use the Dispatch object to give instructions to the UI thread.

Later I will be giving four examples of how to use this library.

1. The first will give a simple example of the use XAML.
2. The second will be an example of using custom types with XAML.
3. The third will be an example of using a compiled window type.
4. The forth example will show how to use the Dispatch object.

To use this library script you will first need to save a copy of the New-CAssembly script either as a function or as a script file in a path location.

Use of the library is fairly simple. Simply dot source the library. Then, call the Start-PresentationInterface function passing either the XAML as an XML node to the Xaml parameter, or the type object of any compiled window type to the WindowType parameter. You may also initialize the window's Tag property by passing it to the WindowTag parameter. The result of that function will give an IAsyncResult object. It behaves just like any other IAsyncResult object, and has a IExposeDispatch interface giving it the Dispatch property. That object may be disposed of safely or you can pass it to the Result parameter of the Stop-PresentationInterface function. That function will block the calling thread untill the window has closed. The return value will give the DialogResult of the window and the final value of the Tag property of the window.

The script for the library is below, but first here is a really simple example to get you started.

. Library-PresentationInterface
# Initialize a window
$result = Start-PresentationInterface -xaml (
	[xml]'<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"><Viewbox><TextBlock>Welcome to the Presentation Framework!</TextBlock></Viewbox></Window>'
)
# Look at the result object
$result
# Wait for the window to close
Stop-PresentationInterface $result

Now the script.

# Library-PresentationInterface.ps1
# Version: 1.0
# Author: LunaticExperimentalist
# End User License: Public Domain/Unrestricted Use
# Provided "as is," with out warranty, and without any assertions of suitability
# for any purpose either express or implied. 

if ($args -contains '-?') { @'
Library-PresentationInterface
VERSION: 1.0
AUTHOR: LunaticExperimentalist

USAGE: Library-PresentationInterface

DESCRIPTION: This library contains two functions and four types. The types are
  only used by the functions and do not need to used directly. The two
  functions, Start-PresentationInterface and Stop-PresentationInterface, provide
  access to the Windows Presentation Framework. 

CONTAINS: Start-PresentationInterface
          Stop-PresentationInterface
'@
return
}


[Void]([Reflection.Assembly]::LoadWithPartialName('PresentationFramework'))
[Void](New-CAssembly @"
using System;
using System.Threading;
using System.Windows;

namespace LibraryPresentationInterface {
	// structure returned by the stop method
	public struct PresentationResult {
		// Contains the value of the DialogResult property of the window
		public bool DialogResult;
		// Contains the value of the Tag property of the window
		// may be used if a bool is insufficient
		public object WindowTag;
		public PresentationResult(bool dialogResult, object tag) {
			DialogResult = dialogResult; WindowTag = tag;
		}
	}

	// public interface can give a reference to the dispatcher assosiated with a window
	public interface IExposeDispatcher {
		System.Windows.Threading.Dispatcher Dispatcher {get;}
	}
	
	// this is an IAsynResult object returned by the start method
	// may be passed to the stop method to retrieve the dialog result or
	// may be discarded safely
	internal class PresentationAsyncResultImpl : IAsyncResult, IExposeDispatcher {
		object UserObject;
		EventWaitHandle Handle;
		bool Completed;
		PresentationResult DialogResult;
		bool IsError;
		System.Exception Error;
		System.Windows.Threading.Dispatcher _Dispatcher;
		
		public PresentationAsyncResultImpl(object userObject, EventWaitHandle handle) {
			UserObject = userObject; this.Handle = handle; Completed = false;
		}
		// returns the user defined object that was given at the start method
		public object AsyncState {get{return this.UserObject;}}
		// returns a wait handle that will be signaled when the window is closed
		public WaitHandle AsyncWaitHandle {get{return this.Handle;}}
		// returns false, this is an asyncronous method
		public bool CompletedSynchronously {get{return false;}}
		// returns true if the window is closed, or if initialization has failed
		public bool IsCompleted {get{return this.Completed;}}
		// returns the dispatcher of the UI thread of the window
		public System.Windows.Threading.Dispatcher Dispatcher {get {return _Dispatcher;}}
		// used by the stop mehtod to get the result
		internal PresentationResult Result {get{
			if (IsError)
				throw Error;
			return DialogResult;
		}}
		// used to set the result when the window is closed
		internal void SetComplete(PresentationResult result) {
			this.DialogResult = result; this.Completed = true; this.Handle.Set();
		}
		// used to set the dispatcher once the window is initialized
		internal void SetDispatcher(System.Windows.Threading.Dispatcher dispatcher) {
			_Dispatcher = dispatcher;
		}
		// used to set the result to throw an exception
		internal void SetException(System.Exception ex) {
			this.IsError = true; this.Error = ex; this.Completed = true;
			this.Handle.Set();
		}
	}
	
	// Args passed to the window thread
	internal class WindowArgs {
		// [xml]containing the xaml for the window or a [type] for a self describing window type
		public object WindowInfo;
		// initial value for the window's tag
		public object WindowTag;
		// an internal reference to the IAsyncResult object so the the result can be set
		public PresentationAsyncResultImpl AsyncResult;
		// initialization wait handle, signaled once initialization is completed
		public EventWaitHandle InitHandle;
		// an initialization exception that, if set, will be thown by the start method
		public Exception InitException; 
	}
	
	public class Presentation {
		// internal method to start the window thread
		private static IAsyncResult InternalStart (object windowInfo, object tag, object userObject) {
			WindowArgs Args = new WindowArgs();
			Args.WindowInfo = windowInfo; Args.WindowTag = tag;
			Args.AsyncResult = new PresentationAsyncResultImpl(userObject, new EventWaitHandle(false, EventResetMode.ManualReset));
			Args.InitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
			Args.InitException = null;
			Thread WindowThread = new Thread(new ParameterizedThreadStart(WindowProc));
			WindowThread.Name = "Presentation.Thread";
			WindowThread.SetApartmentState(ApartmentState.STA);
			WindowThread.Start(Args);
			Args.InitHandle.WaitOne();
			if (Args.InitException != null)
				throw Args.InitException;
			return Args.AsyncResult;
		}
		// public start method to accept xaml
		public static IAsyncResult Start(System.Xml.XmlNode xaml, object tag, object userObject) {
			if (xaml == null)
				throw new ArgumentNullException("xaml");
			return InternalStart(xaml, tag, userObject);
		}
		// public start method to accept a window type
		public static IAsyncResult Start(Type windowClass, object tag, object userObject) {
			if (windowClass == null)
				throw new ArgumentNullException("windowClass");
			return InternalStart(windowClass, tag, userObject);
		}
		// stop method to retrieve the dialog result 
		public static PresentationResult Stop(IAsyncResult asyncResult) {
			if (asyncResult == null)
				throw new ArgumentNullException("asyncResult");
			if (!(asyncResult is PresentationAsyncResultImpl))
				throw new ArgumentException("Unrecognised result type.");
			PresentationAsyncResultImpl Result = (PresentationAsyncResultImpl)asyncResult;
			Result.AsyncWaitHandle.WaitOne();
			return Result.Result;
		}
		// procedure for the window thread
		private static void WindowProc(object obj) {
			WindowArgs Args = (WindowArgs)obj;
			Window LocalWindow;
			PresentationResult FinalResult = new PresentationResult();
			// trap initialization errors
			try {
				if (Args.WindowInfo is System.Xml.XmlNode) {
					// initialize from xaml
					object XamlObject = System.Windows.Markup.XamlReader.Load(
						new System.Xml.XmlNodeReader((System.Xml.XmlNode)Args.WindowInfo));
					if (!(XamlObject is Window))
						throw new InvalidCastException("The given XAML did not return a Window object.");
					LocalWindow = (Window)XamlObject;
				}
				else {
					// initialize from type
					Type WindowType = (Type)Args.WindowInfo;
					System.Reflection.ConstructorInfo Constructor = WindowType.GetConstructor(Type.EmptyTypes);
					if (Constructor != null) {
						LocalWindow = (Window)Constructor.Invoke(new Object[0]);
					}
					else {
						throw new ArgumentException(String.Format("The type\"{0}\" does not have an accessable default constructor.",WindowType.FullName));
					}
				}
				LocalWindow.Tag = Args.WindowTag;
			}
			catch (Exception ex) {
				// set initialization exception
				Args.InitException = ex;
				Args.InitHandle.Set();
				return;
			}
			// initialization complete
			// set the dispatcher
			Args.AsyncResult.SetDispatcher(LocalWindow.Dispatcher);
			// set the initialization wait handle
			Args.InitHandle.Set();
			// trap runtime exceptions
			try {
				FinalResult.DialogResult = (bool)LocalWindow.ShowDialog();
				FinalResult.WindowTag = LocalWindow.Tag;
			}
			catch (Exception ex) {
				// set the runtime exception to be rethrown by the stop method
				Args.AsyncResult.SetException(ex);
				return;
			}
			// set the dialog result
			Args.AsyncResult.SetComplete(FinalResult);
		}
	}
}
"@)

function Start-PresentationInterface([System.Xml.XmlNode]$Xaml, [Type]$WindowType, $WindowTag, $UserObject) {
if (($args -contains '-?') -or ((!$Xaml) -and (!$WindowType)) -or (($Xaml) -and ($WindowType))) { @'
Library-PresentationInterface
VERSION: 1.0
AUTHOR: LunaticExperimentalist

USAGE:
  Start-PresentationInterface -Xaml [System.Xml.XmlNode]
	  [-WindowTag [Object]] [-UserObject [Object]]
  Start-PresentationInterface -WindowType [Type] [-WindowTag [Object]]
	  [-UserObject [Object]]

PARAMETERS:
  Xaml: An XML node, such as an XML document, in the format of XAML that
    describes the content of a Presentation Framework window. This argument is
    mandatory and mutually exclusive to WindowType.

  WindowType: May be any type derived from and including the type
    System.Windows.Window. The type must have a public default constructor.
    The default constuctor of this type is called and the resulting window
    object is displayed. This argument is mandatory and mutually exclusive to
    Xaml.
    
  WindowTag: The value of this argument is applied to the Tag property of the
    window after initialization.
  
  UserObject: This object is not used internally. It is only made available
    though the resulting IAsyncResult object.

RETURNS: An IAsyncResult object that can be used to get the dialog result of
  the window.

DESCRIPTION: Initializes a new window using the information provided by the
  WindowType or Xaml arguments.

SEE ALSO: Stop-PresentationInterface
'@
return
}
	if ($Xaml) {
		[LibraryPresentationInterface.Presentation]::Start($Xaml,$WindowTag,$UserObject)
	}
	else {
		[LibraryPresentationInterface.Presentation]::Start($WindowType,$WindowTag,$UserObject)
	}
}

function Stop-PresentationInterface([IAsyncResult]$Result) {
if (($args -contains '-?') -or (!$Result)) { @'
Stop-PresentationInterface
VERSION: 1.0
AUTHOR: LunaticExperimentalist

USAGE:
  Stop-PresentationInterface -Result [IAsyncResult]

PARAMETERS:
  Result: An IAsyncResult object obtained from the Start-PresentationInterface
    function.
	
RETURNS: An object of type LibraryPresentationInterface.PresentationResult
  containing dialog result information.

DESCRIPTION: Causes the current thread to wait for the window corresponding the
  given IAsyncResult object to close.

SEE ALSO: Start-PresentationInterface
'@
return
}
	[LibraryPresentationInterface.Presentation]::Stop($Result)
}

• A precompiled assembly is not dependent on availability of compilers, while a post compiled assembly must be written in a language that the end user has a compiler for. This shouldn't be a problem, however, if you program in Visual Basic or C#.
• A precompiled assembly should load faster than the equivalent post compiled assembly since the precompiled assembly does not need to be processed by a compiler. This will only have a performance impact when the assembly is first loaded and will only be noticeable with very large assemblies.
• A post compiled assembly can be inserted into a script as plain text, while a precompiled assembly must be maintained and compiled separately from the script.

$CompileTime = Measure-Command {New-CAssembly @"
	namespace Test {
		public class SpeedTestClass {
			public static int GetSum(int[] arr) {
				int sum = 0; foreach (int i in arr) {sum += i;} return sum;
			}
		}
	}
"@}

"TestCModule compile time: " + $CompileTime.TotalMilliseconds

function TestCModule([int[]]$in) {
	[test.speedtestclass]::GetSum($in)
}

function TestCMethod([int[]]$in) {
	Invoke-CScript 'int sum = 0; foreach (Object o in args) {sum += (int)o;} return sum;' $in
}

function TestPSMethod([int[]]$in) {
	[int]$sum = 0
	$in | Foreach {$sum += $_}
	$sum
}
[int[]]$arr = 1..10
"TestCModule(1..10): $((measure-command {TestCModule($arr)}).TotalMilliseconds)ms"
"TestCMethod(1..10): $((measure-command {TestCMethod($arr)}).TotalMilliseconds)ms"
"TestPSMethod(1..10): $((measure-command {TestPSMethod($arr)}).TotalMilliseconds)ms"
''
[int[]]$arr = 1..100
"TestCModule(1..100): $((measure-command {TestCModule($arr)}).TotalMilliseconds)ms"
"TestCMethod(1..100): $((measure-command {TestCMethod($arr)}).TotalMilliseconds)ms"
"TestPSMethod(1..100): $((measure-command {TestPSMethod($arr)}).TotalMilliseconds)ms"
''
[int[]]$arr = 1..1000
"TestCModule(1..1000): $((measure-command {TestCModule($arr)}).TotalMilliseconds)ms"
"TestCMethod(1..1000): $((measure-command {TestCMethod($arr)}).TotalMilliseconds)ms"
"TestPSMethod(1..1000): $((measure-command {TestPSMethod($arr)}).TotalMilliseconds)ms"
''
[int[]]$arr = 1..10000
"TestCModule(1..10000): $((measure-command {TestCModule($arr)}).TotalMilliseconds)ms"
"TestCMethod(1..10000): $((measure-command {TestCMethod($arr)}).TotalMilliseconds)ms"
"TestPSMethod(1..10000): $((measure-command {TestPSMethod($arr)}).TotalMilliseconds)ms"

TestCModule compile time: 184.6108
TestCModule(1..10): 4.0505ms
TestCMethod(1..10): 146.3526ms
TestPSMethod(1..10): 2.8179ms

TestCModule(1..100): 1.1498ms
TestCMethod(1..100): 25.9426ms
TestPSMethod(1..100): 14.3305ms

TestCModule(1..1000): 1.1065ms
TestCMethod(1..1000): 25.8739ms
TestPSMethod(1..1000): 187.4232ms

TestCModule(1..10000): 4.1893ms
TestCMethod(1..10000): 37.7209ms
TestPSMethod(1..10000): 1589.6593ms

# New-CAssembly.ps1
# Version: 1.0
# Author: LunaticExperimentalist
# End User License: Public Domain

param ([String]$Code = $(throw "C# code required to compile new assembly."))

# get code hash
$CodeHash = $Code.GetHashCode() -band 0x7fffffff

# look for an existing assembly
$ExistingAsm = [AppDomain]::CurrentDomain.GetAssemblies() | Foreach {
	$InfoType = $_.GetType("EmitedInfoClass")
	if (($InfoType) -and
		($InfoType.GetProperty("ModuleCode").GetValue($null,$null) -eq $Code )) {
		return $_
	}
}

if ($ExistingAsm) {
	# use existing assembly
	return $ExistingAsm
}

# or compile a new assembly
$CSharpCodeProvider = New-Object Microsoft.CSharp.CSharpCodeProvider
$Parameters = New-Object System.CodeDom.Compiler.CompilerParameters(
	@([AppDomain]::CurrentDomain.GetAssemblies() | where {$_.GlobalAssemblyCache -eq $true} | Foreach {$_.Location}),
	$null,$false)
$Parameters.GenerateInMemory = $true
$CompileResult=$CSharpCodeProvider.CompileAssemblyFromDom($Parameters, @(
	New-Object System.CodeDom.CodeSnippetCompileUnit(
		'public class EmitedInfoClass { public static string ModuleCode{get{return "' +
		($Code -replace '\\','\\' -replace '"','\"' -replace '\r','\r' -replace '\n','\n') + '";} } }'
	);
	New-Object System.CodeDom.CodeSnippetCompileUnit($Code)
) )

# check for errors
if ($CompileResult.Errors.Count -eq 0) {
	# use new assembly
	$CompileResult.CompiledAssembly
}
else {
	# write errors
	$CompileResult.Errors | Foreach {
		Write-Error "C Sharp Compile Error: Line $($_.Line) Col $($_.Column) `"$($_.ErrorText)`""
	}
}

# Invoke-CScript.ps1
# Version: 1.0
# Author: LunaticExperimentalist
# End User License: Public Domain

param ([String]$Code = $(throw "C# code required to compile new assembly."), [Object]$Arguments = $null)

$Asm = New-CAssembly @"
	using System;
	namespace Emited {
		public class EmitedClass {
			public static Object EmitedCMethod(
				Object[] args,
				System.Management.Automation.PSObject[] input,
				System.Management.Automation.EngineIntrinsics context)
				{ $Code }
		}
	}
"@

if ($Asm) {
	# use assembly
	$method = $Asm.GetType("Emited.EmitedClass").GetMethod("EmitedCMethod")
	$InputList = New-Object System.Collections.ArrayList
	$Input | Foreach {[Void]$InputList.Add($_)}
	$method.Invoke($null, @(@($Arguments),[System.Management.Automation.PSObject[]]$InputList.ToArray(),$ExecutionContext))
}

# Get-AssemblyResource.ps1
# Version: 1.0
# Author: LunaticExperimentalist
# End User License: Public Domain

param ([String[]]$AssemblyPath, [Switch]$Silent)

$AssemblyPath | Foreach {
	[String]::Join("`r`n", @(if ($Silent) {'[Void]('}
	"[AppDomain]::CurrentDomain.Load([Convert]::FromBase64String(@'"
	[Convert]::ToBase64String((Get-Content $_ -encoding byte),'InsertLineBreaks')
	"'@) )"
	if ($Silent) {');'}))
}

# Export-FunctionLibrary.ps1
# Version: 1.0
# Author: LunaticExperimentalist
# End User License: Public Domain

param ([String]$Path, [String[]]$FunctionNames,
	[String]$Encoding = 'utf8', [String]$CompressionFormat = 'None')

if (($args -contains "-?") -or (-not $Path) -or (-not $FunctionNames)) {
	"Export-FunctionLibrary"
	"VERSION: 1.0"
	"AUTHOR: LunaticExperimentalist"
	""
	"USAGE: Export-FunctionLibrary -Path [String] -FunctionNames [String[]]"
	"       [-Encoding [String]] [-CompressionFormat [String]]"
	""
	"PARAMETERS:"
	"  Path: A manditory parameter containing a path string to a file where the"
	"        selected functions are to be stored."
	""
	"  FunctionNames: A manditory parameter containing a list of function names."
	"                 The use of path style wildcards may be used here."
	""
	"  Encoding: An optional parameter selecting an encoding to be used when"
	"            exporting the xml text file. Valid encodings are utf8, utf16le,"
	"            and utf16be."
	""
	"  CompressionFormat: An optional parameter selecting a compression format to"
	"                     be applyed to the resulting library. Only GZip is"
	"                     supported by this version."
	""
	"DESCRIPTION: This script copys the code from one or more functions and saves"
	"             them to an xml formated file. The resuling xml can optionally"
	"             be compressed."
	""
	"SEE ALSO: Import-FunctionLibrary"
	return
}

if (('none','gzip') -notcontains $CompressionFormat) {
	throw 'Invalid compression format. Available formats are None and GZip.'
}

if (('utf8','utf16le','utf16be') -notcontains $Encoding) {
	throw 'Invalid encoding. Available encodings are utf8, utf16le, and utf16be.'
}

function IsFunctionNamed {
	param ([String]$FunctionName)
	$FunctionNames | Foreach { if ($FunctionName -like $_) { return $True } }
	return $False
}

function XMLEncode {
	param ([String]$Text)
	return $Text -replace '&','&' -replace '<','<' -replace '>','>'
}

# Generate the xml containg the names and script form the functions indicated by $FunctionNames
$LibraryXML = [String]::Concat($(
	''
	Get-ChildItem Function: | Foreach { if (IsFunctionNamed($_.Name)) {
		"$(XMLEncode($_.Name))$(XMLEncode($_.ScriptBlock.ToString()))"
	} }
	""
))

# Encode the xml
$Unicode = $( switch ($Encoding) {
	utf8 {New-Object System.Text.UTF8Encoding($False); break}
	utf16le {New-Object System.Text.UnicodeEncoding($False,$True); break}
	utf16be {New-Object System.Text.UnicodeEncoding($True,$True); break}
} )

[Byte[]]$LibraryBytes = @($Unicode.GetPreamble(); $Unicode.GetBytes($LibraryXML))

# Open a writable file at the path provided
[IO.FileStream]$FileStream = $Null
if (Test-Path $Path) {
	# File exists
	# Overwrive old file
	$FileStream = (Get-Item -Path $Path).Create()
}
else {
	# File does not exist
	# Create new file
	$FileStream = (New-Item -Path $Path -Type File).Create()
}

# Write the library byte data to the file
if ($CompressionFormat -eq 'gzip') {
	# GZip was requested
	$GZip = New-Object System.IO.Compression.GZipStream($FileStream, 'Compress')
	$GZip.Write($LibraryBytes, 0, $LibraryBytes.Length)
	$GZip.Close()
}
else {$FileStream.Write($LibraryBytes, 0, $LibraryBytes.Length); $FileStream.Close()}

# Import-FunctionLibrary.ps1
# Version: 1.0
# Author: LunaticExperimentalist
# End User License: Public Domain

param ([String]$Path, [String[]]$FunctionNames = '*',
	[String]$CompressionFormat = 'None', [Switch]$List)

if (($args -contains "-?") -or (-not $Path)) {
	"Import-FunctionLibrary"
	"VERSION: 1.0"
	"AUTHOR: LunaticExperimentalist"
	""
	"USAGE: Import-FunctionLibrary -Path [String] -FunctionNames [String[]]"
	"       [-CompressionFormat [String]]"
	""
	"PARAMETERS:"
	"  Path: A manditory parameter containing a path string to a file where the"
	"        selected functions are stored."
	""
	"  FunctionNames: An optional parameter containing a list of function names."
	"                 The use of path style wildcards may be used here."
	""
	"  CompressionFormat: An optional parameter selecting a compression format to"
	"                     be applyed to the resulting library. Only GZip is"
	"                     supported by this version. The default value is none."
	""
	"  List: A swtch parameter that causes Import-FunctionLibrary to output the"
	"        content of the library without creating new functions in the current"
	"        runspace."
	""
	"DESCRIPTION: This script reads functions form a file and makes them available"
	"             to the command line."
	""
	"SEE ALSO: Export-FunctionLibrary"
	return
}

if (('none','gzip') -notcontains $CompressionFormat) {
	throw 'Invalid compression format. Available formats are None and GZip.'
}

function IsFunctionNamed {
	param ([String]$FunctionName)
	$FunctionNames | Foreach { if ($FunctionName -like $_) { return $True } }
	return $False
}

# Read text form file
if (-not (Test-Path $Path)) {throw "Path not found."}

$LibraryText=$Null
if ($CompressionFormat -eq 'gzip') {
	# Read GZiped content
	$FileStream = (Get-Item $Path).OpenRead()
	$GZipStream = New-Object System.IO.Compression.GZipStream($FileStream,'Decompress')
	$FileReader = New-Object System.IO.StreamReader($GZipStream, $True)
	$LibraryText = $FileReader.ReadToEnd()
	$FileReader.Close()
}
else { $LibraryText = Get-Content $Path }

# Parse text as xml
$(
	trap {throw "The library text could not be parsed as xml."}
	$LibraryXML = [xml]$LibraryText
)

# Filter and apply functions from xml to the current runspace
$LibraryXML.SelectNodes('/library/function') | Foreach {
	if (IsFunctionNamed($_.Name)) {
		if ($List) {
			# Write functions to output
			$Container = New-Object PSObject
			Add-Member -MemberType NoteProperty -Name Name -Value ($_.Name) -InputObject $Container
			Add-Member -MemberType NoteProperty -Name Script -Value ($_.ScriptBlock) -InputObject $Container
			$Container
		}
		else {
			# Make functions available for use
			$FunctionName = $_.Name
			$(
				trap {Write-Error ('Could not import function "'+$FunctionName+'".'); continue}
				Set-Content -LiteralPath ("Function:\"+$FunctionName) -Value $_.ScriptBlock
			)
		}
	}
}

I have found a few bugs in Library-AsyncRunspace version 1.1 and I have added a couple of new functions so it's time for an update. The current version is 1.3 now. Yes, I skipped an update. Version 1.2 added the Stop-AsyncPipe function that can be used whenever a pipeline gets stuck in an infinite loop. Version 1.3 added the Write-AsyncMessage function and each new runspace also has a Read-AsyncMessage function. Some mild bugs were also fixed.

An object queue has now been associated with each runspace. The Write-AsyncMessage function will enqueue an object into the queue and Read-AsyncMessage will dequeue objects form the object queue in order. The purpose of the queue is to easily allow control messages to be sent into a runspace that is operating on a pipeline that is of indefinite length.

There is no specific use for this new feature. You may use it how you like. An example of its use would be to have a server run in a background runspace, periodically checking for messages in its queue for information on what to do next.
All other changes are bug fixes.

Here is the code:

# Library-AsyncRunspace
# Version: 1.3

# Include with {. Library-AsyncRunspace}

# Sugjested aliases...
# New-Alias eap End-AsyncPipe
# New-Alias gar Get-AsyncRunspace
# New-Alias wam Write-AsyncMessage
# New-Alias r! Invoke-ExpressionInRunspace
# New-Alias iar Invoke-ExpressionInRunspace
# New-Alias nar New-AsyncRunspace
# New-Alias rap Read-AsyncPipe
# New-Alias rar Remove-AsyncRunspace
# New-Alias sap Start-AsyncPipe

# Don't destroy previous runspace catalog
if ( -not $RunspaceCatalog ) {

# Declare the runspace catalog
$RunspaceCatalog = New-Object PSObject
$RunspaceCatalog | Add-Member NoteProperty RunspaceCountPosition 0 -PassThru |
 Add-Member NoteProperty RunspaceList @{}

function New-AsyncRunspace {
 param ([String]$NewName)
 
 # Incroment id number counter
 $RunspaceCatalog.RunspaceCountPosition++
 
 # Generate a runspace and add usefull properties
 $NewRunspace = [management.automation.runspaces.runspacefactory]::CreateRunspace() |
  Add-Member NoteProperty Name $NewName -PassThru |
  Add-Member NoteProperty CurrentPipe $null -PassThru |
  Add-Member NoteProperty MessageQueue ([Collections.Queue]::Synchronized($(New-Object Collections.Queue))) -PassThru |
  Add-Member ScriptProperty PipeState { $this.CurrentPipe.PipelineStateInfo.State } -PassThru |
  Add-Member ScriptProperty PipeStateReason { $this.CurrentPipe.PipelineStateInfo.Reason } -PassThru |
  Add-Member ScriptProperty CurrentCommands { "{$($this.CurrentPipe.Commands)}" } -PassThru
 $NewRunspace.Open()
 
 # Add a reference to the message queue and a function to read it to the runspace
 $PipeLine = $NewRunspace.CreatePipeline({
  $MessageQueue = $input | Select-Object -first 1
  function Read-AsyncMessage {
   if ($MessageQueue.Count) { return $MessageQueue.Dequeue() }
   else { return $null }
  }
 })
 [void]$Pipeline.Input.Write($NewRunspace.MessageQueue)
 $Pipeline.Input.Close()
 $PipeLine.Invoke()
 
 # Add new runspace to catalog
 $RunspaceCatalog.RunspaceList[$RunspaceCatalog.RunspaceCountPosition] = $NewRunspace
 
 # Report new runspace id number
 $RunspaceCatalog.RunspaceCountPosition
}

function Remove-AsyncRunspace {
 param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))

 if ( -not ($RunspaceID -is [Int32] -or $RunspaceID -is [String])) { throw "A runspace id must be supplied by integer or name!" }
 
 #Find selected runspace by number
 if ($RunspaceID -is [Int32]) {
  $RunspaceCatalog.RunspaceList[$RunspaceID].Close()
  $RunspaceCatalog.RunspaceList.Remove($RunspaceID)
 }
 #Or find selected runspace by name
 else {
  $keys = $RunspaceCatalog.RunspaceList.Keys
  $keys | Foreach-Object {
   if ( $RunspaceCatalog.RunspaceList[$_].Name -like $RunspaceID ) {
    $RunspaceCatalog.RunspaceList[$_].Close()
    $RunspaceCatalog.RunspaceList.Remove($_)
   }
  }
 }
}

function Get-AsyncRunspace {
 param ($RunspaceID)
 
 # Return the entire list of available runspaces by default
 if ( $RunspaceID -eq $null ) {
  return $RunspaceCatalog.RunspaceList.Values
 }
 
 # Type check on id
 if ( -not ($RunspaceID -is [Int32] -or $RunspaceID -is [String])) { throw "A runspace id must be supplied by integer or name!" }
 
 #Find selected runspace by number
 if ($RunspaceID -is [Int32]) {
  $SelectedRunspace = $RunspaceCatalog.RunspaceList[$RunspaceID]
 }
 #Or find selected runspace by name
 else {
  $SelectedRunspace = $RunspaceCatalog.RunspaceList.Values | Where-Object { $_.Name -like $RunspaceID }
 }
 
 # Return result
 $SelectedRunspace
}

function Write-AsyncMessage {
 param ($RunspaceID = (read-host "Enter a valid runspace ID or name."), [Object]$Message)
 
 $SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
 
 # Throw error if no runspace was found with the given id
 if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }

 # Append $Message to message queue
 $SelectedRunspace.MessageQueue.Enqueue($Message)
}

function Invoke-ExpressionInRunspace {
 param ($RunspaceID = (read-host "Enter a valid runspace ID or name."), [String]$Command = (read-host "Enter a command to be executed in the runspace."))
 
 $SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
 
 # Throw error if no runspace was found with the given id
 if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }
 
 # Insert the command into the runspace.
 $Pipeline = $SelectedRunspace.CreatePipeline($Command)

 # Insert input into the new pipe
 $input | Foreach-Object { [void]$Pipeline.Input.Write($_) }
 $Pipeline.Input.Close()
 
 # Execute pipe
 $Pipeline.Invoke()
 
 # Read pipeline result
 if ($Pipeline.PipelineStateInfo.State -eq [management.automation.runspaces.pipelinestate]::failed) {
  throw $Pipeline.PipelineStateInfo.Reason
 }
 $Pipeline.Error.ReadToEnd() | Foreach-Object { Write-Error $_ }
 $Pipeline.Output.ReadToEnd()
}

function Start-AsyncPipe {
 param (
  $RunspaceID = (read-host "Enter a valid runspace ID or name."),
  [String]$Command = (read-host "Enter a command to executed in the runspace.")
 )

 BEGIN {
  $SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
  
  # Throw error if no runspace was found with the given id
  if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }
  
  # Insert the command into the runspace.
  $Pipeline = $SelectedRunspace.CreatePipeline($Command)
  
  # Start async process
  $Pipeline.InvokeAsync()
  
  # List this pipe as current with the runspace
  $SelectedRunspace.CurrentPipe = $Pipeline
 }
 
 PROCESS {
 # Insert input into the new pipe
 [void]$Pipeline.Input.Write($_)
 }
 
 END {
 # Close input
 $Pipeline.Input.Close()
 }
}

function Read-AsyncPipe {
 param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))
 $SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1

 # Throw error if no runspace was found with the given id
 if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }

 if ($SelectedRunspace.CurrentPipe) {
  # Read pipeline result
  if ($SelectedRunspace.CurrentPipe.pipelineStateInfo.state -eq [management.automation.runspaces.pipelinestate]::failed) {
   throw $SelectedRunspace.CurrentPipe.PipelineStateInfo.Reason
  }
  $SelectedRunspace.CurrentPipe.Error.NonBlockingRead() | Foreach-Object { Write-Error $_ }
  $SelectedRunspace.CurrentPipe.Output.NonBlockingRead()
 }
}

function Stop-AsyncPipe {
 param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))

 $SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
 
 # Throw error if no runspace was found with the given id
 if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }
 
 if ( $SelectedRunspace.CurrentPipe ) {
  $SelectedRunspace.CurrentPipe.StopAsync()

  # Pipeline is no longer current
  $SelectedRunspace.CurrentPipe = $null
 }
}

function End-AsyncPipe {
 param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))

 $SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
 
 # Throw error if no runspace was found with the given id
 if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }

 # Check current pipeline
 if ($SelectedRunspace.CurrentPipe) {
  # Pipeline is no longer current
  $Pipeline = $SelectedRunspace.CurrentPipe
  $SelectedRunspace.CurrentPipe = $null
 
  # Read pipeline result
  if ($Pipeline.PipelineStateInfo.State -eq [management.automation.runspaces.pipelinestate]::failed) {
   throw $Pipeline.PipelineStateInfo.Reason
  }
  while ( -not $Pipeline.Output.EndOfPipeline -or -not $Pipeline.Error.EndOfPipeline ) {
   $Pipeline.Error.NonBlockingRead() | Foreach-Object { Write-Error $_ }
   $Pipeline.Output.NonBlockingRead()
   sleep -m 100
  }
 }
}

} # End if ( -not $RunspaceCatalog )

file: Library-AsyncRunspace.ps1

# Library-AsyncRunspace
# Version: 1.1

# Include with {. Library-AsyncRunspace}

# Sugjested aliases...
##New-Alias eap End-AsyncPipe
##New-Alias gar Get-AsyncRunspace
##New-Alias r! Invoke-ExpressionInRunspace
##New-Alias iar Invoke-ExpressionInRunspace
##New-Alias nar New-AsyncRunspace
##New-Alias rap Read-AsyncPipe
##New-Alias rar Remove-AsyncRunspace
##New-Alias sap Start-AsyncPipe

# Don't destroy previous runspace catalog
if ( -not $RunspaceCatalog ) {
	$RunspaceCatalog = New-Object PSObject
	$RunspaceCatalog | Add-Member NoteProperty RunspaceCountPosition 0 -PassThru |
		Add-Member NoteProperty RunspaceList @{}
}

function New-AsyncRunspace {
	param ([String]$NewName)
	
	# Incroment id number counter
	$RunspaceCatalog.RunspaceCountPosition++
	
	# Generate a runspace and add usefull properties
	$NewRunspace = [management.automation.runspaces.runspacefactory]::CreateRunspace() |
		Add-Member NoteProperty Name $NewName -PassThru |
		Add-Member NoteProperty CurrentPipe $null -PassThru |
		Add-Member ScriptProperty PipeState { $this.CurrentPipe.PipelineStateInfo.State } -PassThru |
		Add-Member ScriptProperty PipeStateReason { $this.CurrentPipe.PipelineStateInfo.Reason } -PassThru |
		Add-Member ScriptProperty CurrentCommands { "{$($this.CurrentPipe.Commands)}" } -PassThru
	$NewRunspace.Open()
	
	# Add new runspace to catalog
	$RunspaceCatalog.RunspaceList[$RunspaceCatalog.RunspaceCountPosition] = $NewRunspace
	
	# Report new runspace id number
	$RunspaceCatalog.RunspaceCountPosition
}

function Remove-AsyncRunspace {
	param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))

	if ( -not ($RunspaceID -is [Int32] -or $RunspaceID -is [String])) { throw "A runspace id must be supplied by integer or name!" }
	
	#Find selected runspace by number
	if ($RunspaceID -is [Int32]) {
		$RunspaceCatalog.RunspaceList[$RunspaceID].Close()
		$RunspaceCatalog.RunspaceList.Remove($RunspaceID)
	}
	#Or find selected runspace by name
	else {
		$keys = $RunspaceCatalog.RunspaceList.Keys
		$keys | Foreach-Object {
			if ( $RunspaceCatalog.RunspaceList[$_].Name -like $RunspaceID ) {
				$RunspaceCatalog.RunspaceList[$_].Close()
				$RunspaceCatalog.RunspaceList.Remove($_)
			}
		}
	}
}

function Get-AsyncRunspace {
	param ($RunspaceID)
	
	# Return the entire list of available runspaces by default
	if ( $RunspaceID -eq $null ) {
		return $RunspaceCatalog.RunspaceList.Values
	}
	
	# Type check on id
	if ( -not ($RunspaceID -is [Int32] -or $RunspaceID -is [String])) { throw "A runspace id must be supplied by integer or name!" }
	
	#Find selected runspace by number
	if ($RunspaceID -is [Int32]) {
		$SelectedRunspace = $RunspaceCatalog.RunspaceList[$RunspaceID]
	}
	#Or find selected runspace by name
	else {
		$SelectedRunspace = $RunspaceCatalog.RunspaceList.Values | Where-Object { $_.Name -like $RunspaceID }
	}
	
	# Return result
	$SelectedRunspace
}

function Invoke-ExpressionInRunspace {
	param ($RunspaceID = (read-host "Enter a valid runspace ID or name."), [String]$Command = (read-host "Enter a command to be executed in the runspace."))
	
	$SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
	
	# Throw error if no runspace was found with the given id
	if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }
	
	# Insert the command into the runspace.
	$Pipeline = $SelectedRunspace.CreatePipeline($Command)

	# Insert input into the new pipe
	$input | Foreach-Object { [void]$Pipeline.Input.Write($_) }
	$Pipeline.Input.Close()
	
	# Execute pipe
	$Pipeline.Invoke()
	
	# Return output from pipe
	$Pipeline.Output.ReadToEnd()
}

function Start-AsyncPipe {
	param (
		$RunspaceID = (read-host "Enter a valid runspace ID or name."),
		[String]$Command = (read-host "Enter a command to executed in the runspace.")
	)

	BEGIN {
		$SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
		
		# Throw error if no runspace was found with the given id
		if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }
		
		# Insert the command into the runspace.
		$Pipeline = $SelectedRunspace.CreatePipeline($Command)
		
		# Start async process
		$Pipeline.InvokeAsync()
		
		# List this pipe as current with the runspace
		$SelectedRunspace.CurrentPipe = $Pipeline
	}
	
	PROCESS {
	# Insert input into the new pipe
	[void]$Pipeline.Input.Write($_)
	}
	
	END {
	# Close input
	$Pipeline.Input.Close()
	}
}

function Read-AsyncPipe {
	param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))
	$SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1

	# Throw error if no runspace was found with the given id
	if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }

	# Read pipeline result
	if ($SelectedRunspace.CurrentPipe.pipelineStateInfo.state -eq [management.automation.runspaces.pipelinestate]::failed) {
		throw $SelectedRunspace.CurrentPipe.PipelineStateInfo.Reason
	}
	$SelectedRunspace.CurrentPipe.Output.nonblockingread()
}

function End-AsyncPipe {
	param ($RunspaceID = (read-host "Enter a valid runspace ID or name."))

	$SelectedRunspace = Get-AsyncRunspace $RunspaceID | Select-Object -first 1
	
	# Throw error if no runspace was found with the given id
	if ( ($SelectedRunspace | Measure-Object).Count -eq 0 ) { throw "Runspace not found!" }

	# Pipeline is no longer current
	$Pipeline = $SelectedRunspace.CurrentPipe
	$SelectedRunspace.CurrentPipe = $null

	# Read pipeline result
	if ($Pipeline.PipelineStateInfo.State -eq [management.automation.runspaces.pipelinestate]::failed) {
		throw $Pipeline.PipelineStateInfo.Reason
	}
	else {
		while (-not $Pipeline.Output.endofpipeline) {
			$Pipeline.Output.nonblockingread()
			start-sleep -m 50   #don't overload the cpu
		}
	$Pipeline.output.Close()
	}
}