c# pdf viewer free : How to move pages within a pdf document application software utility azure windows wpf visual studio Windows%20Powershell%20in%20Action%202nd%20Edition32-part1486

290
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
significant feature: it means that you get standard, complete, and consistent error 
messages that are already set up to display in many languages.
Now let’s look at the properties that can be specified for the 
CmdletBinding 
attribute. These properties are shown in figure 8.4.
We’ll describe what each of these properties does and how to use them in the next 
few subsections.
The SupportsShouldProcess property
When the 
SupportsShouldProcess
property is set to true, it tells the runtime to 
enable the 
-Confirm
and 
-WhatIf
standard parameters because the function prom-
ises to make the necessary calls to the 
ShouldProcess()
method on the object in the 
$PSCmdlet 
variable. The 
ShouldProcess()
method is used to either ask the user 
for feedback before proceeding with the operation or to show what the operation 
might have done to the system. The 
$PSCmdlet
variable is an automatic variable that 
provides the callback mechanisms that the function needs to make the expected calls. 
(We’ll cover the 
$PSCmdlet
variable in more detail at the end of this section.) Let’s 
write an example function that shows how it all works. The purpose of this function 
is to allow the user to stop processes on the system. Because stopping the wrong pro-
cess could have undesirable consequences, you want to be able to use 
-Confirm
and 
–WhatIf 
parameters. The example code is shown in figure 8.5 with the necessary 
annotations highlighted.
This function uses the 
Win32_Process
WMI class to get objects representing 
processes on the system (see chapter 19 for more information about 
WMI
). You filter 
the set of processes using the 
Where-Object
cmdlet and then call the 
Terminate() 
method on the process object. Obviously this is a potentially destructive operation, so 
you want to call the 
ShouldProcess()
method before proceeding with the action 
(you  saw  this  behavior  with  the 
Set-ExecutionPolicy
cmdlet). You call this
[CmdletBinding( 
DefaultParameterSet="parametersetname", 
ConfirmImpact=$true,
SupportsShouldProcess=$true, 
)]
CmdletBinding attribute
Tells interpreter that script or function
implements ShouldProcess pattern
Sets default
parameter set name
List of arguments to
attribute
Controls whether confirm-impact
processing should be performed
Figure 8.4 All the properties that can be specified for the 
CmdletBinding
attribute. 
These properties are used by the PowerShell runtime to control the execution of the 
associated function or script.
How to move pages within a pdf document - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
pdf reorder pages online; pdf change page order
How to move pages within a pdf document - 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
how to reorder pages in pdf file; how to reorder pdf pages
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
291
method passing two 
[string]
arguments. The first argument is used to tell the user 
what object you’re going to operate on. The second argument describes the operation 
to be performed—essentially an operation caption. If this method returns true, you 
call 
Terminate()
to end the process. Let’s try it. First, define the function:
PS (1) > function Stop-ProcessUsingWMI 
>> { 
>>     [CmdletBinding(SupportsShouldProcess=$True)] param( 
>>         [parameter(mandatory=$true)] [regex] $pattern 
>>     ) 
>>     foreach ($process in Get-WmiObject Win32_Process | 
>>         where { $_.Name -match $pattern }) 
>>     { 
>>         if ($PSCmdlet.ShouldProcess( 
>>             "process $($process.Name) " + 
>>             " (id: $($process.ProcessId))" , 
>>             "Stop Process")) 
>>         { 
>>             $process.Terminate() 
>>         } 
>>     } 
>> } 
>>
Next, start a Notepad process:
PS (2) > notepad
function Stop-ProcessUsingWMI
{
[CmdletBinding(SupportsShouldProcess=$True)] param(
[regex] $pattern = "notepad" 
foreach ($process in Get-WmiObject Win32_Process |
where {$_.Name -match $pattern})
{
if ($PSCmdlet.ShouldProcess( 
"process $($process.Name)(id: $($process.ProcessId))",
"Stop Process"))
{
$process.Terminate()
}
}
}
CmdletBinding must precede param statement
Function must call 
ShouldProcess()
method
If call to ShouldProcess() returns
true, execute action
Action message
Caption for prompting
Figure 8.5 The function annotations needed to enable 
ShouldProcess
support. The 
SupportsShouldProcess 
property of the 
CmdletBinding
attribute should be set to 
true, and there must be a call to the 
ShouldProcess()
method in the body of the code.
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Able to add and insert one or multiple pages to existing adobe PDF document of adding and inserting a new blank page to the existing PDF document within a well
how to rearrange pdf pages in preview; pdf reorder pages
C# PowerPoint - How to Process PowerPoint
It enables you to move out useless PowerPoint document pages simply with a dealing solution to sort and rearrange PowerPoint slides order within C#.NET
reordering pdf pages; reordering pages in pdf
292
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
Now call 
Stop-ProcessUsingWMI
, specifying the 
-WhatIf
parameter:
PS (3) > Stop-ProcessUsingWMI notepad -Whatif 
What if: Performing operation "Stop Process" on Target "proc 
ess notepad.exe  (id: 6748)".
You see a description of the operation that would be performed. The 
-WhatIf
option 
was only supposed to show what it would have done but not actually do it, so you’ll 
use 
Get-Process
to verify that the command is still running:
PS (4) > Get-Process notepad | ft name,id -auto
Name      Id 
----      --
notepad 6748
Let’s perform the operation again but this time use the 
-Confirm
flag. This requests 
that you be prompted for confirmation before executing the operation. When you get 
the prompt, you’ll respond 
y
to continue with the operation:
PS (5) > Stop-ProcessUsingWMI notepad -Confirm
Confirm
Are you sure you want to perform this action? 
Performing operation "Stop Process" on Target "process 
notepad.exe  (id: 6748)".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All
[S] Suspend[?] Help (default is "Y"): y
__GENUS          : 2 
__CLASS          : __PARAMETERS 
__SUPERCLASS     : 
__DYNASTY        : __PARAMETERS 
__RELPATH        : 
__PROPERTY_COUNT : 1 
__DERIVATION     : {} 
__SERVER         : 
__NAMESPACE      : 
__PATH           : 
ReturnValue      : 0
And the operation was performed. Use 
Get-Process
to confirm that the Notepad 
process no longer exists:
PS (6) > Get-Process notepad | ft name,id -auto 
Get-Process : Cannot find a process with the name "notepad" 
. Verify the process name and call the cmdlet again.
At line:1 char:12 
+ get-process <<<<  notepad | ft name,id -auto
+ CategoryInfo          : ObjectNotFound: (notepad:Str
ing) [Get-Process], ProcessCommandException
+ FullyQualifiedErrorId : NoProcessFoundForGivenName,M
icrosoft.PowerShell.Commands.GetProcessCommand
PS (7) >
C# Word - Process Word Document in C#
It enables you to move out useless Word document pages simply with a You are capable of extracting pages from Microsoft Word document within C#.NET
reorder pages in a pdf; how to move pages in pdf converter professional
C# TIFF: C#.NET Code to Process TIFF, RasterEdge XDoc.Tiff for .
are: TIFF, JPEG, GIF, BMP, PNG, PDF, Word and to program more personalized TIFF document manipulating solutions & a high-level model of the pages within a Tiff
how to move pdf pages around; how to reorder pages in a pdf document
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
293
Using the 
ShouldProcess
mechanism in your scripts and functions when they’ll 
perform destructive operations is a scripting best practice. Although it requires a bit 
of effort on the script author’s part, it adds tremendous value for the script user.
The $PSCmdlet variable
As mentioned earlier, the 
$PSCmdlet
variable gives the script or function author the 
necessary callbacks and properties  needed to be able  to take advantage of all  the 
advanced function features. As well as being able to call 
ShouldProcess()
, this vari-
able gives you access to the parameter set name through the 
$PSCmdlet.Parameter-
SetName
property. It allows you to halt a pipeline containing this command by calling 
the 
$PSCmdlet.ThrowTerminatingError()
method. It basically makes all the fea-
tures available to compiled cmdlet writers available to script and function authors. 
Refer to the PowerShell 
SDK
documentation to get complete details on the features 
available through 
$PSCmdlet
. For now, we’ll continue with our discussion of the prop-
erties on the 
CmdletBinding
attribute.
The ConfirmImpact property
This is an extension on the idea of ”should process.” Not all commands have the 
same consequences,  so  you  have  a  way to  indicate  this  with  this  property. The 
ConfirmImpact
property specifies when the action of the function should be con-
firmed by calling the 
ShouldProcess()
method. The call to the 
ShouldProcess() 
method displays a confirmation prompt only when the 
ConfirmImpact
argument is 
equal to or greater than the value of the 
$ConfirmPreference
preference variable. 
(The default value of the argument is 
Medium
.) Obviously this property should be 
used only when 
SupportsShouldProcess
is also specified.
The DefaultParameterSetName property
The 
DefaultParameterSetName
property specifies the name of the parameter set 
that the runtime will use if it can’t figure out the parameter set from the specified 
parameters. We’ll look at this a bit more when we cover the parameter metadata.
This completes our discussion of the 
CmdletBinding
attribute and the properties 
that apply to the function or script as a whole. Next, we’ll explore the other attribute 
that can be applied to function or script: 
OutputType
.
8.2.3
The OutputType attribute
The 
OutputType
attribute allows you to declare the expected return type of a func-
tion or script. Like the 
CmdletBinding
attribute, this attribute applies to the whole 
function. In PowerShell  v2, this attribute  doesn’t affect the output type and isn’t 
checked by the runtime at any point. What it does do is allow you to document the 
expected return type in such a way that tools like editors can use it to do things like 
provide IntelliSense for the next cmdlet to add to a pipeline. In this scenario, the edi-
tor would show the list of cmdlets that take the previous output type as an input.
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract View PDF document in continuous pages display mode Search text within file by using Ignore case or
reorder pages in pdf document; reverse page order pdf online
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy View PDF document in continuous pages display mode. Search text within file by using Ignore case or
how to move pages around in pdf file; reordering pages in pdf document
294
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
NOTE
They could, but this feature was added late in the v2 ship cycle 
and Microsoft didn’t have time to make use of it in either the ISE or 
the console host. Some of the third-party editors may be able to use it.
Specifying the return type sounds like it should be easy, but functions may return 
more than one type. In fact, some cmdlets like 
Where-Object
can return any type 
because they just return what they were passed. A more common and manageable 
case occurs when you have different types of objects being returned when different 
parameters sets are used: 
PS (1) > function Test-OutputType 
>> { 
>>   [CmdletBinding(DefaultParameterSetName = "1nt")] 
>>   [OutputType("asInt", [int])] 
>>   [OutputType("asString", [string])] 
>>   [OutputType("asDouble", ([double], [single]))] 
>>   [OutputType("lie", [int])] 
>>   param ( 
>>     [parameter(ParameterSetName="asInt")] [switch] $asInt, 
>>     [parameter(ParameterSetName="asString")] [switch] $asString, 
>>     [parameter(ParameterSetName="asDouble")] [switch] $asDouble, 
>>     [parameter(ParameterSetName="lie")] [switch] $lie 
>>  ) 
>>  Write-Host "Parameter set: $($PSCmdlet.ParameterSetName)" 
>>  switch ($PSCmdlet.ParameterSetName) { 
>>      "asInt" { 1 ; break } 
>>      "asString" { "1" ; break } 
>>      "asDouble" { 1.0 ; break } 
>>      "lie" { "Hello there"; break } } 
>> } 
>>
Now let’s try out each of the different switches:
PS (2) > (Test-OutputType -asString).GetType().FullName 
Parameter set: asString 
System.String 
PS (3) > (Test-OutputType -asInt).GetType().FullName 
Parameter set: asInt 
System.Int32 
PS (4) > (Test-OutputType -asDouble).GetType().FullName 
Parameter set: asDouble 
System.Double
Okay—everything is as expected; in each case the correct type was returned. Now use 
the 
-lie
parameter:
PS (5) > (Test-OutputType -lie).GetType().FullName 
Parameter set: lie 
System.String
Even though you specified the 
OutputType
to be 
[int]
, the function returned a 
string. As we said, the attribute is only documentation—it doesn’t enforce the type.
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
NET solution that supports converting each PDF page to Word document file by VB.NET code. All PDF pages can be converted to separate Word files within a short
how to move pages in pdf; reorder pages in pdf reader
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
When converting PDF document to TIFF image using VB.NET program, do you know about a flexible raster image format for handling images and data within a single
how to reorder pdf pages in reader; move pages in pdf acrobat
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
295
So, if it’s just documentation, then at least there must be an easy way to get at it, 
right? Well, unfortunately that’s not the case either. This is another feature that was 
added right at the end of the ship cycle. As a consequence, there’s no real interface to 
get this information. Instead, you have to look at the compiled attributes directly to 
see the values. For functions and scripts, you can retrieve this information from the 
scriptblock that defines the function body. This looks like
PS (6) > (Get-Command Test-OutputType).ScriptBlock.Attributes | 
>>   Select-Object typeid, type | 
>>   Format-List 
>>
TypeId : System.Management.Automation.CmdletBindingAttribute 
type   :
TypeId : System.Management.Automation.OutputTypeAttribute 
Type   : {asInt, int}
TypeId : System.Management.Automation.OutputTypeAttribute 
Type   : {asString, string}
TypeId : System.Management.Automation.OutputTypeAttribute 
Type   : {asDouble, System.Double System.Single}
TypeId : System.Management.Automation.OutputTypeAttribute 
Type   : {lie, int}
For cmdlets, it’s even less friendly because you have to go through the .NET type that 
was used to define the cmdlet. Here’s what that looks like:
PS (9) > $ct = (Get-Command Get-Command).ImplementingType 
PS (10) > $ct.GetCustomAttributes($true) | 
>>   Select-Object typeid, type | 
>>   Format-List 
>>
TypeId : System.Management.Automation.CmdletAttribute 
type   :
TypeId : System.Management.Automation.OutputTypeAttribute 
Type   : {System.Management.Automation.AliasInfo, System.Management.A
utomation.ApplicationInfo, System.Management.Automation.Func
tionInfo, System.Management.Automation.CmdletInfo...}
At this point, you might be saying, “Why bother to specify this?” The answer is that 
good scripts will last beyond any individual release of PowerShell. This information is 
somewhat useful now and will probably be much more useful in the future. As a best 
practice, it’s strongly recommended that this information be included in scripts that 
you want to share with others.
Something we skipped over in the 
OutputType
example was the 
Parameter
attri-
bute. We used it but didn’t actually talk about what it does. We’ll remedy this in the 
next section. 
VB.NET Image: VB Code to Read and Recognize EAN-13 Barcode from
Within document management library in VB platform, users can read and EAN-13 from MS Word and PDF document page, in notice, don't forget to move your activated
reorder pages in pdf preview; change pdf page order reader
C# Image: C# Code to Encode & Decode JBIG2 Images in RasterEdge .
images codec into PDF documents for a better PDF compression; RasterEdge JBIG2 codec SDK controls within C# project Move license text to the new project folder
move pages in pdf file; pdf reverse page order
296
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
8.2.4
Specifying parameter attributes
We specify additional information  on parameters using the 
Parameter
attribute. 
This information is used to control how the parameter is processed. The attribute is 
placed before the parameter definition, as shown in figure 8.6. 
As was the case with the 
CmdletBinding
attribute, specific behaviors are con-
trolled through a set of properties provided as “arguments” to the attribute. Although 
figure 8.6 shows all the properties that can be specified, you only have to provide the 
ones you want to set to something other than the default value. Let’s look at an exam-
ple first and then go through each of the properties.
The  following  example  shows a  parameter  declaration that defines the  -
Path 
parameter. Say you want the parameter to have the following characteristics:
• It’s mandatory—that is, the user must specify it or there’s an error.
• It takes input from the pipeline.
• It requires its argument to be convertible to an array of strings.
The parameter declaration needed to do all of this looks like
param (
[parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string[]] $Parameter 
)
The result is fairly simple because you only need to specify the things you want to 
change. All other properties keep their default values. In the next few sections, we’ll 
look at each of the possible properties, what it does, and how it can be used.
[Parameter(Mandatory=$true, 
Position=0, 
ParameterSetName="set1",
ValueFromPipeline=$false, 
ValueFromPipelineByPropertyName=$true,
ValueFromRemainingArguments=$false,
HelpMessage="some help this is")]
[int] 
$p1 = 0
Parameter is positional,
ocupying position 1 in 
parameter set set1
Property indicating this
parameter is required
Attribute specifying
parameter metadata 
Parameter set this
parameter belongs to
Can’t take argument
from pipeline as is
Can take argument from
a property on object 
coming from  pipeline 
Won’t consume remaining
unbound arguments
Constrains parameter
to be an integer
Parameter’s name is 
p1; initialized to 0
Figure 8.6 This figure shows how the 
Parameter
attribute is used when declaring a variable. 
The attribute must appear before that variable name and its optional initializer expression. The 
figure includes all the properties that can be set on the parameter.
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
297
The Mandatory property
By default, all function and script parameters are optional, which means that the 
caller of the command doesn’t have to specify them. If you want to require that the 
parameter be specified, set the 
Mandatory
property in the 
Parameter
attribute to 
$true
 otherwise,  if  the  property  is  absent  or  set  to 
$false
 the  parameter  is 
optional. The following example shows the declaration of a parameter that’s required 
when the function is run:
PS (1) > function Test-Mandatory 
>> { 
>>     param ( [Parameter(Mandatory=$true)] $myParam) 
>>     $myParam 
>> } 
>>
Now run this function without a parameter:
PS (2) > Test-Mandatory
cmdlet Test-Mandatory at command pipeline position 1 
Supply values for the following parameters: 
myParam: HELLO THERE 
HELLO THERE 
PS (3) >
The PowerShell runtime notices that a mandatory parameter wasn’t specified on the 
command line, so it prompts the user to specify it, which we do. Now the function 
can run to completion.
The Position property
You saw earlier in this chapter that all parameters are both positional and named by 
default. When using advanced parameter specification metadata, either adding the 
CmdletBinding
attribute to the whole function or specifying an individual 
Parameter 
attribute, parameters remain positional by default, until you specify a position for at 
least one of them. Once you start formally specifying positions, all parameters default 
to nonpositional unless the 
Position
property for that parameter is set. The following 
example shows a function with two parameters, neither one having 
Position
set:
PS (1) > function Test-Position 
>> { 
>>   param ( 
>>     [parameter()] $p1 = 'p1 unset', 
>>     $p2 = 'p2 unset' 
>>   ) 
>>   "p1 = '$p1' p2='$p2'" 
>> } 
>>
Now when you run it with positional parameters
PS (2) > Test-Position one two 
p1 = 'one' p2='two'
298
CHAPTER 8
A
DVANCED
FUNCTIONS
AND
SCRIPTS
the arguments are bound by position and there’s no error. Add a position specifica-
tion to one of the parameters, and now the function looks like
PS (3) > function Test-Position 
>> { 
>>     param ( 
>>         [parameter(Position=0)] $p1 = 'p1 unset', 
>>         $p2 = 'p2 unset' 
>>     ) 
>>     "p1 = '$p1' p2='$p2'" 
>> } 
>>
Run it again with two positional parameters:
PS (4) > Test-Position one two
Test-Position : A positional parameter cannot be found that
accepts argument 'two'.
At line:1 char:14 
+ Test-Position <<<<  one two
+ CategoryInfo          : InvalidArgument: (:) [Test-P
osition], ParameterBindingException
+ FullyQualifiedErrorId : PositionalParameterNotFound,
Test-Position
This time you get an error. Although there’s a second parameter, it’s no longer posi-
tional. If you run the function again specifying the second parameter by name,
PS (5) > Test-Position one  -p2 two 
p1 = 'one' p2='two'
PS (6) >
it all works.
The ParameterSetName property
The 
ParameterSetName
property allows you to specify the parameter set or sets that 
a parameter belongs to. If no parameter set is specified, the parameter belongs to all 
the parameter sets defined by the function. The following example shows the param-
eter declaration of two parameters that belong to two different parameter sets: 
PS (1) > function Test-ParameterSets 
>> { 
>>   param ( 
>>     [parameter(ParameterSetName="s1")] $p1='p1 unset', 
>>     [parameter(ParameterSetName="s2")] $p2='p2 unset', 
>>     [parameter(ParameterSetName="s1")] 
>>     [parameter(ParameterSetName="s2",Mandatory=$true)] 
>>       $p3='p3 unset', 
>>     $p4='p4 unset' 
>>  ) 
>>  "Parameter set = " + $PSCmdlet.ParameterSetName 
>>  "p1=$p1 p2=$p2 p3=$p3 p4=$p4" 
>> } 
>>
W
RITING
ADVANCED
FUNCTIONS
AND
SCRIPTS
299
Let’s try it. First call the function, specifying 
-p1
and 
-p4
:
PS (2) > Test-ParameterSets -p1 one -p4 four 
Parameter set = s1 
p1=one p2= p3=p3 unset p4=four
The parameter binder resolves to parameter set 
s1
, where the 
-p3
parameter isn’t 
mandatory. Next specify 
-p1
-p3
, and 
-p4
:
PS (3) > Test-ParameterSets -p1 one -p3 three -p4 four 
Parameter set = s1 
p1=one p2= p3=three p4=four
You still resolve to parameter set 
s1
but this time 
-p3
is bound. Now let’s look at the 
other
parameter set. Because you’re specifying 
-p2
instead of 
-p1
, the second param-
eter set, 
s2
, is used, as you can see in the output:
PS (4) > Test-ParameterSets -p2 two -p3 three 
Parameter set = s2 
p1= p2=two p3=three p4=p4 unset
Now in parameter set 
s2
, the parameter 
-p3
is mandatory. Try running the function 
without specifying it:
PS (5) > Test-ParameterSets -p2 two
cmdlet Test-ParameterSets at command pipeline position 1 
Supply values for the following parameters: 
p3: THREE 
Parameter set = s2 
p1= p2=two p3=THREE p4=p4 unset
The runtime will prompt for the missing parameter. You provide the missing value at 
the prompt, and the function completes successfully.
Let’s verify that the parameter 
-p4
is allowed in both parameter sets. You run the 
following command specifying 
-p4
:
PS (6) > Test-ParameterSets -p2 two -p3 three -p4 four 
Parameter set = s2 
p1= p2=two p3=three p4=four
This works properly. Now try specifying all four of the parameters in the same com-
mand; this shouldn’t work because 
-p1
and 
-p2
are in different parameter sets, so the 
parameter binder can’t resolve to a single parameter set:
PS (7) > Test-ParameterSets -p1 one -p2 two -p3 three -p4 four 
Test-ParameterSets : Parameter set cannot be resolved using
the specified named parameters.
At line:1 char:19 
+ Test-ParameterSets <<<<  -p1 one -p2 two -p3 three -p4 fo 
ur
+ CategoryInfo          : InvalidArgument: (:) [Test-P
arameterSets], ParameterBindingException
+ FullyQualifiedErrorId : AmbiguousParameterSet,Test-P
arameterSets
PS (8) >
Documents you may be interested
Documents you may be interested