c# pdf viewer free : Move pages in pdf document application Library utility azure .net windows visual studio Windows%20Powershell%20in%20Action%202nd%20Edition13-part1465

100
CHAPTER 3
W
ORKING
WITH
TYPES
PS (1) > [string] | get-member -static
TypeName: System.String
Name            MemberType Definition 
----            ---------- ----------
Compare         Method     static System.Int32 Compare(String... 
CompareOrdinal  Method     static System.Int32 CompareOrdinal... 
Concat          Method     static System.String Concat(Object... 
Copy            Method     static System.String Copy(String str) 
Equals          Method     static System.Boolean Equals(Strin... 
Format          Method     static System.String Format(String... 
Intern          Method     static System.String Intern(String... 
IsInterned      Method     static System.String IsInterned(St... 
IsNullOrEmpty   Method     static System.Boolean IsNullOrEmpt... 
Join            Method     static System.String Join(String s... 
op_Equality     Method     static System.Boolean op_Equality(... 
op_Inequality   Method     static System.Boolean op_Inequalit... 
ReferenceEquals Method     static System.Boolean ReferenceEqu... 
Empty           Property   static System.String Empty {get;set;} 
This code will dump out all the static members on the .
NET
System.String
class. If 
you want to call one of these methods, you need to use the 
::
operator. Let’s use the 
join method to join an array of string. First create the array:
PS (2) > $s = "one","two","three"
Then use the join method to join all the pieces into a single string with plus signs in 
between:
PS (3) > [string]::Join(' + ', $s) 
one + two + three 
PS (4) >
Example: using advanced math functions
A good example of the power of static methods is the 
[math]
class from the .
NET 
Framework. This class—
[System.Math]
—is a pure static class. This means you can’t 
create an instance of it—you can only use the static methods it provides. Again, let’s 
use the 
Get-Member
cmdlet to look at the methods. Here’s a truncated listing of the 
output you’d see:
PS (1) > [math] | get-member -static
TypeName: System.Math
Name            MemberType Definition 
----            ---------- ----------
Abs             Method     static System.Single Abs(Single va... 
Acos            Method     static System.Double Acos(Double d) 
Asin            Method     static System.Double Asin(Double d) 
Atan            Method     static System.Double Atan(Double d) 
Atan2           Method     static System.Double Atan2(Double ...
:
:
Move pages in 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
rearrange pages in pdf file; change page order pdf acrobat
Move pages in 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
reorder pages in pdf reader; change page order pdf
T
YPE
CONVERSIONS
101
Sqrt            Method     static System.Double Sqrt(Double d) 
Tan             Method     static System.Double Tan(Double a) 
Tanh            Method     static System.Double Tanh(Double v... 
Truncate        Method     static System.Decimal Truncate(Dec... 
              Property   static System.Double E {get;}
PI              Property   static System.Double PI {get;}
As you can see, it contains a lot of useful methods and properties. For example, it 
contains useful constants like 
Pi
and 
e
as static properties:
PS (2) > [math]::Pi
3.14159265358979
PS (3) > [math]::e
2.71828182845905
PS (4) >
There are also all the trigonometric functions:
PS (4) > [math]::sin(22) 
-0.00885130929040388 
PS (5) > [math]::cos(22) 
-0.999960826394637 
PS (6) >
As we’ve said, types in PowerShell provide tremendous power and breadth of capabil-
ities. In many cases, before rolling your own solution it’s worth browsing the 
MSDN 
documentation on the .
NET
libraries to see if there’s something you can use to solve 
your problems. Now that you’ve seen the types, let’s look at how PowerShell does type 
conversions.
3.6
T
YPE
CONVERSIONS
In the previous section, we introduced type literals and the major data types used in 
PowerShell. But how do all these types work together? This is a critical question we 
had to address in designing PowerShell. In shell languages, there’s usually only string 
data, so you never have to worry about things being of the wrong type. So how could 
the PowerShell team achieve this “typeless” behavior in PowerShell? The answer was a 
comprehensive system for handling type conversions automatically. 
Automatic type conversion is the “secret sauce” that allows a strongly typed language 
like PowerShell to behave like a typeless command-line shell. Without a comprehensive 
type conversion system to map the output of one command to the input type required 
by another command, PowerShell would be nearly impossible to use as a shell. 
In the next few sections, we’ll go through an overview of how the type-conversion 
system works. Then we’ll look at the conversion algorithm in detail. Finally, we’ll 
explore special conversion rules that apply only when binding cmdlet parameters.
3.6.1
How type conversion works
Type conversions are used any time an attempt is made to use an object of one type in 
a context that requires another type (such as adding a string to a number). Here’s a
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. this C#.NET Tiff image management library, you can easily change and move the position of
pdf change page order; how to reorder pages in a pdf document
C# Word - Sort Word Pages Order in C#.NET
adjust the order of all or several Word document pages, or just page inserting, Word page deleting and Word document splitting C# DLLs: Move Word Page Position.
how to move pages in pdf; change page order in pdf reader
102
CHAPTER 3
W
ORKING
WITH
TYPES
good example: In the previous chapter, we talked about how parameters are bound to 
cmdlets. The parameter binder uses the type conversion system heavily when trying 
to bind incoming objects to a particular parameter. If the user has supplied a string 
and the cmdlet requires a number, the system will quietly convert the source object to 
the destination type as long as it’s not a destructive conversion. A destructive conver-
sion is one where the sense of the original object has been lost or distorted in some 
significant way. With numbers, this typically means a loss of precision. 
The type-conversion facility is also surfaced directly to the shell user through cast 
operations in the PowerShell language, as we mentioned in the previous section. In 
PowerShell, you use types to accomplish many things that you’d do with methods or 
functions in other languages. You use type literals as operators to convert (or cast) 
one type of object to another. Here’s a simple example:
PS (1) > [int] "0x25" 
37 
PS (2) >
In this example, a string representing a hexadecimal number is converted into a num-
ber by using a cast operation. A token specifying the name of a type in square brack-
ets can be used as a unary operator that will try to convert its argument into the 
desired type. These type cast operations can be composed—that is, several casts can 
be chained together. Here’s an example of that type of composition. To get the ordi-
nal value for a character, you can do this:
:
PS (2) > [int] [char]"a" 
97
Notice that you first cast the string into a char and then into an int. This is necessary 
because the simple conversion would try to parse the entire string as a number. This 
only works for a string containing exactly one character, however. If you want to con-
vert an entire string, you need to use array types. Here’s what that looks like:
PS (3) > [int[]] [char[]] "Hello world" 
72 
101 
108 
108 
111 
32 
119 
111 
114 
108 
100
The string was split into an array of characters, then that array of characters was con-
verted into an array of integers and finally displayed as a list of decimal numbers. If
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
the order of all or several PowerPoint document pages, or just PowerPoint page deleting and PowerPoint document splitting C# DLLs: Move PowerPoint Page Position.
moving pages in pdf; how to rearrange pages in a pdf file
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.
pdf rearrange pages; change page order in pdf online
T
YPE
CONVERSIONS
103
you wanted to see those numbers in hex, you’d have to use the 
–f
format operator 
and a format specifier string:
PS (4) > "0x{0:x}" -f [int] [char] "a" 
0x61
And then, if you want to make a round trip, string to char to int to char to string, you 
can do this:
PS (6) > [string][char][int] ("0x{0:x}" -f [int] [char] "a") 
a
Finally, here’s a somewhat extreme example (for 2001: A Space Odyssey fans). You’ll 
take the string 
“HAL”
and increment each of the characters in the string by 1:
PS (7) > $s = "HAL"
PS (8) > $OFS=""; [string] [char[]] ( [int[]] [char[]] $s | 
>> foreach {$_+1} ) 
>>
IBM
Creepy, but cool (or just weird if you’re not a 2001 fan)! Moving closer to home, we 
know that the Windows 
NT
kernel was designed by the same person who designed 
the VMS operating system. Let’s prove that Windows 
NT (WNT)
is just 
VMS
plus 1:
PS (9) > $s = "VMS"
PS (10) > $OFS=""; [string] [char[]] ( [int[]] [char[]] $s | 
>> foreach {$_+1} ) 
>>
WNT
One final issue you may be wondering about: what is the 
$OFS
(Output Field Separa-
tor) variable doing in the example? When PowerShell converts arrays to strings, it 
takes each array element, converts that element into a string, and then concatenates 
all the pieces together. Because this would be an unreadable mess, it inserts a separa-
tor between each element. That separator is specified using the 
$OFS
variable. It can 
be set to anything you want, even the empty string. Here’s an interesting example. 
Say you want to add the numbers from 1 to 10. Let’s put the numbers into an array:
PS (1) > $data = 1,2,3,4,5,6,7,8,9,10
Now convert them to a string:
PS (2) > [string] $data 
1 2 3 4 5 6 7 8 9 10
As an aside, variable expansion in strings goes through the same mechanism as the 
type converter, so you’ll get the same result:
PS (3) > "$data" 
1 2 3 4 5 6 7 8 9 10
Change 
$OFS
to be the plus operator, and then display the data.
C# PDF insert text Library: insert text into PDF content in C#.net
int pageIndex = 0; // Move cursor to (400F, 100F). aChar, font, pageIndex, cursor); // Output the new document. Program.RootPath + "\\" output.pdf"; doc.Save
rearrange pdf pages; how to move pages within a pdf document
C# PDF Page Insert Library: insert pages into PDF file in C#.net
Support adding and inserting one or multiple pages to existing PDF document. Add and Insert Multiple PDF Pages to PDF Document Using C#.
move pages in pdf file; how to rearrange pdf pages
104
CHAPTER 3
W
ORKING
WITH
TYPES
PS (4) > $OFS='+'
PS (5) > "$data" 
1+2+3+4+5+6+7+8+9+10
Previously, the fields had been separated by spaces. Now they’re separated by plus 
operators. This is almost what you need. You just have to find a way to execute this 
string. PowerShell provides that ability through the 
Invoke-Expression
cmdlet. 
Here’s how it works:
PS (6) > invoke-expression "$data" 
55 
PS (7) >
Ta-da! Note that this isn’t an efficient way to add a bunch of numbers. The looping 
constructs in the language are a much better way of doing this.
3.6.2
PowerShell’s type-conversion algorithm
In this section, we’ll cover the steps in the conversion process in painful detail—much 
more than you’ll generally need to know in your day-to-day work. But if you want to 
be an expert on PowerShell, this stuff’s for you.
NOTE
Type conversion is one of the areas of the PowerShell project 
that grew “organically.” In other words, we sat down, wrote a slew of 
specifications, threw them out, and ended up doing something com-
pletely different. This is one of the joys of this type of work. Nice, 
clean theory falls apart when you put it in front of real people. The 
type conversion algorithm as it exists today is the result of feedback 
from many of the early adopters both inside Microsoft as well as out-
side. The PowerShell community helped us tremendously in this area.
In general, the PowerShell type conversions are separated into two major buckets; a 
description follows.
PowerShell language standard conversions
These are built-in conversions performed by the engine itself. They’re always pro-
cessed first and consequently can’t be overridden. This set of conversions is largely 
guided by the historical behavior of shell and scripting languages, and isn’t part of the 
normal .
NET
type-conversion system.
.NET-based custom converters
This class of converters uses (and abuses in some cases) existing .
NET
mechanisms for 
doing type conversion.
Table 3.5 lists the set of built-in language conversions that PowerShell uses. The 
conversion process always starts with an object of a particular type and tries to pro-
duce a representation of that object in the requested target type. The conversions are
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 in VB.NET. Add and Insert Multiple PDF Pages to PDF Document Using VB.
rearrange pdf pages in reader; how to rearrange pdf pages online
C# PDF Library SDK to view, edit, convert, process PDF file for C#
load, create, convert and edit PDF document (pages) in C# PDF files; insert, delete, move, rotate, copy and robust APIs for editing PDF document hyperlink (url
reorder pdf pages online; rearrange pdf pages online
T
YPE
CONVERSIONS
105
applied in the order shown in table 3.5. Only one conversion is applied at a time. 
The PowerShell engine doesn’t automatically chain conversions.
If none of the built-in PowerShell language-specific conversions could be applied suc-
cessfully, then the .
NET
custom converters are tried. Again, these converters are tried
Table 3.5 The PowerShell language standard conversions
Converting from
To target type
Result description
$null
[string]
""
(empty string)
[char]
'0' (string containing a single character 0)
Any kind of 
number
The object corresponding to 0 for the correspond-
ing numeric type.
[bool]
$false
[PSObject]
$null
Any other type 
of object
$null
Derived class
Base class
The original object is returned unchanged.
Anything
[void]
The object is discarded.
Anything
[string]
The PowerShell internal string converter is used.
Anything
[xml]
The original object is first converted into a string 
and then into an XML document object.
Array of type [X]
Array of type 
[Y]
PowerShell creates a new array of the target type, 
then copies and converts each element in the 
source array into an instance for the target array 
type.
Non-array (singleton) object
Array of type 
[Y]
Creates an array containing one element and then 
places the singleton object into the array, convert-
ing if necessary.
System.Collections 
.IDictionary
[Hashtable]
A new instance of 
System.Collections.Hashtable is created, 
and then the members of the source 
IDictionary are copied into the new object.
[string]
[char[]]
Converts the string to an array of characters.
[string]
[regex]
Constructs a new instance of a .NET regular 
expression object.
[string]
Number
Converts the string into a number using the small-
est representation available that can accurately 
represent that number. If the string is not purely 
convertible (i.e., only contains numeric informa-
tion), then an error is raised.
[int]
System.Enum
Converts the integer to the corresponding enumer-
ation member if it exists. If it doesn’t, a conversion 
error is generated.
106
CHAPTER 3
W
ORKING
WITH
TYPES
in order until a candidate is found that will produce the required target type. This 
candidate conversion is applied. If  the candidate  conversion  throws an exception 
(that is, a matching converter is found but it fails during the conversion process), no 
further attempt to convert this object will be made and the overall conversion process 
will be considered to have failed. 
NOTE
Developing an understanding of these conversions depends on 
a fair knowledge of the .
NET
type conversion mechanisms. You’ll need 
to refer to additional documentation if you want to understand every-
thing in table 3.6. On the other hand, with the .
NET
docs, you can see 
exactly what steps are being applied in the type-conversion process.
Custom converters are executed in the order described in table 3.6.
Table 3.6 Custom type conversions
Converter type
Description
PSTypeConverter
A PSTypeConverter can be associated with a particular type using the 
TypeConverterAttribute or the <TypeConverter> tag in the 
types.ps1xml file. If the value to convert has a PSTypeConverter that can 
convert to the target type, then it’s called. If the target type has a 
PSTypeConverter that can convert from values to convert, then it’s called. 
The PSTypeConverter allows a single type converter to work for a number 
of different classes. For example, an enum type converter can convert a 
string to any enum (there doesn’t need to be separate type to convert each 
enum
). Refer to the PowerShell SDK documentation from MSDN for com-
plete details on this converter.
TypeConverter
This is a CLR defined type that can be associated with a particular type using 
the TypeConverterAttribute or the <TypeConverter> tag in the 
types file. If the value to convert has a TypeConverter that can convert to 
the target type, then it is called. If the target type has a TypeConverter
that can convert from the source value, then it is called.
The CLR TypeConverter doesn’t allow a single type converter to work for 
a number of different classes. Refer to the PowerShell SDK documentation 
and the Microsoft .NET Framework documentation for details on the 
TypeConverter class.
Parse() method
If the value to convert is a string and the target type has a Parse() method, 
then that Parse() method is called. Parse() is a well-known method 
name in the CLR world and is commonly implemented to allow conversion 
of strings to other types.
Constructors
If the target type has a constructor that takes a single parameter matching 
the type of the value to convert; then this constructor is used to create a 
new object of the desired type.
Implicit cast operator If the value to convert has an implicit cast operator that converts to the tar-
get type, then it’s called. Conversely, if the target type has an implicit cast 
operator that converts from value to convert’s type, then that’s called.
T
YPE
CONVERSIONS
107
This section covered the set of type conversions that PowerShell will apply in expres-
sions. In the parameter binder are a few extra steps that are applied first.
3.6.3
Special type conversions in parameter binding
In this final section, we’ll go over the extra type-conversion rules that are used in 
parameter binding that haven’t already been covered. If these steps are tried and aren’t 
successful, the parameter binder goes on to call the normal PowerShell type converter 
code. 
NOTE
If at any time failure occurs during the type conversion, an 
exception will be thrown.
Here are the extra steps:
1
If there’s no argument for the parameter, the parameter type must be either a 
[bool]
or the special PowerShell type 
SwitchParameter
; otherwise, a parame-
ter binding exception is thrown. If the parameter type is a 
[bool]
, it’s set to 
true. If the parameter type is a 
SwitchParameter
, it’s set to 
SwitchParame-
ter.Present
.
2
If the argument value is null and the parameter type is 
[bool]
, it’s set to false. If 
the argument value is null and the parameter type is 
SwitchParameter
, it’s set 
to 
SwitchParameter.Present
. Null can be bound to any other type, so it just 
passes through.
3
If the argument type is the same as the parameter type, the argument value is 
used without any type conversion.
4
If the parameter type is 
[object]
, the current argument value is used without 
any coercion.
5
If  the  parameter  type  is  a 
[bool]
 use  the  PowerShell  Boolean 
IsTrue() 
method to determine whether the argument value should set the parameter to 
true or false. 
6
If the parameter type is a collection, the argument type must be encoded into 
the appropriate collection type. You’ll encode a scalar argument type or a collec-
tion argument type to a target collection parameter type. You won’t encode a 
collection argument type into a scalar parameter type (unless that type is 
Sys-
tem.Object
or 
PSObject
).
Explicit cast operator If the value to convert has an explicit cast operator that converts to the target 
type, then it’s called. Alternatively, if the target type has an explicit cast oper-
ator that converts from value to convert’s type, then that’s called.
IConvertable
System.Convert.ChangeType is then called.
Table 3.6 Custom type conversions (continued)
Converter type
Description
108
CHAPTER 3
W
ORKING
WITH
TYPES
7
If the argument type is a scalar, create a collection of the parameter type (cur-
rently only arrays and 
IList
are supported) of length 1 and set the argument 
value as the only value in the collection. If needed, the argument type is con-
verted to the element type for the collection using the same type coercion pro-
cess this section describes.
8
If the argument type is a collection, we create a collection of the parameter type 
with length equal to the number of values contained in the argument value. 
Each value is then coerced to the appropriate element type for the new collec-
tion using the recursive application of this algorithm.
9
If none of these steps worked, use the conversions in table 3.6. If those fail, then 
the overall parameter binding attempt fails.
Once again, this is a level of detail that you don’t often need to consider, but it’s useful 
to know it’s available when you need it. 
Scriptblock parameters
And finally, there’s one last aspect of the parameter binder type converter to cover: a 
feature called scriptblock parameters. 
First, a bit of a preview of things to come. PowerShell has something called a 
scriptblock. A scriptblock is a small fragment of code that you can pass around as an 
object itself. This is a powerful concept, and we’ll cover scriptblocks in great detail in 
later chapters, but for now we’re just going to look at them in the context of parame-
ter binding.
Here’s how scriptblock parameters work. Normally, when you pipe two cmdlets 
together, the second cmdlet receives values directly from the first cmdlet. Scriptblock 
parameters (you could also call them computed parameters) allow you to insert a piece 
of script to perform a calculation or transformation in the middle of the pipelined 
operation. This calculation can do pretty much anything you want since a scriptblock 
can contain any element of PowerShell script.
The following example shows how this works. You want to take a collection of 
XML files and rename them as text files. You could write a loop to do the processing, 
but scriptblock parameters greatly simplify this problem. To rename each file, use the 
Rename-Item
cmdlet. This cmdlet takes two parameters: the current name of the file 
and the new name. Use a scriptblock parameter as an argument to the 
-NewName 
parameter to generate the new filename. This scriptblock will use the 
-replace
oper-
ator to replace the .xml file extension with the desired .txt. Here’s the command line 
that performs this task:
dir *.xml | Rename-Item -Path {$_.name} `
-NewName {$_.name -replace '\.xml$', '.txt'} -whatif
The  original path  for 
-Path
is just the current name of the file. The 
-NewName 
parameter is the filename with the extension replaced. The 
-WhatIf
parameter will
S
UMMARY
109
let you see what the command will do before actually moving anything. Once you’re 
happy that the correct operations are being performed, just remove the 
-WhatIf
and 
the renaming will proceed.
Scriptblock parameters can be used with any pipelined parameter as long as the 
type of that parameter is not 
[object]
or 
[scriptblock]
. In these cases, the script-
block is passed as the actual parameter instead of using it to calculate a new value. 
You’ll see why this is important when we look at the 
Where-Object
and 
ForEach-
Object
cmdlets later on.
You now know everything you need to know about how types work on Power-
Shell. Well, not quite everything. In the next two chapters, we’ll discuss how the 
PowerShell  operators  build  on  this  basic  type  foundation.  But  for  now,  we’re 
through!
3.7
S
UMMARY
A solid understanding of the PowerShell type system will allow you to use PowerShell 
most effectively. By taking advantage of the built-in type system and conversions, you 
can accomplish startlingly complex tasks with little code. In this chapter, we covered 
the following topics:
• The PowerShell type system, how it works, and how you can use it
• The basic PowerShell types and how they are represented in PowerShell script 
(literals)
• Some of the more advanced types—hashtables and arrays
• The use of type literals in type casts and as a way to call static methods
• The added support in PowerShell version 2 for generic type literals that greatly 
simplify working with generic types
• The type conversion process for language conversions, the pre-conversion steps 
that are used by the parameter binder, and the relationship between the Power-
Shell types and the underlying .
NET
types
• Scriptblock parameters, which allow you to calculate new values for pipelined 
parameters instead of having to write a loop to do this (we’ll look at scriptblocks 
in detail in chapter 9)
Documents you may be interested
Documents you may be interested