c# pdf viewer free : How to rearrange pdf pages reader Library software component asp.net wpf html mvc Windows%20Powershell%20in%20Action%202nd%20Edition33-part1487

300
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
As expected, the system responds with an error. For more information about the 
parameter-binding process, see section 2.5.2.
The ValueFromPipeline property
You saw earlier how to use 
$_
in the process block to handle pipeline objects. This 
approach works but makes it difficult to handle both pipeline and command-line 
bindings. The 
ValueFromPipeline
property greatly simplifies this. In the following 
example you’ll define a single parameter, 
$x
, that can take values from the command 
line and the pipeline:
PS (1) > function Test-ValueFromPipeline 
>> { 
>> 
>>     param([Parameter(ValueFromPipeline = $true)] $x) 
>>     process { $x } 
>> } 
>>
Now try it with the command line
PS (2) > Test-ValueFromPipeline 123 
123
and it works properly. Now try a pipelined value:
PS (3) > 123 | Test-ValueFromPipeline 
123
This also works properly. And, because you’re using the process block, you can handle 
a collection of values:
PS (4) > 1,2,3 | Test-ValueFromPipeline 
PS (5) >
The 
ValueFromPipeline
property allows you to tell the runtime to bind the entire 
object to the parameter. But sometimes you only want a property on the object. This 
is what the 
ValueFromPipelineByPropertyName
attribute is for, as you’ll see next.
The ValueFromPipelineByPropertyName property
Whereas 
ValueFromPipeline
caused the entire pipeline object to be bound to the 
parameter, the 
ValueFromPipelineByPropertyName
property tells the runtime to 
just use a property on the object instead of the whole object when binding the param-
eter. The name of the property to use comes from the parameter name. Let’s modify 
the previous example to illustrate this:
PS (19) > function Test-ValueFromPipelineByPropertyName 
>> { 
>>  param(
How to rearrange pdf pages reader - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
pdf page order reverse; change page order pdf reader
How to rearrange pdf pages reader - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
move pages in pdf online; move pages in pdf
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
301
>>   [Parameter(ValueFromPipelineByPropertyName=$true)] 
>>   $DayOfWeek 
>>  ) 
>>  process { $DayOfWeek } 
>> } 
>>
This function has one parameter, named 
DayOfWeek
, that’s bound from the pipeline 
by property name. Notice that you haven’t added a type constraint to this property, so 
any type of value will work. Let’s use the 
Get-Date
cmdlet to emit an object with a 
DayOfWeek
property:
PS (20) > Get-Date | Test-ValueFromPipelineByPropertyName 
Tuesday
This returns 
Tuesday
, so binding from the pipeline works fine. What happens when 
you bind from the command line?
PS (21) > Test-ValueFromPipelineByPropertyName (Get-Date) 
Tuesday, June 30, 2009 12:27:56 AM
This time you get the entire 
DateTime
object. Normal command-line binding isn’t 
affected by the attribute. To get the same result, you have to extract the property 
yourself:
PS (22) > Test-ValueFromPipelineByPropertyName ` 
>>  ((Get-Date).DayOfWeek)
Tuesday
That takes care of the single-value case. Now let’s look at the case where you have 
multiple values coming in:
PS (23) > $d = Get-Date
PS (24) > $d, $d.AddDays(1), $d.AddDays(2) | 
>>     Test-ValueFromPipelineByPropertyName 
>>
Tuesday 
Wednesday 
Thursday 
PS (25) >
Each inbound pipeline object is bound to the parameter by property name one at a 
time. Next, we’ll show how to handle variable numbers of arguments when using 
command metadata.
The ValueFromRemainingArguments property
You saw earlier that when you didn’t use any of the metadata annotations, excess argu-
ments ended up in the 
$args
variable. But once you add the metadata, the presence of 
excess arguments results in an error. Because it’s sometimes useful to allow a variable 
number  of parameters,  PowerShell provides the 
ValueFromRemainingArguments 
property, which tells the runtime to bind all excess arguments to this parameter. The
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
how to change page order in pdf document; move pages in a pdf file
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
how to reorder pages in pdf preview; how to move pages around in pdf
302
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
following example shows a function with two parameters. The first argument goes 
into the 
-First
parameter and the remaining arguments are bound to 
-Rest
:
PS (1) > function vfraExample 
>> { 
>>   param ( 
>>     $First, 
>>     [parameter(ValueFromRemainingArguments=$true)] $Rest 
>>   ) 
>>   "First is $first rest is $rest" 
>> } 
>>
Let’s run the function with four arguments:
PS (2) > vfraExample 1 2 3 4
First is 1 rest is 2 3 4
The first ends up in 
$first
with the remaining placed in 
$rest
. Now try using 
-Rest 
as a named parameter
PS (3) > vfraExample 1 -Rest 2 3 4 
vfraExample : A positional parameter cannot be found that a 
ccepts argument '3'.
At line:1 char:12 
+ vfraExample <<<<  1 -Rest 2 3 4
+ CategoryInfo          : InvalidArgument: (:) [vfraEx
ample], ParameterBindingException
+ FullyQualifiedErrorId : PositionalParameterNotFound,
vfraExample
and this fails. When the parameter is specified by name, it won’t receive the excess 
arguments and you’ll get an error. If you use the parameter by name, you have to pass 
the remaining arguments explicitly as a list, as shown here:
PS (4) > vfraExample 1 -Rest 2,3,4
First is 1 rest is 2 3 4 
PS (5) >
Now it works.
The HelpMessage property
The 
HelpMessage
property allows you to attach a short help message to the parame-
ter. This sounds like it should be useful but it isn’t really. This message is displayed 
only when prompting for a missing mandatory parameter. We’ll show you better ways 
to add help for your functions in section 8.4. Still, for completeness sake, let’s work 
through an example.
First, you need a function that has a mandatory parameter so the runtime will 
prompt if you don’t supply it. Also, make it an array so you can specify more than 
one object when prompted. Here’s the function:
PS (1) > function helpMessageExample 
>> {
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page directly. Moreover, when you get a PDF document which is out of order, you need to rearrange the PDF document pages. In these
rearrange pdf pages reader; pdf reverse page order preview
C# PowerPoint - How to Process PowerPoint
pages simply with a few lines of C# code. C# Codes to Sort Slides Order. If you want to use a very easy PPT slide dealing solution to sort and rearrange
rearrange pages in pdf; how to move pages in a pdf file
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
303
>>   param ( 
>>     [parameter(Mandatory=$true, 
>>         HelpMessage="An array of path names.")] 
>>     [string[]] 
>>     $Path 
>>   ) 
>>   "Path: $path" 
>> } 
>>
Now run it with no arguments so the system will prompt for the missing value:
PS (2) > helpMessageExample
cmdlet helpMessageExample at command pipeline position 1 
Supply values for the following parameters: 
(Type !? for Help.)
Path[0]: !?
An array of path names.
Path[0]: fo 
Path[1]: bar 
Path[2]: 
Path: fo bar 
PS (3) >) 
When prompted, you can enter 
!?
to see the help message giving you more informa-
tion about the type of thing you’re supposed to enter. 
And with that, we’re finished with our discussion of the 
Parameter
attribute and 
its properties. But we’re not finished with parameter attributes quite yet. The next 
thing to look at is the 
Alias
attribute. This is a pretty simple feature, but it has a 
couple of important uses.
8.2.5
Creating parameter aliases with the Alias attribute
The 
Alias
attribute allows you to specify alternate names for a parameter. It’s typi-
cally used to add a well-defined shortcut for that parameter. Here’s why this is impor-
tant. If you’ll recall our parameter discussion in chapter 2, we said that you only have 
to specify enough of a parameter name to uniquely identify it. Unfortunately, there’s 
a problem with that approach and that’s versioning the command over time. By ver-
sioning we mean being able to add new capabilities to future versions of a command 
in such a way that older scripts using this command aren’t broken. If you add a new 
parameter to a command that has the same prefix as an existing parameter, you now 
need a longer prefix to distinguish the name. Any scripts that used the old short pre-
fix would fail because they’d be unable to distinguish which parameter to use. This is 
where the 
Alias
attribute comes in. It can be used to add distinctive and mnemonic 
short forms for parameters. 
Let’s look  at  an example.  The  following  function  defines  a single parameter: 
-ComputerName
. You’ll give this parameter an alias: 
-CN
. Here’s the function definition:
PS (1) > function Test-ParameterAlias 
>> {
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages in extracting single or multiple Word pages at one & profession imaging controls, PDF document, image
reorder pages pdf file; change pdf page order preview
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
change page order in pdf reader; reverse pdf page order online
304
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
>>     param ( 
>>         [alias("CN")] 
>>         $ComputerName 
>>     ) 
>>     "The computer name is $ComputerName" 
>> } 
>>
When you run it using the full parameter name, it works as expected:
PS (2) > Test-ParameterAlias -ComputerName foo 
The computer name is foo
And, of course, it also works with the alias:
PS (3) > Test-ParameterAlias -CN foo 
The computer name is foo
Now try a prefix of the 
-ComputerName
parameter:
PS (4) > Test-ParameterAlias -com foo 
The computer name is foo
And it too works fine. Next, create a new version of the command. Add a new para-
meter: 
-Compare
. Here’s the new function definition:
PS (5) > function Test-ParameterAlias 
>> { 
>>     param ( 
>>         [alias("CN")] 
>>         $ComputerName, 
>>         [switch] $Compare 
>>     ) 
>>     "The computer name is $ComputerName, compare=$compare 
>> } 
>>
Try running the command with the parameter prefix 
-Com
again:
PS (6) > Test-ParameterAlias -Com foo 
Test-ParameterAlias : Parameter cannot be processed because
the parameter name 'Com' is ambiguous. Possible matches in 
clude: -ComputerName -Compare.
At line:1 char:20 
+ Test-ParameterAlias <<<<  -Com foo
+ CategoryInfo          : InvalidArgument: (:) [Test-P
arameterAlias], ParameterBindingException
+ FullyQualifiedErrorId : AmbiguousParameter,Test-Para
meterAlias
This time you get an error because 
-com
could refer to either parameter. But if you 
use the 
-CN
alias
PS (7) > Test-ParameterAlias -CN foo 
The computer name is foo, compare=False 
PS (8) >  
it works. 
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods and powerful & profession imaging controls, PDF document, image
move pages in a pdf; how to rearrange pdf pages reader
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
305
Another scenario where you might add an alias is when you’re also using the 
ValueFromPipelineByPropertyName
property on the 
Parameter
attribute. There 
are a number of places where the objects you’re working with have similar parameters 
with different names. For example, the file system objects returned by 
dir
have a 
Name
property, whereas the objects returned by 
Get-Process
have a 
ProcessName 
property. If you wanted to create a function that worked with both of these types, 
you could have a parameter named 
Name
with an alias 
ProcessName
. How about also 
working with services? The objects returned from 
Get-Service
have a 
ServiceName 
property. No problem—just add another alias for 
ServiceName
. In practice, there’s 
no limit to the number of aliases that can be assigned to a parameter.
Now let’s look at the last type of parameter metadata: the validation attributes 
that let you constrain the parameter values in much more interesting ways than just 
by type.
8.2.6
Parameter validation attributes
The last class of parameter attributes we’ll cover are the parameter validation attri-
butes. You already know how to add a type constraint to a parameter where you 
require that the argument be of a particular type. The parameter validation attributes 
allow you to specify additional constraints on the argument to a parameter. The avail-
able parameter validation attributes are shown in figure 8.7. 
In many cases these constraints seem like trivial functions (and mostly they are), 
but they’re valuable for a couple of reasons:
• They  declare  the  parameter 
contract
 This  means  that  by  inspecting  the 
parameter  declaration,  you  can  see  what  constraints  are  present.  This  also 
means that other tools can work with this information as well to drive Intelli-
Sense-like features.
[AllowNull()]
[AllowEmptyString()] 
[AllowEmptyCollection()]
[ValidateNotNull()]
[ValidateNotNullOrEmpty()]
[ValidateCount(min, max)]
[ValidateLength(min, max)]
[ValidatePattern(pattern)]
[ValidateRange(min, max)]
[ValidateSet(set of values…)]
[ValidateScript({scriptblock}
)]
Attributes that control how null or
empty parameters are handled 
Attributes that validate string
lengths or array element counts
Attributes that validate argument values
against numeric ranges, regular expression 
patterns, or explicit sets of values 
Performs custom validation
actions by specifying a scriptblock
Figure 8.7 The validation attributes can be applied to script and function parameters to 
specify additional parameter checks to perform when binding arguments.
306
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
• You don’t have to write any error-handling code. By specifying the attribute, 
you’re declaring the constraint, and the runtime takes care of doing the work of 
checking the value for you. Because the PowerShell runtime does the check, it 
can generate standardized error messages, translated into whatever language the 
user’s environment is configured for. It’s a pretty nifty feature. 
The other interesting thing is that the set of attributes isn’t fixed; a .
NET
programmer 
can create new attributes by deriving from the existing base classes. Although this isn’t 
possible in the PowerShell language yet, you do have 
ValidateScript
, which lets 
you do similar things. We’ll get to that once we cover the other attributes that are 
available.
Validation attribute: AllowNull 
The 
AllowNull
attribute should only makes sense if the associated parameter is 
marked as mandatory. This is because, by default, mandatory parameters don’t allow 
you to pass 
$null
to them. If this attribute is specified, the check is suppressed and 
$null
can be passed to the parameter. The 
AllowNullExample
function in the 
example shows how this might be used: 
function allowNullExample 
{
param
(
[parameter(Mandatory=$true)]
[AllowNull()]
$objectToTest
)
$objectToTest -eq $null 
)
Validation attribute: AllowEmptyString 
The 
AllowEmptyString
attribute is a variation on the 
AllowNull
attribute. Manda-
tory parameters won’t permit empty strings to be passed either. You should specify 
this attribute if, for some unknown reason, you want to allow your function or script 
to have to deal with empty strings in mandatory parameters.
NOTE
It’s pretty hard to think of a good case where you want to allow 
$null
or an empty argument to be passed to a function. If you do this 
but don’t have correct code in your function or script implementation, 
your  users  may  find  themselves  having  to  debug 
NullReference 
exceptions. Not a nice thing to do to your users. 
Validation attribute: AllowEmptyCollection
This is the last variation on the attributes that are used with mandatory parameters to 
disable some of the default checks. The 
AllowEmptyCollection
attribute allows an 
empty collection as the argument of a mandatory parameter.
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
307
Validation attribute: ValidateNotNull
The 
ValidateNotNull
attribute is the opposite of 
AllowNull
. This attribute turns 
on the check for 
$null
if the parameter isn’t mandatory. The following example 
shows the use of this attribute with a nonmandatory parameter:
function validateNotNullExample 
{
param
(
[ValidateNotNull()]
$objectToTest
)
$objectToTest -eq $null 
Validation attribute: ValidateNotNullOrEmpty 
The 
ValidateNotNullOrEmpty
attribute specifies that the argument of the parame-
ter isn’t permitted to  be set to 
$null
, an empty string, or an empty array. 
Validation attribute: ValidateCount
The 
ValidateCount
attribute specifies the minimum and maximum number of val-
ues that can be passed to an array parameter. The runtime generates an error if the 
number of elements in the argument is outside the range. In the following example, 
one parameter, 
$pair
, requires exactly two values:
PS (1) > function validateCountExample 
>> { 
>>   param ( 
>>     [int[]] [ValidateCount(2,2)] $pair 
>>   ) 
>>   "pair: $pair" 
>> } 
>>
Try the function with one argument:
PS (2) > validateCountExample 1 
validateCountExample : Cannot validate argument on paramete 
r 'pair'. The number of supplied arguments (1) is less than
the minimum number of allowed arguments (2). Specify more 
than 2 arguments and then try the command again.
At line:1 char:21 
+ validateCountExample <<<<  1
+ CategoryInfo          : InvalidData: (:) [validateCo
untExample], ParameterBindingValidationException
+ FullyQualifiedErrorId : ParameterArgumentValidationE
rror,validateCountExample
You get the expected error. Next, pass in a pair of numbers:
PS (3) > validateCountExample 1,2 
pair: 1 2
308
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
That works. Finally, pass in three numbers:
PS (4) > validateCountExample 1,2,3 
validateCountExample : Cannot validate argument on paramete 
r 'pair'. The number of supplied arguments (3) exceeds the 
maximum number of allowed arguments (2). Specify less than 
2 arguments and then try the command again.
At line:1 char:21 
+ validateCountExample <<<<  1,2,3
+ CategoryInfo          : InvalidData: (:) [validateCo
untExample], ParameterBindingValidationException
+ FullyQualifiedErrorId : ParameterArgumentValidationE
rror,validateCountExample 
Again, you get an error.
Validation attribute: ValidateLength 
The 
ValidateLength
attribute can only be used with strings or arrays of strings. It 
allows you to specify the minimum and maximum length of the argument strings. If 
the argument is an array of strings, each element of the array will be checked. In the 
following example, the specified computer names must have 1 to 10 characters: 
function validateLengthExample 
{
param (
[string][ValidateLength(8,10)] $username
)
$userName 
}
Validation attribute: ValidatePattern
The 
ValidatePattern
attribute allows you to specify a regular expression to use to 
validate the argument string. For example, the 
$hostName
parameter in the following 
function must start with a letter from a to z followed by one to seven digits:
PS (1) > function validatePatternExample 
>> { 
>>   param ( 
>>     [ValidatePattern('^[a-z][0-9]{1,7}$')] 
>>     [string] $hostName 
>>   ) 
>>   $hostName 
>> } 
>>
Try it with a valid string:
PS (2) > validatePatternExample b123 
b123
It returns the argument with no error. Now try an invalid argument that has too 
many numbers:
PS (3) > validatePatternExample c123456789 
validatePatternExample : Cannot validate argument on parame
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
309
ter 'hostName'. The argument "c123456789" does not match th 
e "^[a-z][0-9]{1,7}$" pattern. Supply an argument that matc 
hes "^[a-z][0-9]{1,7}$" and try the command again.
At line:1 char:23 
+ validatePatternExample <<<<  c123456789
+ CategoryInfo          : InvalidData: (:) [validatePa
tternExample], ParameterBindingValidationException
+ FullyQualifiedErrorId : ParameterArgumentValidationE
rror,validatePatternExample 
You get an error as expected. Unfortunately, the error message isn’t helpful—all it 
reports is the pattern that failed but not why it failed or what the intent of the pattern 
was. This limits the usefulness of this attribute.
Validation attribute: ValidateRange 
The 
ValidateRange
attribute allows you to constrain the range of a numeric argu-
ment. This means that instead of just saying the argument must be an integer, you 
can say that it must be an integer in the range 1 through 10, as shown here:
PS (1) > function validateRangeExample 
>> { 
>>   param ( 
>>     [int[]][ValidateRange(1,10)] $count 
>>   ) 
>>   $count 
>> } 
>>
As  you saw with the 
ValidateLength
attribute for strings, this attribute can be 
applied to a collection, in which case it will validate each member of the collection:
PS (2) > validateRangeExample 1 
PS (3) > validateRangeExample 1,2,3 
3
These two examples return no error because all the members are within range. Now 
try one with a member outside the range:
PS (4) > validateRangeExample 1,2,3,22,4 
validateRangeExample : Cannot validate argument on paramete 
r 'count'. The 22 argument is greater than the maximum allo 
wed range of 10. Supply an argument that is less than 10 an 
d then try the command again.
At line:1 char:21 
+ validateRangeExample <<<<  1,2,3,22,4
+ CategoryInfo          : InvalidData: (:) [validateRa
ngeExample], ParameterBindingValidationException
+ FullyQualifiedErrorId : ParameterArgumentValidationE
rror,validateRangeExample
PS (5) >
It fails, indicating the value that couldn’t be processed.
Documents you may be interested
Documents you may be interested