Kjør Powershell script fra C # med kommandolinje argumenter

stemmer
85

Jeg trenger å utføre en Powershell script innenfra C #. Skriptet må kommandolinjeargumenter.

Dette er hva jeg har gjort så langt:

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();

skripfila inneholder noe sånt som C: \ Program Files \ MyProgram \ Whatever.ps1.

Skriptet bruker en kommandolinje argument som -tasten Value, mens verdien kan være noe sånt som en bane som også kan inneholde mellomrom.

Jeg får ikke dette til å fungere. Er det noen som vet hvordan de skal passere kommandolinjeargumenter til en Powershell script innenfra C # og sørge for at plassene er ikke noe problem?

Publisert på 09/02/2009 klokken 09:21
kilden bruker
På andre språk...                            


7 svar

stemmer
95

Prøv å lage skripfila som en egen kommando:

Command myCommand = new Command(scriptfile);

så kan du legge til parametre med

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

og endelig

pipeline.Commands.Add(myCommand);

Her er den komplette, redigert kode:

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();
Svarte 09/02/2009 kl. 10:15
kilden bruker

stemmer
4

Du kan også bare bruke rørledningen med AddScript Metode:

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;

Det vil ta en streng, og hva parametere du passere den.

Svarte 09/02/2009 kl. 22:48
kilden bruker

stemmer
7

Noen sjanse jeg kunne få mer klarhet på bestått params til Commands.AddScript metoden?

C: \ Foo1.PS1 Hello World Hunger C: \ Foo2.PS1 Hello World

skripfila = "C: \ Foo1.PS1"

parametre = "parm1 parm2 parm3" ... variabel lengde av parametere

Løst dette ... passerer null som navnet og param som verdi i en samling av CommandParameters

Her er min funksjon:

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();
}
Svarte 10/12/2009 kl. 21:03
kilden bruker

stemmer
3

Her er en måte å legge Parametere til skriptet hvis du brukte

pipeline.Commands.AddScript(Script);

Dette er med å bruke en HashMap som paramaters nøkkelen er navnet på variabelen i skriptet og verdien er verdien av variabelen.

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

Og fyll variable metoden er:

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);
    }
  }
}

denne måten kan du enkelt legge til flere parametre til et skript. Jeg har også lagt merke til at hvis du ønsker å få en verdi fra en variabel i deg script som så:

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

// resultater er navnet på v

du må gjøre det på den måten jeg viste fordi en eller annen grunn hvis du gjør det på den måten Kosi2801 antyder script variabler listen ikke blir fylt med dine egne variabler.

Svarte 01/12/2010 kl. 10:01
kilden bruker

stemmer
26

Jeg har en annen løsning. Jeg vil bare teste om gjennomføring av en Powershell script lykkes, fordi kanskje noen kan endre politikken. Som argument, jeg bare angi banen til skriptet som skal utføres.

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));

Med innholdet i manuset er:

$someVariable = "StringToBeVerifiedInAUnitTest"
$someVariable
Svarte 23/12/2010 kl. 16:43
kilden bruker

stemmer
2

For meg er den mest fleksible måten å kjøre Powershell script fra C # brukte PowerShell.Create (). AddScript ()

Tekstutdraget av koden er

string scriptDirectory = Path.GetDirectoryName(
    ConfigurationManager.AppSettings["PathToTechOpsTooling"]);

var script =    
    "Set-Location " + scriptDirectory + Environment.NewLine +
    "Import-Module .\\script.psd1" + Environment.NewLine +
    "$data = Import-Csv -Path " + tempCsvFile + " -Encoding UTF8" + 
        Environment.NewLine +
    "New-Registration -server " + dbServer + " -DBName " + dbName + 
       " -Username \"" + user.Username + "\" + -Users $userData";

_powershell = PowerShell.Create().AddScript(script);
_powershell.Invoke<User>();
foreach (var errorRecord in _powershell.Streams.Error)
    Console.WriteLine(errorRecord);

Du kan sjekke om det er noen feil ved å sjekke Streams.Error. Det var veldig nyttig å sjekke samlingen. Brukeren er den type objekt Powershell script returnerer.

Svarte 09/07/2014 kl. 13:48
kilden bruker

stemmer
2

Mine er litt mer mindre og enklere:

/// <summary>
/// Runs a PowerShell script taking it's path and parameters.
/// </summary>
/// <param name="scriptFullPath">The full file path for the .ps1 file.</param>
/// <param name="parameters">The parameters for the script, can be null.</param>
/// <returns>The output from the PowerShell execution.</returns>
public static ICollection<PSObject> RunScript(string scriptFullPath, ICollection<CommandParameter> parameters = null)
{
    var runspace = RunspaceFactory.CreateRunspace();
    runspace.Open();
    var pipeline = runspace.CreatePipeline();
    var cmd = new Command(scriptFullPath);
    if (parameters != null)
    {
        foreach (var p in parameters)
        {
            cmd.Parameters.Add(p);
        }
    }
    pipeline.Commands.Add(cmd);
    var results = pipeline.Invoke();
    pipeline.Dispose();
    runspace.Dispose();
    return results;
}
Svarte 11/09/2015 kl. 15:43
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more