c# pdf viewer free : Move pages in pdf Library software component .net winforms windows mvc Windows%20Powershell%20in%20Action%202nd%20Edition28-part1481

250
CHAPTER 7
P
OWER
S
HELL
FUNCTIONS
Because the value of a switch is highly constrained, initializing switches is neither nec-
essary nor recommended. Here’s an example function that uses a switch parameter:
PS (1) > function get-soup ( 
>>     [switch] $please, 
>>     [string] $soup= "chicken noodle" 
>> ) 
>> { 
>>     if ($please) { 
>>         "Here's your $soup soup" 
>>    } 
>>    else 
>>    { 
>>         "No soup for you!" 
>>     } 
>> } 
>>
Try out this function:
PS (2) > get-soup 
No soup for you!
PS (3) > get-soup -please 
Here's your chicken noodle soup 
PS (4) > get-soup -please tomato 
Here's your tomato soup 
PS (5) >
So if you say, “please,” you get soup. If not, no soup for you! 
Soup or no soup, we’re going to move on with our exploration of switch parame-
ters and take a look at a feature that seems almost contradictory. 
Specifying arguments to switch parameters 
By definition, switch parameters don’t take arguments. Nonetheless, PowerShell pro-
vides a way to do this. It sounds like a contradiction but it turns out that there’s one 
very important scenario where you do need to do exactly this. The case in question 
happens when you need to pass the value of a switch parameter on one function to a
function <name> ( $p1, [switch] $s1 ) { <statementList> }
function keyword
Function name
List of parameter
specifications
[switch] type annotation marks
variable $s1 as switch parameter
Figure 7.5 Marking a parameter as a switch or flag by adding the 
[switch]
type constraint to it
Move pages in pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
move pages in pdf online; change page order in pdf online
Move pages in pdf - 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 reader; move pages in pdf document
D
ECLARING
FORMAL
PARAMETERS
FOR
A
FUNCTION
251
switch parameter on another function. For example, consider a function 
foo
that has 
a switch parameter -
s
. From function 
bar
, you want to call
foo
sometimes and 
foo -s
other times, and this will be controlled by a switch parameter on the 
bar
function. 
You could use 
if
statements to handle this, but even if there’s only one parameter you 
need to pass through this way, you significantly complicate your code. And if there’s 
more than one—well, let’s just say it gets ugly very quickly. To avoid this, there’s a fea-
ture in PowerShell designed with exactly this scenario in mind. Here’s how it works. 
Although switch parameters don’t require arguments, they can take one if you specify 
the parameter with a trailing colon:
dir -recurse: $true
Here’s  an  example showing  how  the  two  functions  mentioned  previously  would 
work. You’ll define a 
bar
function that passes its 
$x
switch parameter to the 
-s
switch 
parameter on function 
foo
. First define the 
foo
function:
PS (77) > function foo ([switch] $s) { "s is $s" } 
PS (78) > foo -s 
s is True 
PS (79) > foo 
s is False
Now define function 
bar
, which will call 
foo
as discussed previously:
PS (80) > function bar ([switch] $x) { "x is $x"; foo -s: $x }
Call 
bar
without passing 
-x
,
PS (81) > bar 
x is False 
s is False
and you see that 
$s
emitted from 
foo
is false. Now call 
bar
again, but specify 
-x
this 
time,
PS (82) > bar -x 
x is True 
s is True
and you see that specifying 
-x
has caused 
-s
to be set to true as well. 
This functions-calling-functions pattern is pretty much the only time you should 
ever have to pass an argument to a switch function. As a corollary to this, a script author 
should never have to write a function, script, or cmdlet where a switch parameter is ini-
tialized to 
$true
because it makes the commands very hard to use. Switch parameters 
are designed so that they need only be present or absent to get the desired effect. If you 
do have a  situation where you’re considering initializing a switch  to 
$true
, you
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Using this C#.NET Tiff image management library, you can easily change and move the position of any two or more Tiff file pages or make a totally new order for
reorder pages of pdf; pdf reverse page order
C# Word - Sort Word Pages Order in C#.NET
page reorganizing library control, developers can swap or adjust the order of all or several Word document pages, or just C# DLLs: Move Word Page Position.
change pdf page order online; how to move pages within a pdf document
252
CHAPTER 7
P
OWER
S
HELL
FUNCTIONS
probably should be using a Boolean parameter instead of a switch parameter. In the 
next section, we’ll investigate how these two types of parameters are related. 
7.2.7
Switch parameters vs. Boolean parameters
Having  both  Boolean  and  switch  parameters  in  PowerShell  may  seem  redun-
dant—both types can only be true or false. But they’re used to solve two quite differ-
ent problems. To reiterate, the important difference between the two is that switch 
parameters don’t require an argument and Booleans do. Simply specifying a switch 
parameter on the command line is sufficient for PowerShell to know that the param-
eter should be set to true:
PS (1) > function ts ([switch] $x) { [bool] $x } 
PS (2) > ts 
False 
PS (3) > ts -x 
True
With the 
ts
function, if 
-x
isn’t present, the return value is 
$false
. If it’s present, 
then the return value is 
$true
. For Boolean parameters (identified with the 
[bool] 
type accelerator), an argument must be specified each time the parameter is present. 
This is illustrated in the following example:
PS (4) > function tb ([bool] $x) { [bool] $x }
PS (5) > tb 
False 
PS (6) > tb -x 
tb : Missing an argument for parameter 'x'. Specify a parameter of type 
'System.Boolean' and try again. 
At line:1 char:6 
+ tb -x <<<<
+ CategoryInfo          : InvalidArgument: (:) [tb], 
ParameterBindingException
+ FullyQualifiedErrorId : MissingArgument,tb 
PS (7) > tb -x $true 
True
PS (8) > tb -x $false 
False
With the 
tb
function, if 
-x
isn’t present, the return value is 
$false
. If it’s present but 
no argument is specified, an error occurs. If it’s present and a Boolean value is pro-
vided as the argument, then the return value is the same as the argument. 
NOTE
There’s a characteristic in how Boolean type conversions work 
for 
[bool]
parameters that you need to be aware of. The argument to 
[bool]
parameter must either be an actual Boolean value (
$true
$false
, or the result of an expression that returns a Boolean) or a 
number where 0 is treated as 
$false
and non-zero is treated as 
$true
This is a departure from how objects are converted to Boolean else-
where in PowerShell. This inconsistency was introduced deliberately
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the C# DLLs: Move PowerPoint Page Position.
move pages in a pdf file; how to reorder pages in pdf
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
RasterEdge XDoc.PDF allows you to easily move PDF document pages position, including sorting pages and swapping two pages. Copying and Pasting Pages.
reorder pages in pdf document; rearrange pages in pdf online
D
ECLARING
FORMAL
PARAMETERS
FOR
A
FUNCTION
253
because  new  PowerShell  users  would  try  commands  like 
Get-
Something -boolParameter false
and be surprised when 
-bool-
Parameter
ended up being true, not false. (Remember, non-zero-
length strings are considered true everywhere else in the system.) The 
cognitive dissonance resulting from having 
"false"
evaluate to 
$true 
was a stumbling block for some new users. To mitigate this, Power-
Shell makes passing anything other than a number or a Boolean value 
an error condition.  This seems to be the least  inconsistent  solution 
because the new behavior is a proper subset of normal type conversion.
The behavior  of switch  parameters is specifically designed  for creating command 
switches. The scenario where you need Boolean parameters is quite different. You use 
Boolean parameters when you’re writing a command to change the value of some of 
the properties on the object passing through the pipeline. This is part of the common 
Get/Update/Set pattern where you get an object from a store, change some properties 
on that object, and then pass it to an update command. In this pattern, you only 
want to change the value of the property if there’s a corresponding parameter on the 
command line. This is where the 
[bool]
parameter is useful—it’s how you handle 
this pattern for Boolean properties. If the parameter is present, you want to set the 
property on the pipeline object to be the value passed to the parameter. If the para-
meter is absent, then you don’t want to change it. We’ll dig into this a bit more in the 
next section, but first we’ll digress for a while to investigate a common configuration 
management pattern and how you deal with it in PowerShell.
A digression: the Get/Update/Set pattern
A lot  of management data is contained in database-like remote  stores. Microsoft 
Exchange and Active Directory are two examples of this kind of thing. The character-
istic usage pattern for working with these stores is as follows:
1
Get a record from the remote store.
2
Modify some property or properties on this object.
3
Send the modified object back to the store where the changes are recorded.
For example, when managing Exchange mailboxes, the mailbox objects are retrieved 
from the server, modified, and then sent back to the server to update the database. 
This is the Get/Update/Set pattern in action. It’s an important enough pattern that 
we’re going to work through a somewhat extended example illustrating this approach 
in  PowerShell.  The following listing implements a  simple database that contains 
information about familiar characters from the comic strips. 
$characterData = @{                    
"Linus" = @{ age = 8; human = $true}
"Lucy" = @{ age = 8; human = $true}
Listing 7.1    The Get-Character function
Stores character data in 
hashtable of hashtables
C# PDF insert text Library: insert text into PDF content in C#.net
int pageIndex = 0; // Move cursor to (400F, 100F). String outputFilePath = Program.RootPath + "\\" output.pdf"; doc.Save(outputFilePath);
how to reverse pages in pdf; rearrange pages in pdf
VB.NET PDF insert text library: insert text into PDF content in vb
Dim pageIndex As Integer = 0 ' Move cursor to (400F, 100F). Dim outputFilePath As String = Program.RootPath + "\\" output.pdf" doc.Save(outputFilePath).
how to rearrange pdf pages reader; rearrange pages in pdf file
254
CHAPTER 7
P
OWER
S
HELL
FUNCTIONS
"Snoopy" = @{ age = 2; human = $true} 
}
function Get-Character ($name = "*") 
{
foreach ($entry in $characterData.GetEnumerator() | Write-Output) 
{
if ($entry.Key -like $name)
{
$properties = @{ "Name" = $entry.Key } + 
$entry.Value
New-Object PSCustomObject -Property $properties 
}
}
function Set-Character {      
process {
$characterData[$_.name] =
@{
age = $_.age
human = $_.human
}
}
function Update-Character (                                          
[string] $name = '*',
[int] $age,
[bool] $human 
{
begin
{
if ($PSBoundParameters."name")                                  
{
$name = $PSBoundParameters.name
[void] $PSBoundParameters.Remove("name")                      
}
}
process
{  
if ($_.name -like $name)                                        
{
foreach ($p in $PSBoundParameters.GetEnumerator())
{
$_.($p.Key) = $p.value     
}
}
$_
}
NOTE
To make this example work, you need to use a few features 
that haven’t been covered yet: the 
process
keyword used in 
Update-
Character
, custom objects, and the 
$PSBoundParameters
automatic
Gets data 
from table
Builds merged 
hashtable
Emits character 
record
Processes record; 
updates character entry
Updates properties 
on object
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Get image information, such as its location, zonal information, metadata, and so on. Able to edit, add, delete, move, and output PDF document image.
how to rearrange pages in pdf document; reverse page order pdf
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Rapidly and multiple PDF document (pages) creation and edit methods file formats; merge, append, and split PDF files; insert, delete, move, rotate, copy
move pages in pdf; change page order pdf acrobat
D
ECLARING
FORMAL
PARAMETERS
FOR
A
FUNCTION
255
variable. We’ll cover the 
process
keyword later in this chapter and the 
$PSBoundParameters
is discussed in chapter 8. This variable is key to 
making this example work as it lets you see which parameters were 
specified  on the  command line.  Creating custom objects  using  the 
New-Object
command is explored in chapter 11. Of these features, 
only the 
process
keyword is available in v1. The others are only avail-
able in v2.
In this example, the character data is stored in nested hashtables, making it easy to 
access by name. The 
Get-Character
function retrieves characters from the table and 
emits custom objects for each character. The 
Set-Character
data reverses this pro-
cess  and  uses  the  inbound  records  to  update  the  character  table.  The 
Update-
Character
function is where you see the use case for Boolean parameters mentioned 
in the previous section. Let’s apply this code to manage your character database. First 
you’ll get a listing of all the characters in the table:
PS (1) > Get-Character | Format-Table -auto
human Name   age 
----- ----   ---
True Snoopy   2
True Lucy     8
True Linus    8
You’re passing the output of 
Get-Character
through 
Format-Table -auto
to get a 
nice, concise table showing the character data. Immediately you see that there’s a 
problem with this data. It lists Snoopy as being human even though you know he’s a 
dog (well, at least if you’re a Peanuts fan). You’ll need to use the 
Update-Character 
function to fix this:
PS (2) > Get-Character | 
>>   Update-Character -name snoopy -human $false | 
>>    Format-Table -auto 
>>
human Name   age 
----- ----   ---
False Snoopy   2
True Lucy     8
True Linus    8
Note that you haven’t updated the table yet—you’re just looking at how the updated 
table will look. You can verify the data hasn’t changed by calling 
Get-Character
again:
PS (3) > Get-Character | Format-Table -auto
human Name   age 
----- ----   ---
True Snoopy   2
True Lucy     8
True Linus    8
256
CHAPTER 7
P
OWER
S
HELL
FUNCTIONS
Now do the Set part of Get/Update/Set:
PS (4) > Get-Character | 
>>   Update-Character -name snoopy -human $false | 
>>   Set-Character 
>>
Then, dump the table to verify that change:
PS (5) > Get-Character | Format-Table -auto
human Name   age 
----- ----   ---
False Snoopy   2
True Lucy     8
True Linus    8
Now Snoopy is no longer marked as human. But there’s also something else you want 
to check on. You’ll dump the records that show the data for characters whose names 
begin with 
L
:
PS (6) > Get-Character L* | Format-Table -auto
human Name  age 
----- ----  ---
True Lucy    8
True Linus   8
And there’s the problem: the table lists Lucy and Linus as being the same age. Because 
Linus is Lucy’s younger brother, you know the current age property must be wrong. 
Again you’ll use 
Update-Character
piped to 
Set-Character
to update the data, 
correcting the character’s age:
PS (7) > Get-Character Linus | 
>>   Update-Character -age 7 | 
>>   Set-Character 
>>
PS (8) > Get-Character | Format-Table -auto
human Name   age 
----- ----   ---
False Snoopy   2
True Lucy     8
True Linus    7
Now the table is correct.
In this extended example, you looked at a common pattern for working with 
management data—Get/Update/Set—which you’re likely to run into many times 
doing systems management. In the process, we demonstrated the reason for Boolean 
parameters being distinct from switch parameters: they address two quite different 
usage patterns.
R
ETURNING
VALUES
FROM
FUNCTIONS
257
By now, you’ve probably had enough discussion on how stuff gets passed into 
functions. Let’s talk about how stuff comes out of functions instead. In the next sec-
tion, we’ll look at the various ways objects can be returned from functions.
7.3
R
ETURNING
VALUES
FROM
FUNCTIONS
Now it’s time to talk about returning values from functions. We’ve been doing this all 
along, but there’s something we need to highlight. Because PowerShell is a shell, it 
doesn’t return results—it writes output or emits objects. As you’ve seen, the result of 
any expression or pipeline is to emit the result object to the caller. At the command 
line, if you type three expressions separated by semicolons, the results of all three 
statements are output:
PS (1) > 2+2; 9/3; [math]::sqrt(27) 
3
5.19615242270663
In this example, there are three statements in the list, so three numbers are displayed. 
Now let’s put this into a function:
PS (2) > function numbers { 2+2; 9/3; [math]::sqrt(27) }
Now run that function:
PS (3) > numbers 
3
5.19615242270663
Just as when you typed it on the command line, three numbers are output. Now run 
it and assign the results to a variable:
PS (4) > $result = numbers
Then, check the content of that variable:
PS (5) > $result.length 
PS (6) > $result[0] 
PS (7) > $result[1] 
PS (8) > $result[2]
5.19615242270663
From the output, you can see that 
$result
contains an array with three values in it. 
Here’s what happened. As each statement in the function was executed, the result of 
that statement was captured in an array, and then that array was stored in 
$result
The easiest way to understand this is to imagine variable assignments working like 
redirection, except the result is stored in a variable instead of in a file.
258
CHAPTER 7
P
OWER
S
HELL
FUNCTIONS
Let’s try something more complex. The goal here is twofold. First, you want to 
increase your understanding of how function output works. Second, you want to 
see  how  to  take  advantage  of  this  feature  to  simplify  your  scripts  and  improve 
performance. 
Let’s redefine the function numbers to use a 
while
loop that generates the num-
bers 1 to 10:
PS (11) > function numbers 
>> { 
>> $i=1 
>> while ($i -le 10) 
>> { 
>> $i 
>> $i++ 
>> } 
>> } 
>>
Now run it:
PS (12) > numbers 
10
Capture the results in a variable:
PS (13) > $result = numbers
What ended up in the variable? First check the type
PS (14) > $result.gettype().fullname 
System.Object[]
and the length:
PS (15) > $result.length 
10
The output of the function ended up in an array of elements, even though you never 
mentioned an array anywhere. This should look familiar by now, because we talked 
about it extensively in chapter 5 in our discussion of arrays. The PowerShell runtime 
will spontaneously create a collection when needed. Compare this to the way you’d 
write this function in a traditional language. Let’s rewrite this as a new function, 
tradnum
 In  the  traditional  approach,  you  have  to  initialize  a  result  variable,
R
ETURNING
VALUES
FROM
FUNCTIONS
259
$result
, to hold the array being produced, add each element to the array, and then 
emit the array:
PS (16) > function tradnum 
>> { 
>> $result = @() 
>> $i=1 
>> while ($i -le 10) 
>> { 
>>     $result += $i 
>>     $i++ 
>> } 
>> $result 
>> } 
>>
This code is significantly more complex: you have to manage two variables in the func-
tion now instead of one. If you were writing in a language that didn’t automatically 
extend the size of the array, it would be even more complicated, as you’d have to add 
code to resize the array manually. And even though PowerShell will automatically resize 
the array, it’s not efficient compared to capturing the streamed output. The point is to 
make you think about how you can use the facilities that PowerShell offers to improve 
your code. If you find yourself writing code that explicitly constructs arrays, consider 
looking at it to see if it can be rewritten to take advantage of streaming instead. 
Of course, every silver lining has a cloud. As wonderful as all this automatic col-
lecting of output is, there are some potential pitfalls. Sometimes you’ll find things in 
the output collection that you didn’t expect and have no idea how they got there. 
This can be hard (and frustrating) to figure out. In the next section we’ll explore the 
reasons why this might happen and you’ll learn how to go about debugging the prob-
lem if you encounter it. 
7.3.1
Debugging problems in function output
When writing a function, there’s something you need to keep in mind that’s specific 
to shell environments. The result of all statements executed will appear in the output 
of the function. This means that if you add debug message statements that write to 
the output stream to your function, this debug output will be mixed into the actual 
output of the function. 
NOTE
In  text-based  shells, the  usual  way  to  work  around  mixing 
debug information with output is to write the debug messages to the 
error stream (stderr). This works fine when the error stream is simple 
text; however, in PowerShell, the error stream is composed of error 
objects.  All  the  extra  information  in  these  objects,  while  great  for 
errors,  makes  them  unpalatable for writing simple  debug  messages. 
There are better ways of handling this, as you’ll see in chapter 9 when 
we talk about debugging.
Documents you may be interested
Documents you may be interested