public PSTestScope(bool connect = true)
{
SiteUrl = ConfigurationManager.AppSettings["SPODevSiteUrl"];
CredentialManagerEntry = ConfigurationManager.AppSettings["SPOCredentialManagerLabel"];
var iss = InitialSessionState.CreateDefault();
if (connect)
{
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-SPOnline", typeof(ConnectSPOnline), null);
iss.Commands.Add(ssce);
}
_runSpace = RunspaceFactory.CreateRunspace(iss);
_runSpace.Open();
if (connect)
{
var pipeLine = _runSpace.CreatePipeline();
Command cmd = new Command("connect-sponline");
cmd.Parameters.Add("Url", SiteUrl);
if (!string.IsNullOrEmpty(CredentialManagerEntry))
{
cmd.Parameters.Add("Credentials", CredentialManagerEntry);
}
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
}
}
/// <summary>
/// Verifies if the InitialSessionState of the current process.
/// </summary>
/// <returns></returns>
private static bool DoesCurrentRunspaceIncludeCoreHelpCmdlet()
{
InitialSessionState iss =
System.Management.Automation.Runspaces.Runspace.DefaultRunspace.InitialSessionState;
if (iss != null)
{
IEnumerable <SessionStateCommandEntry> publicGetHelpEntries = iss
.Commands["Get-Help"]
.Where(entry => entry.Visibility == SessionStateEntryVisibility.Public);
if (publicGetHelpEntries.Count() != 1)
{
return(false);
}
foreach (SessionStateCommandEntry getHelpEntry in publicGetHelpEntries)
{
SessionStateCmdletEntry getHelpCmdlet = getHelpEntry as SessionStateCmdletEntry;
if ((getHelpCmdlet != null) && (getHelpCmdlet.ImplementingType.Equals(typeof(GetHelpCommand))))
{
return(true);
}
}
}
return(false);
}
public override InitialSessionStateEntry Clone()
{
SessionStateCmdletEntry stateCmdletEntry = new SessionStateCmdletEntry(this.Name, this._implementingType, this._helpFileName, this.Visibility);
stateCmdletEntry.SetPSSnapIn(this.PSSnapIn);
stateCmdletEntry.SetModule(this.Module);
return((InitialSessionStateEntry)stateCmdletEntry);
}
internal void AddSessionStateCmdletEntryToCache(SessionStateCmdletEntry entry)
{
if (this.IsSpecialCmdlet(entry.ImplementingType))
{
return;
}
this.AddCmdletInfoToCache(this.NewCmdletInfo(entry));
}
public PSTestScope(bool connect = true)
{
SiteUrl = ConfigurationManager.AppSettings["SPODevSiteUrl"];
CredentialManagerEntry = ConfigurationManager.AppSettings["SPOCredentialManagerLabel"];
Realm = ConfigurationManager.AppSettings["Realm"];
AppId = ConfigurationManager.AppSettings["AppId"];
AppSecret = ConfigurationManager.AppSettings["AppSecret"];
var iss = InitialSessionState.CreateDefault();
if (connect)
{
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-SPOnline", typeof(ConnectSPOnline), null);
iss.Commands.Add(ssce);
}
_runSpace = RunspaceFactory.CreateRunspace(iss);
_runSpace.Open();
// Sets the execution policy to unrestricted. Requires Visual Studio to run in elevated mode.
var pipeLine = _runSpace.CreatePipeline();
Command cmd = new Command("Set-ExecutionPolicy");
cmd.Parameters.Add("ExecutionPolicy", "Unrestricted");
cmd.Parameters.Add("Scope", "Process");
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
if (connect)
{
pipeLine = _runSpace.CreatePipeline();
cmd = new Command("connect-sponline");
cmd.Parameters.Add("Url", SiteUrl);
if (!string.IsNullOrEmpty(CredentialManagerEntry))
{
// Use Windows Credential Manager to authenticate
cmd.Parameters.Add("Credentials", CredentialManagerEntry);
}
else
{
if (!string.IsNullOrEmpty("AppId") && !string.IsNullOrEmpty("AppSecret"))
{
// Use oAuth Token to authenticate
if (!string.IsNullOrEmpty(Realm))
{
cmd.Parameters.Add("Realm", Realm);
}
cmd.Parameters.Add("AppId", AppId);
cmd.Parameters.Add("AppSecret", AppSecret);
}
}
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
}
}
internal static CmdletInfo NewCmdletInfo(
SessionStateCmdletEntry entry,
ExecutionContext context)
{
CmdletInfo cmdletInfo = new CmdletInfo(entry.Name, entry.ImplementingType, entry.HelpFileName, entry.PSSnapIn, context);
cmdletInfo.Visibility = entry.Visibility;
cmdletInfo.SetModule(entry.Module);
return(cmdletInfo);
}
/// <summary>
/// This sample shows how to add a cmdlet to an InitialSessionState object and then
/// uses the modified InitialSessionState object when creating a Runspace object.
/// </summary>
/// <param name="args">Parameter is not used.</param>
/// This sample demonstrates:
/// 1. Creating an InitialSessionState object.
/// 2. Adding a cmdlet to the InitialSessionState object.
/// 3. Creating a runspace that uses the InitialSessionState object.
/// 4. Craeting a PowerShell object tht uses the Runspace object.
/// 5. Running the pipeline of the PowerShell object synchronously.
/// 6. Working with PSObject objects to extract properties
/// from the objects returned by the pipeline.
private static void Main(string[] args)
{
// Create a default InitialSessionState object. The default
// InitialSessionState object contains all the elements provided
// by Windows PowerShell.
InitialSessionState iss = InitialSessionState.CreateDefault();
// Add the get-proc cmdlet to the InitialSessionState object.
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("get-proc", typeof(GetProcCommand), null);
iss.Commands.Add(ssce);
// Create a Runspace object that uses the InitialSessionState object.
// Notice that no PSHost object is specified, so the default host is used.
// See the Hosting samples for information on creating your own custom host.
using (Runspace myRunSpace = RunspaceFactory.CreateRunspace(iss))
{
myRunSpace.Open();
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = myRunSpace;
// Add the get-proc cmdlet to the pipeline of the PowerShell object.
powershell.AddCommand("get-proc");
Collection <PSObject> results = powershell.Invoke();
Console.WriteLine("Process HandleCount");
Console.WriteLine("--------------------------------");
// Display the output of the pipeline.
foreach (PSObject result in results)
{
Console.WriteLine(
"{0,-20} {1}",
result.Members["ProcessName"].Value,
result.Members["HandleCount"].Value);
}
}
// Close the runspace to release resources.
myRunSpace.Close();
}
System.Console.WriteLine("Hit any key to exit...");
System.Console.ReadKey();
}
public PsRunspace()
{
var config = InitialSessionState.CreateDefault();
SessionStateCmdletEntry requireModule = new SessionStateCmdletEntry(
"Require-Module", typeof(RequireCommand), "");
var requireAlias = new SessionStateAliasEntry("Require", "Require-Module");
config.Commands.Add(requireModule);
config.Commands.Add(requireAlias);
PsHost = new CustomPsHost();
Runspace = RunspaceFactory.CreateRunspace(PsHost, config);
Runspace.DefaultRunspace = Runspace;
Runspace.Open();
}
/// <summary>
/// Sample adds a cmdlet to InitialSessionState and then uses
/// modified InitialSessionState to create the Runspace.
/// </summary>
/// <param name="args">Unused</param>
static void Main(string[] args)
{
//Create a default InitialSessionState
InitialSessionState iss = InitialSessionState.CreateDefault();
//Add get-proc cmdlet to the session state
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("get-proc", typeof(GetProcCommand), null);
iss.Commands.Add(ssce);
// Create a runspace.
// (Note that no PSHost instance is supplied in the constructor so the
// default PSHost implementation is used. See the Hosting topics for
// more information on creating your own PSHost class.)
Runspace myRunSpace = RunspaceFactory.CreateRunspace(iss);
myRunSpace.Open();
PowerShell powershell = PowerShell.Create();
powershell.Runspace = myRunSpace;
// Create a pipeline with get-proc command (from this assembly)
powershell.AddCommand("get-proc");
Collection <PSObject> results = powershell.Invoke();
Console.WriteLine("Process HandleCount");
Console.WriteLine("--------------------------------");
// Print out each result object...
foreach (PSObject result in results)
{
Console.WriteLine("{0,-20} {1}",
result.Members["ProcessName"].Value,
result.Members["HandleCount"].Value);
}
// Finally close the runspace
// up any resources.
myRunSpace.Close();
System.Console.WriteLine("Hit any key to exit...");
System.Console.ReadKey();
}
public PSTestScope(bool connect = true)
{
configuration = new Configuration();
var iss = InitialSessionState.CreateDefault();
if (connect)
{
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-PnPOnline", typeof(ConnectOnline), null);
iss.Commands.Add(ssce);
}
_runSpace = RunspaceFactory.CreateRunspace(iss);
_runSpace.Open();
if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
var executionPolicyPipeline = _runSpace.CreatePipeline();
// This is only works / is needed on Windows
var executionPolicyCmd = new Command("Set-ExecutionPolicy");
executionPolicyCmd.Parameters.Add("ExecutionPolicy", "Unrestricted");
executionPolicyPipeline.Commands.Add(executionPolicyCmd);
executionPolicyPipeline.Invoke();
}
var pipeLine = _runSpace.CreatePipeline();
if (connect)
{
var cmd = new Command("Connect-PnPOnline");
cmd.Parameters.Add("Url", configuration.SiteUrl);
// Use the configured Credential Manager to authenticate
cmd.Parameters.Add("Credentials", configuration.Credentials);
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
}
}
private bool DoesInitialSessionStateIncludeGetCommandWithListImportedSwitch()
{
if (!this._initialSessionStateIncludesGetCommandWithListImportedSwitch.HasValue)
{
lock (this._initialSessionStateIncludesGetCommandWithListImportedSwitchLock)
{
if (!this._initialSessionStateIncludesGetCommandWithListImportedSwitch.HasValue)
{
bool flag = false;
InitialSessionState initialSessionState = this.RunspacePool.InitialSessionState;
if (initialSessionState != null)
{
IEnumerable <SessionStateCommandEntry> source = from entry in initialSessionState.Commands["Get-Command"]
where entry.Visibility == SessionStateEntryVisibility.Public
select entry;
SessionStateFunctionEntry e = source.OfType <SessionStateFunctionEntry>().FirstOrDefault <SessionStateFunctionEntry>();
if (e != null)
{
if (e.ScriptBlock.ParameterMetadata.BindableParameters.ContainsKey("ListImported"))
{
flag = true;
}
}
else
{
SessionStateCmdletEntry entry2 = source.OfType <SessionStateCmdletEntry>().FirstOrDefault <SessionStateCmdletEntry>();
if ((entry2 != null) && entry2.ImplementingType.Equals(typeof(GetCommandCommand)))
{
flag = true;
}
}
}
this._initialSessionStateIncludesGetCommandWithListImportedSwitch = new bool?(flag);
}
}
}
return(this._initialSessionStateIncludesGetCommandWithListImportedSwitch.Value);
}
private static bool DoesCurrentRunspaceIncludeCoreHelpCmdlet()
{
InitialSessionState initialSessionState = Runspace.DefaultRunspace.InitialSessionState;
if (initialSessionState != null)
{
IEnumerable <SessionStateCommandEntry> source = from entry in initialSessionState.Commands["Get-Help"]
where entry.Visibility == SessionStateEntryVisibility.Public
select entry;
if (source.Count <SessionStateCommandEntry>() != 1)
{
return(false);
}
foreach (SessionStateCommandEntry entry in source)
{
SessionStateCmdletEntry entry2 = entry as SessionStateCmdletEntry;
if ((entry2 != null) && entry2.ImplementingType.Equals(typeof(GetHelpCommand)))
{
return(true);
}
}
}
return(false);
}
public static InitialSessionState GetSessionStateForCommands(CommandInfo[] commands)
{
InitialSessionState iss = InitialSessionState.CreateDefault();
Dictionary <string, SessionStateCommandEntry> commandCache = new Dictionary <string, SessionStateCommandEntry>();
foreach (SessionStateCommandEntry ssce in iss.Commands)
{
commandCache[ssce.Name] = ssce;
}
iss.ApartmentState = ApartmentState.STA;
iss.ThreadOptions = PSThreadOptions.ReuseThread;
if (commands.Length == 0)
{
return(iss);
}
foreach (CommandInfo cmd in commands)
{
if (cmd.Module != null)
{
string manifestPath = cmd.Module.Path.Replace(".psm1", ".psd1").Replace(".dll", ".psd1");
if (System.IO.File.Exists(manifestPath))
{
iss.ImportPSModule(new string[] { manifestPath });
}
else
{
iss.ImportPSModule(new string[] { cmd.Module.Path });
}
continue;
}
if (cmd is AliasInfo)
{
CommandInfo loopCommand = cmd;
while (loopCommand is AliasInfo)
{
SessionStateAliasEntry alias = new SessionStateAliasEntry(loopCommand.Name, loopCommand.Definition);
iss.Commands.Add(alias);
loopCommand = (loopCommand as AliasInfo).ReferencedCommand;
}
if (loopCommand is FunctionInfo)
{
SessionStateFunctionEntry func = new SessionStateFunctionEntry(loopCommand.Name, loopCommand.Definition);
iss.Commands.Add(func);
}
if (loopCommand is CmdletInfo)
{
CmdletInfo cmdletData = loopCommand as CmdletInfo;
SessionStateCmdletEntry cmdlet = new SessionStateCmdletEntry(cmd.Name,
cmdletData.ImplementingType,
cmdletData.HelpFile);
iss.Commands.Add(cmdlet);
}
}
if (cmd is FunctionInfo)
{
SessionStateFunctionEntry func = new SessionStateFunctionEntry(cmd.Name, cmd.Definition);
iss.Commands.Add(func);
}
if (cmd is CmdletInfo)
{
CmdletInfo cmdletData = cmd as CmdletInfo;
SessionStateCmdletEntry cmdlet = new SessionStateCmdletEntry(cmd.Name,
cmdletData.ImplementingType,
cmdletData.HelpFile);
iss.Commands.Add(cmdlet);
}
}
return(iss);
}
private CmdletInfo NewCmdletInfo(SessionStateCmdletEntry entry) => CommandDiscovery.NewCmdletInfo(entry, this._context);
public void InitialPlugin(IServiceProvider serviceProvider)
{
PowerShellRecourseLoader = new PowerShellRecourseLoader(serviceProvider);
SessionStateCmdletEntry cmdletEntry = new SessionStateCmdletEntry("get-proc", typeof(AddDnsCacheItem), null);
}
/// <summary>
/// Add an new SessionState cmdlet entry to this session state object...
/// </summary>
/// <param name="entry">The entry to add</param>
internal void AddSessionStateEntry(SessionStateCmdletEntry entry)
{
AddSessionStateEntry(entry, /*local*/ false);
}
public static void InitializeRunspaceConfiguration(InitialSessionState config)
{
config.LanguageMode = PSLanguageMode.FullLanguage;
config.UseFullLanguageModeInDebugger = true;
var cmdlets = new List <SessionStateCmdletEntry>();
AddCmdletConfigurationEntries(new List <Type>()
{
//Common
typeof(ConvertSCPathCmdlet),
typeof(InvokeGenericMethodCmdlet),
//Book
typeof(WriteTextCmdlet),
typeof(WriteHtmlCmdlet),
typeof(WriteImageCmdlet),
typeof(WriteContentCmdlet),
typeof(WriteLatexCmdlet),
typeof(AddBookCharacterStyleCmdlet),
typeof(AddBookParagraphStyleCmdlet),
typeof(SetBookDefaultCharacterPropertiesCmdlet),
typeof(SetBookDefaultParagraphPropertiesCmdlet),
typeof(SetBookDefaultPropertiesCmdlet),
typeof(AddBookPageBreakCmdlet),
typeof(AddBookSectionCmdlet),
typeof(SetBookSectionCmdlet),
typeof(SetBookSectionHeaderCmdlet),
typeof(SetBookSectionFooterCmdlet),
typeof(AddBookTocCmdlet),
typeof(AddBookShapeCmdlet),
typeof(NewBookCmdlet),
typeof(MergeBookCmdlet),
typeof(SaveBookCmdlet),
typeof(WriteSpreadTableCmdlet),
typeof(WriteDataTableCmdlet),
//typeof(OutBookTemplateCmdlet),
typeof(WriteSyntaxTextCmdlet),
typeof(WriteErrorMessageCmdlet),
typeof(WriteMarkdownCmdlet),
typeof(ClearBookCmdlet),
//Spreadsheet
typeof(OutSpreadTableCmdlet),
typeof(NewSpreadPivotCmdlet),
typeof(NewSimpleSpreadChartCmdlet),
typeof(NewSpreadChartCmdlet),
typeof(NewSpreadsheetCmdlet),
typeof(SaveSpreadsheetCmdlet),
typeof(MergeSpreadsheetCmdlet),
typeof(OutSpreadTemplateCmdlet),
typeof(GetSpreadTableCmdlet),
typeof(SaveSpreadChartCmdlet),
typeof(ClearSpreadsheetCmdlet),
typeof(GetSpreadTableNamesCmdlet),
typeof(GetSpreadSheetNamesCmdlet),
typeof(SelectSpreadSheetCmdlet),
//Chart
typeof(NewChartCmdlet),
typeof(AddChartSeriesCmdlet),
typeof(AddChartTitleCmdlet),
typeof(AddChartPaneCmdlet),
typeof(SetChartLegendCmdlet),
typeof(AddChartLegendCmdlet),
typeof(SetChartSeriesLabelCmdlet),
typeof(SetChartTotalLabelCmdlet),
typeof(WriteChartCmdlet),
typeof(AddChartAxisCmdlet),
typeof(SetChartAxisCmdlet),
typeof(SetChartDefaultPaneCmdlet),
typeof(SetChartAxisLabelCmdlet),
typeof(SetChartAxisTitleCmdlet),
typeof(AddChartAxisCustomLabelCmdlet),
typeof(AddChartConstantLineCmdlet),
typeof(AddChartIndicatorCmdlet),
typeof(AddChartScaleBreakCmdlet),
typeof(AddChartSeriesTitleCmdlet),
typeof(AddChartAnnotationCmdlet),
typeof(AddChartSeriesColorizerCmdlet),
typeof(AddChartSegmentColorizerCmdlet),
typeof(SaveChartCmdlet),
typeof(SaveChartTemplateCmdlet),
//Sankey
typeof(WriteSankeyDiagramCmdlet),
typeof(SaveSankeyDiagramCmdlet),
//Grid
typeof(OutDataCmdlet),
typeof(OutDataSetCmdlet),
typeof(RemoveDataTableCmdlet),
typeof(ClearDataCmdlet),
typeof(SelectDataTableCmdlet),
//Map
typeof(NewMapCmdlet),
typeof(WriteMapCmdlet),
typeof(AddMapLayerVectorFileCmdlet),
typeof(AddMapLayerSqlCmdlet),
typeof(AddMapLayerWktCmdlet),
typeof(AddMapLayerImageCmdlet),
typeof(AddMapLayerVectorDataCmdlet),
typeof(AddMapLayerVectorItemsCmdlet),
typeof(AddMapItemCmdlet),
typeof(AddMapChoroplethColorizerCmdlet),
typeof(AddMapGraphColorizerCmdlet),
typeof(AddMapKeyColorizerCmdlet),
typeof(AddMapLegendCmdlet),
typeof(AddMapLayerSearchCmdlet),
typeof(AddMapLayerRouteCmdlet),
typeof(AddMapOverlayCmdlet),
typeof(AddMapMiniMapCmdlet),
typeof(AddMapClustererCmdlet),
typeof(SaveMapCmdlet),
//Heap
typeof(OutFileViewerCmdlet),
//Script
typeof(InvokeSCScriptCmdlet),
typeof(GetDbConnectionCmdlet),
typeof(SetDbConnectionCmdlet),
typeof(InvokeSqlScriptCmdlet),
typeof(InvokeSqlQueryCmdlet),
typeof(ExportTableToDatabaseCmdlet),
typeof(GetSCHostCmdlet),
typeof(ConvertToObjectListCmdlet),
typeof(ConvertToVectorCmdlet),
typeof(ConvertToPivotCmdlet),
typeof(ConvertToUnPivotCmdlet),
//ImportExport
typeof(ImportDelimitedTextCmdlet),
typeof(ImportFixedLengthTextCmdlet),
typeof(ExportDelimitedTextCmdlet),
typeof(ExportFixedLengthTextCmdlet),
typeof(ImportDbfCmdlet),
typeof(ExportDbfCmdlet),
//Async
typeof(InvokeAsyncCommandsCmdlet),
typeof(NewSCRunspaceCmdlet),
typeof(NewSCRunspacePoolCmdlet)
#if DEBUG
, typeof(TestCmdlet)
#endif
});
config.Commands.Add(cmdlets);
void AddCmdletConfigurationEntries(IEnumerable <Type> types)
{
foreach (var type in types)
{
AddCmdletConfigurationEntry(type);
}
}
void AddCmdletConfigurationEntry(Type cmdletType)
{
var attrsCmdlet = cmdletType.GetCustomAttributes(typeof(CmdletAttribute), true);
if (attrsCmdlet == null || attrsCmdlet.Length <= 0)
{
throw new Exception($"Cannot register cmdlet: {cmdletType.Name}");
}
var attrCmdlet = ((CmdletAttribute)attrsCmdlet[0]);
var cmdletName = $"{attrCmdlet.VerbName}-{attrCmdlet.NounName}";
var cmdletEntry = new SessionStateCmdletEntry(cmdletName, cmdletType, null);
cmdlets.Add(cmdletEntry);
}
}
/// <summary>
/// Add an new SessionState cmdlet entry to this session state object...
/// </summary>
/// <param name="entry">The entry to add</param>
/// <param name="local">If local, add cmdlet to current scope. Else, add to module scope</param>
internal void AddSessionStateEntry(SessionStateCmdletEntry entry, bool local)
{
ExecutionContext.CommandDiscovery.AddSessionStateCmdletEntryToCache(entry, local);
}
/// <summary>
/// This sample uses the ProxyCommand class to create a proxy command that
/// calls an existing cmdlet, but restricts the set of available parameters.
/// The proxy command is then added to an intial session state that is used to
/// create a contrained runspace. This means that the user can access the cmdlet
/// through the proxy command.
/// </summary>
/// <remarks>
/// This sample demonstrates the following:
/// 1. Creating a CommandMetadata object that describes the metadata of an
/// existing cmdlet.
/// 2. Modifying the cmdlet metadata to remove a parameter of the cmdlet.
/// 3. Adding the cmdlet to an initial session state and making it private.
/// 4. Creating a proxy function that calls the existing cmdlet, but exposes
/// only a restricted set of parameters.
/// 6. Adding the proxy function to the initial session state.
/// 7. Calling the private cmdlet and the proxy function to demonstrate the
/// constrained runspace.
/// </remarks>
private static void Main()
{
// Create a default intial session state. The default inital session state
// includes all the elements that are provided by Windows PowerShell.
InitialSessionState iss = InitialSessionState.CreateDefault();
// Add the get-proc cmdlet to the initial session state.
SessionStateCmdletEntry cmdletEntry = new SessionStateCmdletEntry("get-proc", typeof(GetProcCommand), null);
iss.Commands.Add(cmdletEntry);
// Make the cmdlet private so that it is not accessable.
cmdletEntry.Visibility = SessionStateEntryVisibility.Private;
// Set the language mode of the intial session state to NoLanguge to
//prevent users from using language features. Only the invocation of
// public commands is allowed.
iss.LanguageMode = PSLanguageMode.NoLanguage;
// Create the proxy command using cmdlet metadata to expose the
// get-proc cmdlet.
CommandMetadata cmdletMetadata = new CommandMetadata(typeof(GetProcCommand));
// Remove one of the parameters from the command metadata.
cmdletMetadata.Parameters.Remove("Name");
// Generate the body of a proxy function that calls the original cmdlet,
// but does not have the removed parameter.
string bodyOfProxyFunction = ProxyCommand.Create(cmdletMetadata);
// Add the proxy function to the initial session state. The name of the proxy
// function can be the same as the name of the cmdlet, but to clearly
// demonstrate that the original cmdlet is not available a different name is
// used for the proxy function.
iss.Commands.Add(new SessionStateFunctionEntry("get-procProxy", bodyOfProxyFunction));
// Create the constrained runspace using the intial session state.
using (Runspace myRunspace = RunspaceFactory.CreateRunspace(iss))
{
myRunspace.Open();
// Call the private cmdlet to demonstrate that it is not available.
try
{
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = myRunspace;
powershell.AddCommand("get-proc").AddParameter("Name", "*explore*");
powershell.Invoke();
}
}
catch (CommandNotFoundException e)
{
System.Console.WriteLine(
"Invoking 'get-proc' failed as expected: {0}: {1}",
e.GetType().FullName,
e.Message);
}
// Call the proxy function to demonstrate that the -Name parameter is
// not available.
try
{
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = myRunspace;
powershell.AddCommand("get-procProxy").AddParameter("Name", "idle");
powershell.Invoke();
}
}
catch (ParameterBindingException e)
{
System.Console.WriteLine(
"\nInvoking 'get-procProxy -Name idle' failed as expected: {0}: {1}",
e.GetType().FullName,
e.Message);
}
// Call the proxy function to demonstrate that it calls into the
// private cmdlet to retrieve the processes.
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = myRunspace;
powershell.AddCommand("get-procProxy");
List <Process> processes = new List <Process>(powershell.Invoke <Process>());
System.Console.WriteLine(
"\nInvoking the get-procProxy function called into the get-proc cmdlet and returned {0} processes",
processes.Count);
}
// Close the runspace to release resources.
myRunspace.Close();
}
System.Console.WriteLine("Hit any key to exit...");
System.Console.ReadKey();
}
