c# pdf viewer free : Move pages in pdf Library control API .net web page windows sharepoint Windows%20Powershell%20in%20Action%202nd%20Edition12-part1464

90
CHAPTER 3
W
ORKING
WITH
TYPES
3.3.3
Hashtables as reference types
Hashtables are reference types, so if you create a hashtable, assign it to a variable 
$foo
, and assign 
$foo
to another variable, 
$bar
, you’ll have two variables that point 
to, or reference, the same object. Consequently, any changes that are made to one vari-
able will affect the other, because they’re pointing to the same object. Let’s try this 
out. Create a new hashtable and assign it to 
$foo
:
PS (2) > $foo = @{ 
>> a = 1 
>> b = 2 
>> c = 3 
>> } 
>>
PS (3) > $foo 
Key                            Value 
---                            -----
                             1 
                             2 
                             3
Now assign 
$foo
to 
$bar
and verify that it matches 
$foo
as you’d expect:
PS (4) > $bar = $foo 
PS (5) > $bar 
Key                            Value 
---                            -----
                             1 
                             2 
                             3
Next assign a new value to the element 
a
in 
$foo
:
PS (6) > $foo.a = "Hi there" 
PS (7) > $foo.a 
Hi there
And see what happened to 
$bar
:
PS (8) > $bar.a 
Hi there 
PS (9) > $bar 
Key                            Value 
---                            -----
                             Hi there 
                             2 
                             3
The change that was made to 
$foo
has been reflected in 
$bar
.
Now if you want to make a copy of the hashtable instead of just copying the refer-
ence, you can use the 
Clone()
method on the object:
PS (1) > $foo=@{a=1; b=2; c=3} 
PS (2) > $bar = $foo.Clone()
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
reorder pdf pages online; change page order pdf
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
pdf rearrange pages online; move pages within pdf
C
OLLECTIONS
ARRAYS
AND
SEQUENCES
91
Change the 
a
member in the table
PS (3) > $foo.a = "Hello"
and verify that the hashtable in 
$foo
has changed
PS (4) > $foo.a 
Hello
but the hashtable in 
$bar
hasn’t
PS (5) > $bar.a 
1
because it’s a copy, not a reference. This technique can be useful if you’re creating a 
number of tables that are mostly the same. You can create a “template” table, make 
copies, and then change the pieces you need to.
There’s still more to know about hashtables and how they work with operators, 
but we’ll cover that in chapters 4 and 5. For now, let’s move on to the next data type.
3.4
C
OLLECTIONS
ARRAYS
AND
SEQUENCES
In the previous section, we talked about hashtables and hash literals. Now let’s talk 
about the PowerShell syntax for arrays and array literals. Most programming languages 
have some kind of array literal notation similar to the PowerShell hash literal notation, 
where there’s a beginning character sequence followed by a list of values, followed by 
a closing character sequence. Here’s how array literals are defined in PowerShell:
They’re not. There’s no array literal notation in PowerShell. 
Yes, you read that correctly. There’s no notation for an array literal in PowerShell. So 
how exactly does this work? How do you define an inline array in a PowerShell script? 
Here’s the answer: instead of having array literals, there’s a set of operations that create 
collections as needed. In fact, collections of objects are created and discarded trans-
parently throughout PowerShell. If you need an array, one will be created for you. If 
you need a singleton (or scalar) value, the collection will be unwrapped as needed. 
3.4.1
Collecting pipeline output as an array
The most common operation resulting in an array in PowerShell is collecting the out-
put from a pipeline. When you run a pipeline that emits a sequence of objects and 
assign that output to a variable, it automatically collects the elements into an array, 
specifically into a .
NET
object of type 
[object[]]
But what about building a simple array in an expression? The simplest way to do 
this is to use the comma operator (,). For example, at the command line, type
1,2,3
and you’ll have created a sequence of numbers. (See chapter 5 for more information 
about using the comma operator.) When you assign that sequence to a variable, it’s
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 pdf; move pdf pages online
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.
how to move pages in a pdf; reorder pages of pdf
92
CHAPTER 3
W
ORKING
WITH
TYPES
stored as  an array. Assign these three numbers to a variable, 
$a
, and look at the 
result type:
PS (1) > $a = 1,2,3 
PS (2) > $a.gettype().fullname 
System.Object[]
As in the pipeline case, the result is stored in an array of type 
[object[]]
 
3.4.2
Array indexing
Let’s explore some of the operations that can be performed on arrays. As is commonly 
the case, getting and setting elements of the array (array indexing) is done with square 
brackets. The length of an array can be retrieved with the 
Length
property:
PS (3) > $a.length 
PS (4) > $a[0] 
1
Note that arrays in PowerShell are origin-zero; that is, the first element in the array is 
at index 0, not index 1. As the example showed, the first element of 
$a
is in 
$a[0]
.
As with hashtables,  changes are made to an array by assigning new values  to 
indexes in the array. The following example assigns new values to the first and third 
elements in 
$a
:
PS (5) > $a[0] = 3.1415 
PS (6) > $a
3.1415 
PS (7) > $a[2] = "Hi there" 
PS (8) > $a
3.1415 
Hi there 
PS (9) >
Looking at the output, you can see that elements of the array have been changed. 
Simple assignment updates the element at the specified index.
3.4.3
Polymorphism in arrays
Another important thing to note from the previous example is that arrays are poly-
morphic by default. By polymorphic we mean that you can store any type of object in 
an array. (A 
VBS
cript user would call these variant arrays.) When you created the 
array, you assigned only integers to it. In the subsequent examples, you assigned a 
floating-point number and a string. The original array was capable of storing any 
kind  of  object.  In  formal  terms,  PowerShell  arrays  are  polymorphic  by  default 
(though it’s possible to create type-constrained arrays).
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.
how to reorder pages in pdf reader; how to rearrange pages in a pdf reader
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.
move pages in pdf reader; reorder pages in pdf
C
OLLECTIONS
ARRAYS
AND
SEQUENCES
93
Earlier you saw how to get the length of an array. What happens when you try to 
assign to an element past the end of the array? The next example illustrates this:
PS (9) > $a.length 
PS (10) > $a[4] = 22 
Array assignment failed because index '4' was out of range. 
At line:1 char:4 
+ $a[4 <<<< ] = 22 
PS (11) >
Attempts to assign outside the bounds of an array will result in a range error. This is 
because PowerShell arrays are based on .
NET
arrays and their size is fixed. So how can 
you add more elements to a PowerShell array if the underlying objects are fixed in 
size? This is easily done through array concatenation using the plus (+) or plus-equals 
(+=) operators. Let’s add two more elements to the array from the previous example:
PS (11) > $a += 22,33 
PS (12) > $a.length 
PS (13) > $a[4] 
33 
PS (14) >
So the length of the array in 
$a
is now 5. The addition operation did add elements. 
Here’s how this works: 
1
PowerShell creates a new array large enough to hold the total number of elements. 
2
It copies the contents of the original array into the new one. 
3
It copies the new elements into the end of the array. 
You didn’t add any elements to the original array after all. Instead, you created a new, 
larger one.
3.4.4
Arrays as reference types
This copying behavior has some interesting consequences. You can explore this fur-
ther by first creating a simple array and looking at the value. Let’s use string expan-
sion here so that the values in the variable are all displayed on one line:
PS (1) > $a=1,2,3 
PS (2) > "$a" 
1 2 3
Now assign 
$a
to a new variable, 
$b
, and check that 
$a
and 
$b
have the same elements:
PS (3) > $b = $a 
PS (4) > "$b" 
1 2 3
Next, change the first element in 
$a
:
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 rearrange pages in a pdf document; how to reorder pdf pages in
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).
reorder pages in pdf online; how to reorder pages in pdf preview
94
CHAPTER 3
W
ORKING
WITH
TYPES
PS (5) > $a[0] = "Changed" 
PS (6) > "$a"
Changed 2 3
Yes, the first element in 
$a
was changed. But what about 
$b
PS (7) > "$b"
Changed 2 3
It was also changed. As with hashtables, array assignment is done by reference. When 
you assigned 
$a
to 
$b
, you got a copy of the reference to the array instead of a copy of 
contents of the array. Add a new element to 
$b
:
PS (8) > $b += 4 
PS (9) > "$b" 
Changed 2 3 4
$b
is now four elements long. Because of the way array concatenation works, 
$b
con-
tains a copy of the contents of the array instead of a reference. If you change 
$a
now, 
it won’t affect 
$b
. Let’s verify that:
PS (10) > $a[0] = "Changed again" 
PS (11) > "$a"
Changed again 2 3 
PS (12) > "$b"
Changed 2 3 4
You see that 
$b
wasn’t changed. Conversely, changing 
$b
should have no effect on 
$a
:
PS (13) > $b[0] = 1 
PS (14) > "$a"; "$b" 
Changed again 2 3 
1 2 3 4 
PS (15) >
Again, there was no change.
To reiterate, arrays in PowerShell, like arrays in other .
NET
languages, are refer-
ence types, not value types. When you assign them to a variable, you get another 
reference to the array, not another copy of the array.
3.4.5
Singleton arrays and empty arrays
You saw how to use the comma operator to build up an array containing more than 
one element. You can also use the comma operator as a prefix operator to create an 
array containing only one element. The next example shows this:
PS (1) > , 1 
PS (2) > (, 1).length 
PS (3) >
This code creates an array containing a single element, 
1
.
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 move pages in a pdf; rearrange pdf pages reader
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
how to rearrange pdf pages in preview; reorder pages pdf
C
OLLECTIONS
ARRAYS
AND
SEQUENCES
95
How about empty arrays? The comma operator always takes an argument to work 
on. Even using 
$null
as an argument to the comma operator will result in a one-
element array containing the 
$null
reference. Empty arrays are created through a 
special form of subexpression notation that uses the 
@
symbol instead of the 
$
sign to 
start the expression. Here’s what it looks like:
PS (3) > @()
PS (4) > @().length 
PS (5) >
In the preceding example, you created an array of length 0. This notation is more 
general—it takes the result of the expression it encloses and ensures that it’s always 
returned as an  array. If the expression returns 
$null
or a scalar value, it will be 
wrapped in a one-element array. Given this behavior, the other solution to creating an 
array with one element is
PS (1) > @(1) 
PS (2) > @(1).length 
1
That is, you place the value you want in the array in 
@(  ...  )
and you get an 
array back.
Use this notation when you don’t know whether the command you’re calling is 
going to return an array. By executing the command in this way, you’re guaranteed 
to get an array back. Note that if what you’re returning is already an array, it won’t be 
wrapped in a new array. Compare this to the use of the comma operator:
PS (1) >  1,2,3 
PS (2) > (1,2,3).Length 
PS (3) > ( , (1,2,3) ).Length 
PS (4) > ( @( 1,2,3 ) ).Length 
3
Line 1 created a regular array; on line 5, you get the length and see that it’s 3. Next, 
on line 7, you apply the prefix operator to the array and then get the length. The 
result now is only 1. This is because the unary comma operator always wraps its argu-
ments in a new array. Finally, on line 9, you use the 
@( ... )
notation and then get 
the length. This time it remains 3. The 
@( ... )
sequence doesn’t wrap unless the 
object isn’t an array.
Now let’s look at the last type of literal: the type literal. Because object types are so 
important in PowerShell, you need to be able to express types in a script. Remember 
with numbers, when you wanted to say, “Get me all the files larger than 10 
MB
,” you
96
CHAPTER 3
W
ORKING
WITH
TYPES
needed numeric literals? The same concept applies to types. If you want to be able to 
say, “Get me all the objects of a particular type,” you need to be able to express that 
type in the script.
3.5
T
YPE
LITERALS
In earlier sections, you saw a number of things that looked like 
[type]
. These are the 
type literals. In PowerShell, you use type literals a variety of ways. You use them to 
specify a particular type. They can be used as operators in a cast (an operation that 
converts an object from one type to another), as part of a type-constrained variable 
declaration (see chapter 4), or as an object itself. Here’s an example of a cast using a 
type literal:
$i = [int] "123"
In this example, you’re casting or converting a string into a number, specifically an 
instance of primitive .
NET
type 
System.Int32
. You could use the longer .
NET
type 
name to accomplish the same thing:
$i = [System.Int32] "123" 
Now let’s look at something a bit more sophisticated. If you wanted to make this into 
an array of integers, you’d do this:
$i = [int[]][object[]] "123"
In this example, you’re not just casting the basic type, you’re also changing it from a 
scalar object to an array. Notice that you had to do this in two steps. In the first step, 
you converted it into a collection but without changing the element type. In the sec-
ond step, you converted the types of the individual elements. This follows the general 
type converter rule that no more than one conversion will be performed in a single 
step. This rule makes it much easier to predict what any given conversion will do.  
NOTE
In this case, converting a scalar value into an array is so com-
mon that we added support for doing this directly in PowerShell v2. 
You can simply say 
$i = [int[]] "123"
.
3.5.1
Type name aliases
Obviously, the shorter type name (or type alias, as it’s known) is more convenient. 
Table 3.4 lists all the type aliases defined in PowerShell and the .
NET
types they cor-
respond to. It also indicates which version of  PowerShell the alias  is available in. 
(Another change that was made in v2 is that there are no longer separate aliases for 
arrays of the base type. As a result, these aren’t shown in the table as they were in the 
first  version  of  the  book.)  Anything  in  the 
System.Management.Automation 
namespace is specific to PowerShell. The other types are core .
NET
types and are cov-
ered in the 
MSDN
documentation.
T
YPE
LITERALS
97
Type resolution
When PowerShell resolves a type name, it first checks the type name alias table; 
then it checks to see whether a type exists whose full name matches the string 
specified. Finally it prepends the type with system. and checks to see whether a 
type exists that matches the new string. This means things that are in the System 
namespace look like they might be aliased. 
For example, the type System.IntPtr can be referred to as [intpr] even though 
it’s not in the alias table. For the most part, this referral is transparent. The one time 
it does matter is if, for some reason, a type was added to the system that lives in the 
top-level namespace. In this case, [intptr] would refer to the new type and you’d 
have to use [system.intptr] to refer to the system type. This should never 
happen because types should always be in namespaces. 
Table 3.4 PowerShell type aliases and their corresponding .NET types
Type alias
Corresponding .NET type
Version
[int]
System.Int32
1, 2
[long]
System.Int64
1, 2
[string]
System.String
1, 2
[char]
System.Char
1, 2
[bool]
System.Boolean
1, 2
[byte]
System.Byte
1, 2
[double]
System.Double
1, 2
[decimal]
System.Decimal
1, 2
[float]
System.Single
1, 2
[single]
System.Single
1, 2
[regex]
System.Text.RegularExpressions.Regex
1, 2
[array]
System.Array 
1, 2
[xml]
System.Xml.XmlDocument
1, 2
[scriptblock]
System.Management.Automation.ScriptBlock
1, 2
[switch]
System.Management.Automation.SwitchParameter
1, 2
[hashtable]
System.Collections.Hashtable
1, 2
[ref]
System.Management.Automation.PSReference
1, 2
[type]
System.Type
1, 2
[psobject]
System.Management.Automation.PSObject
1, 2
[pscustomobject]
System.Management.Automation.PSObject
2
[psmoduleinfo]
System.Management.Automation.PSModuleInfo
2
98
CHAPTER 3
W
ORKING
WITH
TYPES
3.5.2
Generic type literals
There’s a special kind of type in .
NET
called a generic type, which let you say some-
thing like “a list of strings” instead of just “a list.” And although you could do this 
without generics, you’d have to create a specific type for the type of list. With gener-
ics, you create one generic list type (hence the name) and then parameterize it with 
the type it can contain. 
NOTE
Generic type literal support was added in v2. In v1, it was pos-
sible to express a type literal, but it was a painful process. You’ll learn 
how to do this later in the book.
This  example  shows  the  type  literal  for  a  generic  list  (
System.Collections 
.Generic.List
) of integers:
PS (1) > [system.collections.generic.list[int]] | ft -auto
IsPublic IsSerial Name   BaseType 
-------- -------- ----   --------
True     True     List`1 System.Object 
If you look at the type literal, it’s easy to see  how the collection  element type is 
expressed: 
[int]
. This is essentially a nested type literal where the type parameter is 
enclosed in nested square brackets. Create an instance of this type:
PS (2) > $l = new-object system.collections.generic.list[int]
Then add some elements to it:
PS (3) > $l.add(1)
PS (4) > $l.add(2)
Get the count of elements added and list the elements:
PS (5) > $l.count 
2
[powershell]
System.Management.Automation.PowerShell
2
[runspacefactory] System.Management.Runspaces.RunspaceFactory
2
[runspace]
System.Management.Automation.Runspaces.Runspace
2
[ipaddress]
System.Net.IPAddress
2
[wmi]
System.Management.ManagementObject
1, 2
[wmisearcher]
System.Management.ManagementClass
1, 2
[wmiclass]
System.Management.ManagementClass
1, 2
[adsi]
System.DirectoryServices.DirectoryEntry
1, 2
[adsisearcher]
System.DirectoryServices.DirectorySearcher
1, 2
Table 3.4 PowerShell type aliases and their corresponding .NET types (continued)
Type alias
Corresponding .NET type
Version
T
YPE
LITERALS
99
PS (6) > $l 
2
Try to add something that isn’t an integer:
PS (7) > $l.add("hello")
Cannot convert argument "0", with value: "hello", for "Add" to 
type "System.Int32": "Cannot convert value "hello" to type "System 
.Int32". Error: "Input string was not in a correct format."" 
at line:1 char:7
$l.add <<<< ("hello")
+ CategoryInfo          : NotSpecified: (:) [], MethodExcep
tion
+ FullyQualifiedErrorId : MethodArgumentConversionInvalidCa
stArgument
This results in a type error because 
"hello"
can’t be converted into an integer. Now, 
if the string could be converted to a number, as in this example
PS (8) > $l.add("123") 
PS (9) > $l.count 
3
PowerShell would take care of the conversion and the operation could proceed with-
out error.
Finally, let’s look at a type that requires more than one type parameter. For exam-
ple, a generic dictionary requires two type parameters: the type of the keys and the 
type of the values. Here’s what this looks like:
PS (10) > [system.collections.generic.dictionary[string,int]] | 
>> Format-List -auto
IsPublic IsSerial Name         BaseType 
-------- -------- ----         --------
True     True     Dictionary`2 System.Object
The two type parameters are separated by a comma inside the square brackets. 
Now let’s take a trip into the “too-much-information” zone and look in detail at 
the process PowerShell uses to perform all of these type conversions. On first reading, 
you’ll probably want to skim this section but read it in detail later when you’re more 
comfortable with PowerShell. This is a “spinach” section—you may not like it, but 
it’s good for you.
The primary uses for type literals are in performing type conversions and invoking 
static methods. We’ll look at both of these uses in the next two sections. 
3.5.3
Accessing static members with type literals
As mentioned, a common use for type literals is for accessing static methods on .
NET 
classes. You can use the 
Get-Member
cmdlet to look at the members on an object. To 
view the static members, use the 
-Static
flag:
Documents you may be interested
Documents you may be interested