Exécuter le script PowerShell à partir de C# avec des arguments de ligne de commande

Question

Je dois exécuter un script PowerShell à partir de C#. Le script a besoin d'arguments de ligne de commande.

Voici ce que j'ai fait jusqu'à présent :

RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();

Runspace runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
runspace.Open();

RunspaceInvoke scriptInvoker = new RunspaceInvoke(runspace);

Pipeline pipeline = runspace.CreatePipeline();
pipeline.Commands.Add(scriptFile);

// Execute PowerShell script
results = pipeline.Invoke();

scriptFile contient quelque chose comme " C:\Program Fichiers \MyProgram\Whatever.ps1 ".

Le script utilise un argument de ligne de commande tel que "-key Value" alors que Value peut être quelque chose comme un chemin qui peut aussi contenir des espaces.

Je n'arrive pas à le faire fonctionner. Quelqu'un sait-il comment passer des arguments de ligne de commande à un script PowerShell depuis C# et s'assurer que les espaces ne posent pas de problème ?

Answer 1

Essayez de créer scriptfile comme une commande séparée :

Command myCommand = new Command(scriptfile);

vous pouvez alors ajouter des paramètres avec

CommandParameter testParam = new CommandParameter("key","value");
myCommand.Parameters.Add(testParam);

et enfin

pipeline.Commands.Add(myCommand);

---

Voici le code complet, édité :

RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();

Runspace runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
runspace.Open();

RunspaceInvoke scriptInvoker = new RunspaceInvoke(runspace);

Pipeline pipeline = runspace.CreatePipeline();

//Here's how you add a new script with arguments
Command myCommand = new Command(scriptfile);
CommandParameter testParam = new CommandParameter("key","value");
myCommand.Parameters.Add(testParam);

pipeline.Commands.Add(myCommand);

// Execute PowerShell script
results = pipeline.Invoke();

Answer 2

J'ai une autre solution. Je veux juste tester si l'exécution d'un script powershell réussit, car peut-être quelqu'un pourrait changer la politique. Comme argument, je spécifie simplement le chemin du script à exécuter.

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;
Process process = new Process();
process.StartInfo = startInfo;
process.Start();

string output = process.StandardOutput.ReadToEnd();
Assert.IsTrue(output.Contains("StringToBeVerifiedInAUnitTest"));

string errors = process.StandardError.ReadToEnd();
Assert.IsTrue(string.IsNullOrEmpty(errors));

Le contenu du script étant :

$someVariable = "StringToBeVerifiedInAUnitTest"
$someVariable

Answer 3

Y a-t-il une chance que je puisse obtenir plus de clarté sur le passage des paramètres à la méthode Commands.AddScript ?

C:\Foo1.PS1 Bonjour la faim dans le monde C:\Foo2.PS1 Bonjour le monde

scriptFile = " C:\Foo1.PS1 "

parameters = "parm1 parm2 parm3" ... longueur variable des paramètres

Résolution de ce problème ... en passant null comme nom et le paramètre comme valeur dans une collection de CommandParameters.

voici ma fonction :

private static void RunPowershellScript(string scriptFile, string scriptParameters)
{
    RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();
    Runspace runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
    runspace.Open();
    RunspaceInvoke scriptInvoker = new RunspaceInvoke(runspace);
    Pipeline pipeline = runspace.CreatePipeline();
    Command scriptCommand = new Command(scriptFile);
    Collection<CommandParameter> commandParameters = new Collection<CommandParameter>();
    foreach (string scriptParameter in scriptParameters.Split(' '))
    {
        CommandParameter commandParm = new CommandParameter(null, scriptParameter);
        commandParameters.Add(commandParm);
        scriptCommand.Parameters.Add(commandParm);
    }
    pipeline.Commands.Add(scriptCommand);
    Collection<PSObject> psObjects;
    psObjects = pipeline.Invoke();
}

Answer 4

Vous pouvez aussi simplement utiliser le pipeline avec la méthode AddScript :

string cmdArg = ".\script.ps1 -foo bar"            
Collection<PSObject> psresults;
using (Pipeline pipeline = _runspace.CreatePipeline())
            {
                pipeline.Commands.AddScript(cmdArg);
                pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
                psresults = pipeline.Invoke();
            }
return psresults;

Elle prendra une chaîne de caractères, et les paramètres que vous lui passerez.

Answer 5

Voici une manière d'ajouter des paramètres au script si vous avez utilisé

pipeline.Commands.AddScript(Script);

Il s'agit d'utiliser un HashMap comme paramètres, la clé étant le nom de la variable dans le script et la valeur étant la valeur de la variable.

pipeline.Commands.AddScript(script));
FillVariables(pipeline, scriptParameter);
Collection<PSObject> results = pipeline.Invoke();

Et la méthode de la variable de remplissage est :

private static void FillVariables(Pipeline pipeline, Hashtable scriptParameters)
{
  // Add additional variables to PowerShell
  if (scriptParameters != null)
  {
    foreach (DictionaryEntry entry in scriptParameters)
    {
      CommandParameter Param = new CommandParameter(entry.Key as String, entry.Value);
      pipeline.Commands[0].Parameters.Add(Param);
    }
  }
}

de cette façon, vous pouvez facilement ajouter plusieurs paramètres à un script. J'ai aussi remarqué que si vous voulez obtenir une valeur d'une variable dans votre script comme ceci :

Object resultcollection = runspace.SessionStateProxy.GetVariable("results");

//résultat étant le nom de la v

tu devras le faire de la manière que j'ai montrée parce que pour une raison quelconque si tu le fais de la manière que Kosi2801 suggère la liste de variables script ne se remplit pas avec vos propres variables.