public bool ShouldExit
{
  get { return shouldExit; }
  set { shouldExit = value; }
}
private bool shouldExit;

/// <summary>
/// Define the property that the PSHost implementation will
/// use to tell the host application what exit code to use
/// when exiting.
/// </summary>
public int ExitCode
{
  get { return exitCode; }
  set { exitCode = value; }
}
private int exitCode;

//
// Copyright (c) 2006 Microsoft Corporation. All rights reserved.
// 
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
// PARTICULAR PURPOSE.
//
using System;
using System.Collections.Generic;
using System.Text;
using System.Management.Automation;
using System.Management.Automation.Host;
using System.Management.Automation.Runspaces;

namespace Microsoft.Samples.PowerShell.Host
{
  class Host01
  {
    /// <summary>
    /// Define the property that the PSHost implementation will 
    /// use to tell the host application that it should exit.
    /// </summary>
    public bool ShouldExit
    {
      get { return shouldExit; }
      set { shouldExit = value; }
    }
    private bool shouldExit;

    /// <summary>
    /// Define the property that the PSHost implementation will
    /// use to tell the host application what exit code to use
    /// when exiting.
    /// </summary>
    public int ExitCode
    {
      get { return exitCode; }
      set { exitCode = value; }
    }
    private int exitCode;
    /// <summary>
    /// This sample uses the RunspaceInvoke class to execute
    /// a script that calls exit. The host application looks at
    /// this and prints out the results.
    /// </summary>
    /// <param name="args">Unused</param>
    static void Main(string[] args)
    {
      // Create an instance of this class so that the PowerShell 
      // will have access to the ShouldExit and ExitCode 
      // parameters.
      Host01 me = new Host01();

      // Create the host instance to use.
      MyHost myHost = new MyHost(me);

      // Create and open the runspace, passing the host 
      // instance just created.
      Runspace myRunSpace = RunspaceFactory.CreateRunspace(myHost);
      myRunSpace.Open();

      // Create the invoker and use it to execute the script.
      RunspaceInvoke invoker = new RunspaceInvoke(myRunSpace);
      string script = "exit (2+2)";
      invoker.Invoke(script);

      // Check the flags and see if they were set propertly.
      Console.WriteLine(
                        "ShouldExit={0} (should be True); ExitCode={1} (should be 4)",
                        me.ShouldExit, me.ExitCode);

      // Close the runspace.
      myRunSpace.Close();

      Console.WriteLine("Hit any key to exit...");
      Console.ReadKey();
    }
  }
}

//
// Copyright (c) 2006 Microsoft Corporation. All rights reserved.
// 
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
// PARTICULAR PURPOSE.
//
using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;
using System.Management.Automation;
using System.Management.Automation.Host;
using System.Management.Automation.Runspaces;

namespace Microsoft.Samples.PowerShell.Host
{
  /// <summary>
  /// This is a sample implementation of the PSHost abstract class for 
  /// console applications. Not all members of the class are implemented. 
  /// Those that are not implemented throw a NotImplementedException.
  /// </summary>
  class MyHost : PSHost
  {
    /// <summary>
    /// Construct an instance of this PSHost implementation. Keep
    /// a reference to the hosting application object so it can
    /// be informed of when to exit.
    /// </summary>
    /// <param name="program">
    /// A reference to the host application object.
    /// </param>
    public MyHost(Host01 program)
    {
      this.program = program;
    }
    private Host01 program;
      
    /// <summary>
    /// This API returns the culture information to use. This 
    /// implementation returns a snapshot of the curture 
    /// information of the thread that created this object.
    /// </summary>
    public override System.Globalization.CultureInfo CurrentCulture
    {
      get { return originalCultureInfo; }
    }
    private CultureInfo originalCultureInfo = 
    System.Threading.Thread.CurrentThread.CurrentCulture;
    /// <summary>
    /// This API returns the UI culture info to use. This 
    /// implementation returns a snapshot of the UI curture 
    /// information of the thread that created this object.
    /// </summary>
    public override System.Globalization.CultureInfo CurrentUICulture
    {
      get { return originalUICultureInfo; }
    }
    private CultureInfo originalUICultureInfo =
    System.Threading.Thread.CurrentThread.CurrentUICulture;

    /// <summary>
    /// This API is not implemented by this example class.
    /// The call fails with an exception.
    /// </summary>
    public override void EnterNestedPrompt()
    {
      throw new NotImplementedException(
            "The method or operation is not implemented.");
    }

    /// <summary>
    /// This API is not implemented by this example class.
    /// The call fails with an exception.
    /// </summary>
    public override void ExitNestedPrompt()
    {
      throw new NotImplementedException(
            "The method or operation is not implemented.");
    }

    static Guid myId = Guid.NewGuid();
    /// <summary>
    /// Return the GUID allocated at instantiation time 
    /// for the InstanceId.
    /// </summary>
    public override Guid InstanceId
    {
      get { return myId; }
    }

    /// <summary>
    /// This API returns an appropriate string to identify 
    /// this host implementation. Keep in mind that this 
    /// string may be used by script writers to identify when 
    /// this host is being used.
    /// </summary>
    public override string Name
    {
      get { return "MySampleConsoleHostImplementation"; }
    }

    /// <summary>
    /// This API is called before an external application 
    /// process is started. Typically it is used to save 
    /// state that the child process may alter so the 
    /// parent can restore that state when the child exits. 
    /// In this example, it is not needed so the method 
    /// does nothing.
    /// </summary>
    public override void NotifyBeginApplication()
    {
      return;  // Do nothing...
    }

    /// <summary>
    /// This API is called after an external application 
    /// process finishes. Typically it is used to restore 
    /// state that the child process may have altered. In 
    /// this example, it is not needed so the method
    /// does nothing.
    /// </summary>
    public override void NotifyEndApplication()
    {
      return; // Do nothing...
    }

    /// <summary>
    /// This API indicates to the host application that 
    /// an exit has been requested. It passes the exit code 
    /// that the host application should use when exiting 
    /// the process.
    /// </summary>
    /// <param name="exitCode"></param>
    public override void SetShouldExit(int exitCode)
    {
      program.ShouldExit = true;
      program.ExitCode = exitCode;
    }

    /// <summary>
    /// This example does not implement a PSHostUserInterface 
    /// component so this property returns null.
    /// </summary>
    public override PSHostUserInterface UI
    {
      get { return null; }
    }

    /// <summary>
    /// Return the version object for this application. 
    /// Typically, this object should match the version 
    /// resource in the application.
    /// </summary>
    public override Version Version
    {
      get {return new Version(1,0,0,0); }
    }
  }
}