Using an answer file with a PowerShell script

开发者_开发百科I have a PowerShell script with a number of 'params' at the start:

param(
    [switch] $whatif,
    [string] $importPath = $(Read-Host "Full path to import tool"),
    [string] $siteUrl = $(Read-Host "Enter URL to create or update"),
    [int] $importCount = $(Read-Host "Import number")
)

Is there any way I can run this against an answer file to avoid entering the parameter values every time?

I am not getting the reason for the question. All you have to do to call your script is something like:

.\script.ps1 -whatif -importPath import_path -siteUrl google.com -importCount 1

The Read-Host are there as defaults, to be executed ( and then read and assign the values to the parameters ) only if you don't specify the values. As long you have the above comand ( saved in a file so that you can copy and paste into console or run from another script or whatever ), you don't have to enter the values again and again.

Start by setting the function or script up to accept pipeline input.

[CmdletBinding(SupportsShouldProcess=$True,ConfirmImpact='Low')]
param(
  [Parameter(Mandatory=$True,ValueFromPipelineByPropertyName=$True)]
  [string] $importPath,

  [Parameter(Mandatory=$True,ValueFromPipelineByPropertyName=$True)]
  [string] $siteUrl,

  [Parameter(Mandatory=$True,ValueFromPipelineByPropertyName=$True)]
  [int] $importCount
)

Notice that I removed your manually-created -whatif. No need for it - I'll get to it in a second. Also note that Mandatory=$True will make PowerShell prompt for a value if it isn't provided, so I removed your Read-Host.

Given the above, you could create an "answer file" that is a CSV file. Make an importPath column, a siteURL column, and an importCount column in the CSV file:

importPath,siteURL,importCount
"data","data",1
"x","y",2

Then do this:

Import-CSV my-csv-file.csv | ./My-Script

Assuming your script is My-Script.ps1, of course.

Now, to -whatif. Within the body of your script, do this:

if ($pscmdlet.shouldprocess($target)) {
  # do whatever your action is here
}

This assumes you're doing something to $target, which might be a path, a computer name, a URL, or whatever. It's the thing you're modifying in your script. Put your modification actions/commands inside that if construct. Doing this, along with the SupportsShouldProcess() declaration at the top of the script, will enable -whatif and -confirm support. You don't need to code those parameters yourself.

What you're building is called an "Advanced Function," or if it's just a script than I guess it'd be an "Advanced Script." Utilizing pipeline input parameters in this fashion is the "PowerShell way of doing things."

To my knowledge, Powershell doesn't have a built-in understanding of answer files. You'll have to pass them in somehow or read them yourself from the answer file.

Wrapper. You could write another script that calls this script with the same parameters you want to use every time. You could also make a wrapper script that reads the values from the answer file, then pass them in.

Optional Parameters. Or you could change the parameters to use defaults that indicate no parameters were passed, then check for a file of a specific name to read values from. If the file isn't found, then prompt for the values.

If the format of the answer file is flexible, (i.e., you're only going to be using it with this Powershell script), you could get much closer to the behavior of an actual answer file by writing it as a Powershell script itself and dot-sourcing it.

if (test-path 'myAnswerfile'){
    . 'myAnswerFile'
    #process whatever was sourced from the answer file, if necessary
} else {
    #prompt for values
}

It still requires removing the Read-Host calls from the parameters of the script.

Following on from Joel you could set up a different parameter set, based around the switch -answerfile.

If that's set the function will look for an answer file and parse though it - as he said you'll need to do that yourself. If it's not set and the others are then the functionis used with the parameters given. Minor benefit I see is that you can still have the parameters mandatory when used that way.

Matt