How to execute PowerShell script in C#

What is PowerShell?

Windows PowerShell is developed by Microsoft for the purpose of managing automation and configuring tasks.

If the Command Prompt has a fairly primitive scripting language, Powershell with the addition of Windows Scripting Host, VBScript, JScript has greatly increased the ability.

PowerShell is based primarily on the .NET Framework. Therefore, PowerShell is designed as an object-oriented utility and supports scripting languages.

How to Embed PowerShell Within a C# Application?

Creating a new Windows Froms Application project, then open your form designer. Next, We will drag TextBox, Button and Label controls from your Visual Studio Toolbox to your winform.

After completing the interface design, you need to install the System.Management.Automation from the Manage Nuget Packages to your project.

Call Powershell from C#

Adding a click event handler to the Run button allows you to run the powershell script that you enter from your TextBox control.

For example, How to call PowerShell cmdlets from C#

// c# run powershell commands
private void btnRun_Click(object sender, EventArgs e)
{
    txtOutput.Clear();
    // powershell c# cmdlet run
    using (PowerShell powerShell = PowerShell.Create()) // Create a PowerShell instance
    {
        // c# powershell command input script
        powerShell.AddScript(txtInput.Text);
        // Add a cmdlet and parameters
        powerShell.AddCommand("Out-String");
        // Invoke the cmdlet
        Collection<PSObject> PSOutput = powerShell.Invoke(); // c# execute powershell command
        StringBuilder stringBuilder = new StringBuilder();
        // Output the results
        foreach (PSObject pSObject in PSOutput)
            stringBuilder.AppendLine(pSObject.ToString());
        txtOutput.Text = stringBuilder.ToString();
    }
}

First, Use PowerShell.Create() to create an instance of the PowerShell runtime, then use AddCommand("Get-Process") specifies the cmdlet you want to run.

How to run PowerShell scripts from C#?

Adding a click event handler to the Open button allows you to open the powershell script file, then execute the powershell script file.

// c# run powershell script
private void btnOpen_Click(object sender, EventArgs e)
{
    txtOutput.Clear();
    using (OpenFileDialog openFileDialog = new OpenFileDialog() { Filter = "PowerShell|*.ps1" })
    {
        if (openFileDialog.ShowDialog() == DialogResult.OK)
        {
            // powershell c# cmdlet run
            using (PowerShell powerShell = PowerShell.Create()) // Create a PowerShell instance
            {
                powerShell.AddScript(System.IO.File.ReadAllText(openFileDialog.FileName));
                // Add a cmdlet and parameters
                powerShell.AddCommand("Out-String");
                // Invoke the cmdlet
                Collection<PSObject> PSOutput = powerShell.Invoke();
                StringBuilder stringBuilder = new StringBuilder();
                // Output the results
                foreach (PSObject pSObject in PSOutput)
                    stringBuilder.AppendLine(pSObject.ToString());
                txtOutput.Text = stringBuilder.ToString();
            }
        }
    }
}

You can also get output from the PowerShell command after executing and reading data from the PSObject object.

To check for errors when calling PowerShell cmdlets from C#, you can use the HadErrors property of the PowerShell instance. If any errors occur during the execution, you can iterate through the Streams.Error collection to display the error details.

// Check for errors
if (powerShell.HadErrors)
{
    Console.WriteLine("Error encountered while executing PowerShell cmdlet.");
    foreach (var error in powerShell.Streams.Error)
    {
        Console.WriteLine(error.ToString());
    }
}

How to run powershell script from c# with parameters?

To call a PowerShell cmdlet with a name and parameters, you can use the AddCommand method to specify the cmdlet, and the AddParameter method to pass any parameters.

For example, to call Get-Process with the -Name parameter to filter by process name, you can write:

// Add a cmdlet and parameters (e.g., Get-Process with a specific name)
powerShell.AddCommand("Get-Process")
          .AddParameter("Name", "notepad");

To run a PowerShell script from C# with parameters, you will need to use the PowerShell class from System.Management.Automation.

using System;
using System.Management.Automation;

class Program
{
    static void Main(string[] args)
    {
        string scriptPath = @"C:\script.ps1";
        string param1 = "value1";
        string param2 = "value2";

        // Create a PowerShell runspace
        using (PowerShell ps = PowerShell.Create())
        {
            // Add the script
            ps.AddScript(scriptPath);

            // Add parameters
            ps.AddParameter("Param1", param1);
            ps.AddParameter("Param2", param2);

            // Invoke the script run powershell command from c#
            var result = ps.Invoke();

            // Output the result
            foreach (var item in result)
            {
                Console.WriteLine(item);
            }
        }
    }
}

If you want to execute a PowerShell script as a process, you can use System.Diagnostics.Process to call PowerShell and pass parameters directly.

using System;
using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        string scriptPath = @"C:\script.ps1";
        string param1 = "value1";
        string param2 = "value2";

        // Set up the PowerShell process
        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "powershell.exe",
            Arguments = $"-File \"{scriptPath}\" -Param1 \"{param1}\" -Param2 \"{param2}\"",
            RedirectStandardOutput = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };

        // Start the process
        using (Process process = Process.Start(startInfo))
        {
            // Read the output (if any)
            using (var reader = process.StandardOutput)
            {
                string output = reader.ReadToEnd();
                Console.WriteLine(output);
            }
        }
    }
}

How to use PowerShell in .NET Console Application

Similarly, you can easily call PowerShell from .Net Console application and pass the command as an argument as shown below.

// run powershell in c#
static void Main(string[] args)
{
    ProcessStartInfo processInfo = new ProcessStartInfo();
    processInfo.FileName = "powershell.exe";
    processInfo.Arguments = $@"& {args[0]}";
    processInfo.RedirectStandardError = true;
    processInfo.RedirectStandardOutput = true;
    processInfo.UseShellExecute = false;
    processInfo.CreateNoWindow = true;

    Process process = new Process();
    process.StartInfo = processInfo;
    process.Start();

    Console.WriteLine("Output - {0}", process.StandardOutput.ReadToEnd());
    Console.WriteLine("Errors - {0}", process.StandardError.ReadToEnd());
    Console.Read();
}

You can also create a method allows you to execute powershell cmdlets or powershell script through console application in c# as shown below.

void GetError()
{
    // powershell script c# run
    var script = @"C:\scripts\myscript.ps1";
    var startInfo = new ProcessStartInfo()
    {
        FileName = "powershell.exe",
        Arguments = $"-NoProfile -ExecutionPolicy unrestricted \"{script}\"",
        UseShellExecute = false
    };
    Process.Start(startInfo);
}

Through the example above, I hope you can integrate powershell cmdlets within your C# applications.