c# pdf viewer free : Reorder pages in pdf reader SDK Library service wpf .net windows dnn Windows%20Powershell%20in%20Action%202nd%20Edition18-part1470

150
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
neither 
[int]
nor 
[long]
, PowerShell will attempt to convert them 
into 
[long]
and then perform the operation. 
4.6
S
UMMARY
That concludes our tour of the basic PowerShell operators. We covered a lot of infor-
mation, much of it in great detail. We explored the basic PowerShell operators and 
expressions with semantics and applications of those operators. Here are the impor-
tant points to remember:
• PowerShell operators are polymorphic with special behaviors defined by Power-
Shell for the basic types: numbers, strings, arrays, and hashtables. For other 
object types, the 
op_
methods are invoked.
• The behavior of most of the binary operators is determined by the type of the 
operand on the left. 
• PowerShell uses widening when working with numeric types. For any arithme-
tic operation, the type of the result will be the narrowest .
NET
numeric type 
that can properly represent the result. Also note that integer division will under-
flow into floating point if the result of the operation isn’t an integer. Casts can 
be used to force an integer result.
• There are two types of pattern matching operations in PowerShell: wildcard 
patterns (usually used for matching filenames) and regular expressions.
• Because the comparison and pattern-matching operators work on collections, in 
many cases you don’t need a looping statement to search through collections.
• Regular expressions are powerful and can be used to do complex text manipula-
tions with very little code. PowerShell uses the .
NET
regular expression classes 
to implement the regular expression operators in the language.
• PowerShell  version 2 introduced  two  new  operators  for  working with text: 
-split
and 
-join
. With the addition of these two, the set of text-manipula-
tion operators is now complete.
• PowerShell has built-in operators for working with binary values: 
-band
-bor
-bxor
, and 
-bnot
.
But we’re not done yet! In the next chapter, we’ll finish our discussion of operators 
and expressions and also explain how variables are used. Stay tuned!
Reorder pages in pdf reader - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change page order in pdf reader; how to move pages in pdf files
Reorder pages in pdf 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
change page order pdf reader; how to reorder pages in a pdf document
151
C
H
A
P T E R   5
Advanced operators and 
variables
5.1  Operators for working with types  152
5.2  The unary operators  154
5.3  Grouping and subexpressions  157
5.4  Array operators  162
5.5  Property and method operators  173
5.6  The format operator   179
5.7  Redirection and the redirection 
operators  181
5.8  Working with variables  184
5.9  Summary  196
The greatest challenge to any thinker is stating the problem in a way that 
will allow a solution.
—Bertrand Russell
The previous chapter covered the basic operators in PowerShell, and in this chapter 
we’ll continue our discussion of operators by covering the advanced  ones, which 
include things that some people don’t think of as operators at all. We’ll break the 
operators into related groups, as shown in figure 5.1. 
In this chapter, we’ll look at how to work with types, properties, and methods and 
how to use these operators to build complex data structures. The chapter concludes 
with a detailed discussion of how variables work in PowerShell and how you can use 
them with operators to accomplish significant tasks.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
move pages in a pdf; how to move pages in pdf
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
pdf move pages; reorder pages of pdf
152
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
5.1
O
PERATORS
FOR
WORKING
WITH
TYPES
The type of an object is fundamental to determining the sorts of operations you can 
perform on that object. Up until now, you’ve allowed the type of the object to implic-
itly determine the operations that are performed. But sometimes you want to do this 
explicitly. PowerShell provides a set of operators that can work with types, as shown 
in figure 5.2. They’re also listed in table 5.1 with examples and more description. 
These operators let you test whether an object is of a particular type and enable 
you to convert an object to a new type. The 
-is
operator returns true if the object on 
the left side is of the type specified on the right side. By “is,” I mean that the left oper-
ator is either of the type specified on the right side or is derived from that type. (See 
section 1.3 in chapter 1 for an explanation of derivation.) 
The 
-isnot
operator returns true if the left side is not of the type specified on the 
right side. The right side of the operator must be represented as a type or a string that 
names a type. This means that you can use either a type literal such as 
[int]
or the 
literal string “int”. The 
-as
operator will try to convert the left operand into the type
-is   -isnot   -as
Operators for working with types
-not  +  -
--
++  [cast]  ,
Unary operators
( <pipeline> )    $( <statements> )    
@( <statements> )
Grouping, expression, and
subexpression operators
[ <indexExpr> ]   ,  ..
Array operators
<type>::<expr>()   
<expr>.<expr>()
Property and method
reference operators
 >> 2>  2>> 2>&1
Redirection  operators
<fmtString> -f 
<argsList>
Format operator
Figure 5.1 The broad groups of operators we’ll cover in this chapter
<value> -is <type>
<expr> -isnot <type>
<expr> -as <type>
Operators for working with types
Figure 5.2 The binary operators for working with types
Read PDF in Web Image Viewer| Online Tutorials
Extract images from PDF documents; Add, reorder pages in PDF files; Save and print Document Viewer, make sure that you have install RasterEdge PDF Reader Add-on
reorder pages in pdf document; pdf reverse page order preview
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Enable batch changing PDF page orientation without other PDF reader control. PDF page, delete certain PDF page, reorder existing PDF pages and split
rearrange pdf pages in preview; reorder pages pdf
O
PERATORS
FOR
WORKING
WITH
TYPES
153
specified by the right operand. Again, either a type literal can be used, or you can use 
a string naming a type.
NOTE
The PowerShell 
-is
and 
-as
operators are directly modeled 
on the corresponding operators in 
C
#. But PowerShell’s version of 
-as 
uses PowerShell’s more aggressive approach to casting. For example, 
C
# won’t cast the string “123” into the number 123, whereas the Pow-
erShell operator will do so. The PowerShell 
-as
operator will also work 
on any type, and the 
C
# operator is restricted to reference types.
You may be wondering why you need the 
-as
operator when you can just use a cast. 
The reason is that the 
-as
operator allows you to use a runtime expression to specify 
the type, whereas the cast is fixed at parse time. Here’s an example showing how you 
can use this runtime behavior:
PS (1) > foreach ($t in [float],[int],[string]) {"0123.45" -as $t} 
123.45 
123 
0123.45
This example loops over a list of type literals and converts the string into each of the 
types. This isn’t possible when types are used as casts. 
Finally, there’s one additional difference between a regular cast and using the 
-as 
operator. In a cast, if the conversion doesn’t succeed an error is generated. With the 
-as
operator, if the cast fails, then the expression returns 
$null
instead of generating 
an error.
PS (2) > [int] "abc" -eq $null 
Cannot convert "abc" to "System.Int32". Error: "Input string was not 
in a correct format."
At line:1 char:6 
+ [int]  <<<< "abc" -eq $null 
PS (3) > ("abc" -as [int]) -eq $null 
True 
PS (4) >
You can see this here. Casting “abc” to 
[int]
generated an error, but the 
-as
opera-
tor just returned 
$null
instead. Table 5.1 provides several more examples of how to 
use the type operators PowerShell provides.
Table 5.1 PowerShell operators for working with types
Operator Example
Results
Description
-is
$true -is [bool]
$true
True if the type of the left side matches the 
type of the object on the right side.
$true -is [object]
$true
This is always true—everything is an object 
except $null.
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
how to rearrange pages in a pdf document; reverse page order pdf online
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
just following attached links. C# PDF: Add, Delete, Reorder PDF Pages Using C#.NET, C# PDF: Merge or Split PDF Files Using C#.NET.
change pdf page order online; move pdf pages in preview
154
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
In practice, most of the time the automatic type conversion mechanism will be all 
you need, and explicit casts will take care of the majority of the remaining cases. So 
why have these operators? They’re mostly used in scripting. For example, if you want 
to have a script that behaves differently based on whether it’s passed a string or a 
number, you’ll need to use the 
-is
operator to select which operation to perform. 
Obvious examples of this kind of functionality are the binary operators described in 
the previous chapter. The addition operator has different behavior depending on the 
type of its left argument. To write a script that did the same thing, you’d have to use 
-is
to select the type of the operation to perform and 
-as
to convert the right 
operand to the correct type. 
5.2
T
HE
UNARY
OPERATORS
Now let’s take a detailed look at the unary operators, which take only one argument. 
These operators are shown in figure 5.3 and listed with examples in table 5.2. 
$true -is [ValueType]
$true
The left side is an instance of a .NET value 
type such as an integer or floating-point 
number.
"hi"  -is [ValueType]
$false
A string is not a value type; it’s a reference 
type so this expression returns FALSE.
"hi" -is [object]
$true
A string is still an object.
12 -is [int]
$true
12 is an integer.
12 -is "int"
$true
The right side of the operator can be either 
a type literal or a string naming a type.
-isnot
$true -isnot [string]
$true
The object on the left side is not of the 
type specified on the right side.
$null -isnot [object]
$true
The null value is the only thing that isn’t an 
object.
-as
"123" -as [int]
123
Takes the left side and converts it to the 
type specified on the right side.
123 -as "string"
"123"
Turns the left side into an instance of the 
type named by the string on the right.
Table 5.1 PowerShell operators for working with types (continued)
Operator Example
Results
Description
-not <value>
+<value>
-<value>
[cast] <value>
,<value>
-- <assignableExpr>
<assignableExpr> --
++ <assignableExpr>
<assignableExpr> ++
Unary operators including increment and decrement operators
Figure 5.3 
The binary 
various unary 
operators
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
move pages in pdf file; rearrange pdf pages reader
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
change page order in pdf online; move pages in pdf online
T
HE
UNARY
OPERATORS
155
You’ve seen most of these operators already in previous sections. The unary 
+
and 
-
operators do what you’d expect for numbers. Applying them to any other type results 
in an error. 
The use of the type casts as unary operators was discussed at length in chapter 3, so 
we won’t go into it again. The interesting operators in this section are the increment 
and decrement operators. They match the behavior of the equivalent operators in the 
C
programming language with both the prefix and postfix forms of the operators. 
These operators are special in that they take an assignable expression as an argu-
ment.  An  assignable  expression  is,  well,  anything  that  can  be  assigned  to.  This 
includes variables, array elements, and object properties. These operators retrieve the 
current value of the assignable expression, increment (add 1) or decrement (subtract
1) that value, and then assign it back to the assignable expression. For example, if 
you’re using 
++
with a variable, the value of the variable will be retrieved, incre-
mented by 1, and then assigned back to the variable. As with the unary 
+
and 
-
oper-
ators, the increment (
++
) and decrement (
--
) operators are only defined for variables 
containing numbers. Applying them to a variable containing anything other than 
numbers results in an error.
There’s another thing that’s special about these operators. The increment and decre-
ment operators were almost not included in PowerShell because they introduced a 
problem. In languages such as C and C#, when you use one of these operators
$a++
Table 5.2 PowerShell unary operators
Operator
Example
Results
Description
-
- (2+2)
-4
Negation. Tries to convert its argument to a 
number, and then negates the result.
+
+ "123 "
123
Unary plus. Tries to converts its argument 
to a number and returns the result. This is 
effectively a cast to a number.
--
--$a ; $a--
Depends on the 
current value of 
the variable
Pre- and postdecrement operator. Converts 
the content of the variable to a number, and 
then tries to subtract one from that value. 
The prefix version returns the new value; 
the postfix version returns the original value.
++
++$a; $a++
Depends on the 
current value of 
the variable
Pre- and postincrement. Converts the variable 
to a number, and then adds 1 to the result. 
The prefix version returns the new value; the 
postfix version returns the original value.
[<type>] [int] "0x123" 291
Type cast. Converts the argument into an 
instance of the type specified by the cast.
,
, (1+2)
One-element array 
containing the value 
of the expression
Unary comma operator. Creates a new 
one-element array of type [object[]]
and stores the operand in it.
156
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
as a statement, nothing is displayed. This is because statements in 
C
and 
C
# don’t 
return values. In PowerShell, all statements return a value, which led to confusion. 
People would write scripts like this
$sum=0 
$i=0 
while ($i -lt 10) { $sum += $i; $i++ } 
$sum
and be surprised to see the numbers 0 through 9 displayed. This was because 
$a++ 
returned a value and PowerShell was displaying the results of every statement. This was 
so confusing that the language design team almost removed these operators from the 
language. Then we hit on the idea of a voidable statement. Basically, this means that cer-
tain types of expressions, when used as statements, aren’t displayed. Voidable statements 
include assignment statements and the increment/decrement operators. When incre-
ment and decrement are used in an expression, they return a value, but when they’re 
used as a stand-alone statement, they return no value. Again, this is one of those details 
that won’t affect how you use PowerShell other than to make it work as you expect. Now, 
if you do want the value of the expression to be output, there’s a trick you can use. If 
the expression is enclosed in parentheses, the result will be returned instead of discarded. 
This can be convenient sometimes, especially in string expansions. Let’s try this. Your 
task is to print out a list of strings prefixed with the string number. Here’s how:
PS {1) > $l=1 
PS {2) > foreach ($s in "one","two","three") 
>> { "$($l++): $s" } 
>> 
: one 
: two 
: three
The 
foreach
statement loops over the strings and emits your output. The 
++
in the 
subexpressions (which we’ll get to next) causes the variable to be incremented. But 
because the expression is treated as a statement, there’s no output in the string. Here’s 
how you can fix it. You’ll make one small change and add parentheses around the 
increment expression. Let’s try it again:
PS {3) > $l=1 
PS {4) > foreach ($s in "one","two","three") 
>> { "$(($l++)): $s" } 
>> 
1: one 
2: two 
3: three 
PS {5) >
This time it works properly—you see the numbers in the output strings.
NOTE
Only some statements are considered voidable. For other state-
ment types, you’ll have to explicitly discard the output of a statement.
G
ROUPING
AND
SUBEXPRESSIONS
157
In effect, you want to turn a regular statement into a voidable one. The 
way to do this through an explicit cast is to use 
[void]
, as in 
[void] 
(Write-Output  "discard  me")
. The statement whose value you 
want to discard is enclosed in parentheses, and the whole thing is cast 
to void. You’ll see another way to accomplish the same effect using the 
redirection operators later in this chapter.
Having touched on subexpressions in our discussion of voidable statements, let’s take 
a more formal look at them in the next section, where we’ll cover all the grouping 
constructs in the language.
5.3
G
ROUPING
AND
SUBEXPRESSIONS
So far you’ve seen a variety of situations where collections of expressions or statements 
have been grouped together. You’ve even used these grouping constructs in string 
expansions. These operators are shown in figure 5.4.
Now let’s look at them in more detail. Table 5.3 provides more details and some 
examples. 
( <pipeline> )     $( <statementList> )      @( <statementList> )
Grouping, expression, and subexpression operators
Figure 5.4 The PowerShell operators for grouping expressions and statements
Table 5.3 Expression and statement grouping operators
Operator
Example
Results
Description
( ... )
( 2 + 2 ) * 3 
(get-date).dayofweek
12 
Returns the current 
weekday
Parentheses group expression 
operations and may contain 
either a simple expression or a 
simple pipeline. They may not 
contain more than one statement 
or things like while loops.
$( ... ) $($p = "a*"; 
get-process $p )
Returns the pro-
cess objects for all 
processes starting 
with the letter a
Subexpressions group collec-
tions of statements as opposed 
to being limited to a single 
expression. If the contained 
statements return a single value, 
that value will be returned as a 
scalar. If the statements return 
more than one value, they will be 
accumulated in an array.
158
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
The first grouping notation is the simple parenthetical notation. As in most lan-
guages, the conventional use for this notation is to control the order of operations, as 
shown by the following example:
PS (1) > 2+3*4 
14 
PS (2) > (2+3)*4 
20
The parentheses in the second expression cause the addition operation to be per-
formed first. In PowerShell, parentheses also have another use. Looking at the syntax 
specification shown in figure 5.4 for parenthetical expressions illustrates this:
<pipeline>
)
From the syntax, you can see that pipelines are allowed between simple parentheses. 
This allows you to use a command or pipeline as a value in an expression. For exam-
ple, to obtain a count of the number of files in a directory, you can use the 
dir
com-
mand in parentheses, then use the 
Count
property to get the number of objects 
returned:
PS (1) > (dir).count 
46
Using a pipeline in the parentheses lets you get a count of the number of files match-
ing the wildcard pattern 
*.doc
:
PS (2) > (dir | where {$_.name -like '*.doc'}).count 
32
NOTE
People familiar with other languages tend to assume that the 
expression 
(1,2,3,4)
is an array literal in PowerShell. In fact, as you 
learned in chapter 3, this isn’t the case. The comma operator, discussed 
in the next section, allows you to easily construct arrays in PowerShell, 
but there  are no array literals as such in the language. All  that the 
parentheses do is control the order of operations. Otherwise, there’s 
nothing  special about them. In  fact, the precedence of the comma 
operator is such that you typically never need parentheses for this pur-
pose. More on that later.
@( ... ) @( dir  c:\; dir d:\)
Returns an array 
containing the 
FileInfo objects 
in the root of the C: 
and D: drives
The array subexpression operator 
groups collections of statements 
in the same manner as the regu-
lar subexpression operator, but 
with the additional behavior that 
the result will always be returned 
as an array. 
Table 5.3 Expression and statement grouping operators (continued)
Operator
Example
Results
Description
G
ROUPING
AND
SUBEXPRESSIONS
159
Now let’s move on to the next set of grouping constructs—the subexpressions. There 
are two forms of the subexpression construct, as shown in the following:
$( <statementList> ) 
@( <statementList> )
5.3.1
Subexpressions $( ... )
The syntactic difference between a subexpression (either form) and a simple paren-
thetical expression  is that you can have  any list  of statements in  a subexpression 
instead of being restricted to a single pipeline. This means that you can have any 
PowerShell  language  element  in  these grouping  constructs,  including loop  state-
ments. It also means that you can have several statements in the group. Let’s look at 
an example. Earlier in this chapter, you saw a short piece of PowerShell code that cal-
culates the numbers in the Fibonacci sequence below 100. At the time, you didn’t 
count the number of elements in that sequence. You can do this easily using the sub-
expression grouping construct:
PS (1) > $($c=$p=1; while ($c -lt 100) {$c; $c,$p=($c+$p),$c}).count 
10
By enclosing the statements in 
$( ... )
, you can retrieve the result of the enclosed 
collection of statements as an array.
NOTE
Many languages have a special notation for generating collec-
tions of objects. For example, Python and functional languages such as 
Haskell have a feature called list comprehensions for doing this. Power-
Shell (and shell languages in general) don’t need special syntax for this 
kind of operation. Collections occur naturally as a consequence of the 
shell pipeline model. If a set of statements used as a value returns mul-
tiple objects, they’ll automatically be collected into an array.
Another difference between the subexpression construct and simple parentheses is how 
voidable statements are treated. We looked at this concept earlier with the increment 
and decrement operators. A voidable expression is one whose result is discarded when 
used directly as a statement. Here’s an example that illustrates this. First initialize 
$a
to 
0; then use a postincrement expression in parentheses and assign it to the variable 
$x
:
PS (1) > $a=0 
PS (2) > $x=($a++)
Checking the value of 
$x
, you see that it is 0, as expected, and that 
$a
is now 1:
PS (3) > $x 
PS (4) > $a 
1
Now do a second assignment, this time with the expression in 
$( ... )
PS (5) > $x=$($a++)
Documents you may be interested
Documents you may be interested