Complete Guide to Executing PowerShell Scripts with Command Line Arguments from C#

Technical Background of PowerShell and C# Integration

In modern software development, the integration of C# and PowerShell provides powerful automation capabilities. PowerShell, as Microsoft's scripting language, offers rich system management features, while C#, as the primary language of the .NET platform, can directly invoke the PowerShell engine through the System.Management.Automation namespace. This integration approach avoids inter-process communication overhead and delivers superior execution performance.

Core Execution Framework: Runspace and Pipeline

The foundation of executing PowerShell scripts from C# lies in establishing a Runspace and Pipeline. The Runspace provides an isolated environment for script execution, while the Pipeline manages the command execution flow. The following code demonstrates the basic execution framework:

RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();
Runspace runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
runspace.Open();
Pipeline pipeline = runspace.CreatePipeline();

Best Practices for Parameter Passing

Proper handling of command line arguments is a critical challenge in the integration process. When parameter values contain spaces or special characters, using Command and CommandParameter classes ensures correct parameter transmission. This method prevents parsing errors that may occur with string concatenation.

Command myCommand = new Command(scriptFile);
CommandParameter testParam = new CommandParameter("key", "value with spaces");
myCommand.Parameters.Add(testParam);
pipeline.Commands.Add(myCommand);
Collection<PSObject> results = pipeline.Invoke();

Technical Details of Parameter Handling

The CommandParameter class automatically handles parameter value escaping and formatting. When passing path parameters containing spaces, the system automatically adds necessary quotation marks to ensure proper parsing by PowerShell scripts. For example, the path "C:\Program Files\MyApp" is automatically converted to "'C:\Program Files\MyApp'" format.

Alternative Approach: Process Invocation Method

Beyond using Runspace API, developers can directly invoke PowerShell processes through the Process class. This method is suitable for scenarios requiring independent execution environments or handling execution policy restrictions:

ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.FileName = @"powershell.exe";
startInfo.Arguments = @"& 'C:\Scripts\test.ps1'";
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;

Error Handling and Debugging Techniques

In practical deployments, proper exception handling for execution processes is essential. It's recommended to catch PipelineStoppedException and RuntimeException, and obtain detailed error information through the pipeline.Error collection. Additionally, enabling script block logging can assist in diagnosing parameter transmission issues.

Performance Optimization Recommendations

For frequently executed scripts, consider reusing Runspace instances to reduce initialization overhead. RunspacePool can manage multiple runspaces for concurrent execution. Furthermore, pre-compiling commonly used scripts can further enhance execution efficiency.

Security Considerations

When executing external scripts, security risks must be addressed. It's advisable to verify script file integrity, restrict script execution permissions, and disable dangerous PowerShell commands in production environments. ExecutionPolicy settings can control script execution behavior.

Practical Application Scenarios

This integration pattern is widely applied in system management tools, deployment automation, configuration management, and other scenarios. For instance, automatically executing environment configuration scripts in CI/CD pipelines, or dynamically running diagnostic commands in management consoles.