c# pdf viewer free : Reorder pages in pdf reader Library control class asp.net web page winforms ajax Windows%20Powershell%20in%20Action%202nd%20Edition43-part1498

400
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Now that you know how to manipulate scriptblocks and functions, let’s take this 
one step further. As discussed in chapter 1, objects encapsulate data and code. We’ve 
spent a lot of time on data in the earlier chapters, and now we have a way of manipu-
lating code too. This means that you’re ready to take the next step and see how you 
can use data and scriptblocks to build your own objects. 
11.2
B
UILDING
AND
MANIPULATING
OBJECTS
Let’s kick our scripting up a notch and look at ways to build custom objects. Up to this 
point in the chapter we’ve been talking about scriptblocks as stand-alone functions. 
Now it’s time to talk about how to use scriptblocks to build objects. At their core, as 
discussed in chapter 1, objects are a binding of data and behaviors. These behaviors are 
implemented by blocks of script. You needed to know how to build the blocks of code, 
scriptblocks, before we could talk about building objects. With a good understanding 
of scriptblocks, we can now discuss manipulating and building objects in PowerShell.
In  chapter  2,  we  talked  extensively  about  types.  Now  we’re  concerned  with 
objects—that is, instances of types. A type is the pattern or template that describes an 
object, and an object is an instance of that pattern. In statically typed languages such 
as 
C
#, once an object is instantiated, its interfaces can’t be changed. With dynamic 
languages such as PowerShell (or Ruby or Python), this isn’t true. Dynamic lan-
guages allow you to alter the set of members available at runtime.
NOTE
As of 
C
# 4.0, the language is no longer strictly statically typed. 
C# 4.0 introduced a new “dynamic” keyword, allowing you to write 
programs that have dynamic types. 
In the rest of this section, we’ll explore manipulating objects and types in PowerShell. 
We’ll start with a discussion of how to examine existing members, followed by a look 
at the types of members available on an object. Then we’ll cover the various ways to 
add members to an object, and finally we’ll look at the plumbing of the PowerShell 
type system to give you a sense of the flexibility of the overall system and how it facil-
itates your goal of writing programs to manipulate programs.
11.2.1
Looking at members
An object’s interface is defined by the set of public members it exposes. Public mem-
bers are the public fields, properties, and methods of the class. As always, the easiest 
way to look at those members is with the 
Get-Member
cmdlet. For example, here are 
the members defined on an integer:
PS (1) > 12 | Get-Member
TypeName: System.Int32
Name        MemberType Definition 
----        ---------- ----------
CompareTo   Method     System.Int32 CompareTo(Int32 value), S... 
Equals      Method     System.Boolean Equals(Object obj), Sys...
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
reorder pdf pages reader; how to move pages in a pdf file
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 acrobat; reorder pages of pdf
B
UILDING
AND
MANIPULATING
OBJECTS
401
GetHashCode Method     System.Int32 GetHashCode()
GetType     Method     System.Type GetType()
GetTypeCode Method     System.TypeCode GetTypeCode()
ToString    Method     System.String ToString(), System.Strin...
Note that this doesn’t show you all the members on an 
[int]
. It only shows you the 
instance members. You can also use 
Get-Member
to look at the static members:
PS (2) > 12 | Get-Member -Static
TypeName: System.Int32
Name            MemberType Definition 
----            ---------- ----------
Equals          Method     static System.Boolean Equals(Objec... 
Parse           Method     static System.Int32 Parse(String s... 
ReferenceEquals Method     static System.Boolean ReferenceEqu... 
TryParse        Method     static System.Boolean TryParse(Str... 
MaxValue        Property   static System.Int32 MaxValue {get;} 
MinValue        Property   static System.Int32 MinValue {get;}
You’ll use this mechanism to look at the members you’ll be adding to objects in the 
next couple of sections.
Defining synthetic members
One of the most powerful features in the PowerShell environment is the ability to 
extend existing object types and instances. This allows PowerShell to perform adapta-
tion across a wide variety of types of data. By adaptation, we mean overlaying a com-
mon set of interfaces onto existing data sources. This may be as simple as unifying the 
name of the property that counts a collection to be the string  “count” across  all 
countable objects or as complex as taking a string containing some XML data and 
being able to treat that string as an object with a set of properties and attributes. 
This isn’t the same as subclassing or creating derived types as you would in tradi-
tional object-oriented programming languages. In those languages, if you want to 
extend a new type, you can do so only by creating an entirely new type. In dynamic 
languages such as PowerShell, you can add members to existing types and objects. 
This sounds odd from the point of view of a conventional object-oriented language, 
because types and member definitions are so tightly tied together. In languages such 
as PowerShell, it’s possible to have objects that don’t have any type at all.
NOTE
If  you’re  a  JavaScript  user,  this  won’t  be  surprising.  The 
object-oriented mechanisms in JavaScript use a mechanism called pro-
totypes. Prototype-based systems don’t have types as discrete objects. 
Instead, you use an object that has the set of members you want to use 
and use it as the prototype for your new object. Although PowerShell 
isn’t strictly a prototype-based language, its type extension mechanisms 
can be used in much the same way.
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 file; how to reorder pdf pages in reader
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
how to rearrange pages in a pdf document; reorder pages in pdf
402
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Because the members you’ll be adding to objects aren’t natively part of the object’s 
definition, they’re called synthetic members. Synthetic members are used extensively 
throughout PowerShell for adaptation and extension. Let’s look at an example. First, 
we’ll examine the synthetic properties on an object returned by 
dir
from the file 
system:
PS (6) > dir $profile | Get-Member ps*
TypeName: System.IO.FileInfo
Name          MemberType   Definition 
----          ----------   ----------
PSChildName   NoteProperty System.String PSChildName=Microsof... 
PSDrive       NoteProperty System.Management.Automation.PSDri... 
PSIsContainer NoteProperty System.Boolean PSIsContainer=False 
PSParentPath  NoteProperty System.String PSParentPath=Microso... 
PSPath        NoteProperty System.String PSPath=Microsoft.Pow... 
PSProvider    NoteProperty System.Management.Automation.Provi...
Now let’s get the same information from the Registry:
PS (8) > dir hklm:\software | Get-Member ps*
TypeName: Microsoft.Win32.RegistryKey
Name          MemberType   Definition 
----          ----------   ----------
PSChildName   NoteProperty System.String PSChildName=Adobe 
PSDrive       NoteProperty System.Management.Automation.PSDri... 
PSIsContainer NoteProperty System.Boolean PSIsContainer=True 
PSParentPath  NoteProperty System.String PSParentPath=Microso... 
PSPath        NoteProperty System.String PSPath=Microsoft.Pow... 
PSProvider    NoteProperty System.Management.Automation.Provi...
You can see the same set of 
PS*
properties with the PowerShell 
(PS)
prefix on the 
object, even though they’re completely different types. Take a look at these properties. 
They allow you to work with these two different objects in the same way. This means 
that you can always tell if an object might have children by looking at the 
PSIs-
Container
property, regardless of the type of the underlying object. And you can 
always get the path to the object through the 
PSPath
property. We call this type of 
adaptation object  normalization.  By  adding  this  set  of  synthetic properties  to  all 
objects  returned from  the  provider  infrastructure,  you make  it  possible  to  write 
scripts that are independent of the type of object that the provider surfaces. This 
makes the scripts both simpler and more reusable. In the next section we’ll start look-
ing at ways to create synthetic members.
11.2.2
Using Add-Member to extend objects
The 
Add-Member
cmdlet is the easiest way to add a new member to an object 
instance, either a static .
NET
object type or a custom synthetic object. It can be used
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
pdf change page order; reorder pages in pdf online
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
reorder pdf page; pdf change page order online
B
UILDING
AND
MANIPULATING
OBJECTS
403
to add any type of member supported by the PowerShell type system. The list of 
possible member types that can be added with 
Add-Member
is shown in table 11.1.
You’ll work through some examples showing how to use these members. You’ll 
use an instance of the string “Hi there” to do this. For convenience, store it in a vari-
able 
$s
as shown:
PS (1) > $s = "Hi there"
Now let’s go over how you add these member types to an object instance.
Table 11.1  Member types that can be added with Add-Member
Member type
Version
Description
AliasProperty
v1, v2
An alias property provides an alternate name for an exist-
ing property. For example, if there is an existing Length
property, then you might alias this to Count.
CodeProperty
v1, v2
A property that maps to a static method on a .NET class.
Property
v1, v2
A native property on the object. In other words, a prop-
erty that exists on the underlying object that is surfaced 
directly to the user. For example, there might be a native 
property Length that you choose to also make available 
through an extended alias member.
NoteProperty
v1, v2
A data-only member on the object (equivalent to a .NET 
field).
ScriptProperty
v1, v2
A property whose value is determined by a piece of Pow-
erShell script.
Properties
v1, v2
The collection of properties exposed by this object.
PropertySet
v1, v2
A named group of properties.
Method
v1, v2
A native method on the underlying object. For example, 
the SubString() method on the class 
System.String shows up as a method.
CodeMethod
v1, v2
A method that is mapped to a static method on a .NET 
class.
ScriptMethod
v1, v2
A method implemented in PowerShell script.
ParameterizedProperty
v1, v2
A property that takes both arguments and a value to 
assign. This is typically used for things like indexers and 
might look like 
$collection.item(2.3)  = "hello"
This sets the element at 2,3 in the collection to the value 
"hello".
PSVariableProperty
v2
A property that is backed by a variable. This type of mem-
ber was introduced in version 2 along with modules. It 
has an advantage over note properties because it can be 
type-constrained.
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 reader; how to rearrange pdf pages
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.
move pages in a pdf; rearrange pages in pdf document
404
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Adding AliasProperty members
The first type of synthetic member you’ll add is called an alias property. This prop-
erty, whose name is (surprise) 
AliasProperty
, allows you to provide a new name for 
an existing property. Let’s work with the 
Length
property on a string:
PS (2) > $s.Length 
8
As you can see, this string has a length of 8. Let’s say that you want to add an alias 
size
for 
Length
because you’ll be working with a set of objects that all have a 
size 
property:
PS (3) > $s = Add-Member -PassThru -in $s AliasProperty size length
There are a couple things to note in this example. First (and most important) is that 
when you first add a synthetic member to an object, you’re creating a new object (but 
not a new type). This new object wraps the original object in an instance of 
System 
.Management.Automation.PSObject
. Just as 
System.Object
is the root of the 
type system in .NET, 
PSObject
is the root of the synthetic type system in Power-
Shell. For this reason, you assign the result of the 
Add-Member
call back to the origi-
nal variable. To do this, you have to add the 
-PassThru
parameter to the command 
since, by default, the 
Add-Member
cmdlet doesn’t emit anything.
Let’s look at the new member you’ve added using 
gm
(the alias for 
Get-Member
):
PS (4) > $s | gm size
TypeName: System.String
Name MemberType    Definition 
---- ----------    ----------
size AliasProperty size = length
Again, there are a couple of things to note. You can see that the 
size
member is there 
and is an alias property that maps 
size
to 
Length
. Also, you need to note that the 
object’s type is still 
System.String
. The fact that it’s wrapped in a 
PSObject
is 
pretty much invisible from the script user’s view, though you can test for it as shown 
in the next example. Using the 
-is
operator, you can test to see whether or not the 
object you’re dealing with is wrapped in a 
PSObject
:
PS (5) > $s -is [PSObject] 
True 
PS (6) > "abc" -is [PSObject] 
False 
PS (7) > $s -is [string]
True
The  result  of  the  first  command  in  the  example  shows  that 
$s
does contain a 
PSObject
. The second command shows that the raw string doesn’t, and the last line 
shows  that  the  object  in 
$s
is still considered a string, even though it’s also a 
PSObject
.
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
how to reverse pages in pdf; how to move pages around in pdf file
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
how to rearrange pages in pdf document; how to reorder pages in pdf reader
B
UILDING
AND
MANIPULATING
OBJECTS
405
The question now is, after all that explanation, did you actually create this aliased 
member? The answer is, yes:
PS (8) > $s.size 
PS (9) > $s.Length 
8
Both the 
size
and 
length
members return the value 8.
Adding NoteProperty members
Now let’s add a note property. A note property is a way of attaching a new piece of 
data (a note) to an existing object, rather like putting a sticky note on your monitor. 
Again you’ll use the same string in 
$s
. Let’s add a note property called 
Description
In this example, because you know that 
$s
is already wrapped in a 
PSObject
, you 
don’t need to use 
-PassThru
and do the assignment—you simply add the property 
to the existing object:
PS (10) > Add-Member -in $s NoteProperty description "A string" 
PS (11) > $s.Description 
A string
You’ve added a 
Description
property to the object with the value “A string”. And, 
to prove that this property isn’t present on all strings:
PS (12) > "Hi there".Description 
PS (13) >
You see that the property returned nothing.
Of course, the note property is a settable property, so you can change it with an 
assignment like any other settable property:
PS (14) > $s.Description = "A greeting" 
PS (15) > $s.Description 
A greeting
In this example, you changed the value in the note property to “A greeting”. Note 
properties allow you  to  attach arbitrary data to an object. They aren’t type con-
strained, so they can hold any type. 
NOTE
Sooner or later, if you’re working through all the examples in this 
chapter, something will fail because one example collides with another. 
If that happens, start a new PowerShell session and keep going. If you’re 
using the 
ISE
, you can switch to a new tab by pressing 
C
trl-
T
. This will 
allow you to flip back and forth between sessions to compare things.
Next, set the 
Description
property to a 
[datetime]
object:
PS (16) > $s.Description = Get-Date 
PS (17) > $s.Description
Sunday, May 28, 2006 4:24:50 PM
406
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
But the value stored in the object is still a 
[datetime]
object, not a string. As such, 
you can get the 
DayOfWeek
property out of the 
description
property:
PS (18) > $s.Description.dayofweek 
Sunday 
PS (19) > $s.Description.GetType().FullName 
System.DateTime
Adding ScriptMethod members
Both of the synthetic members you’ve added so far have been pure data properties; no 
code was involved. Now we’ll look at adding members that execute code. We’ll start 
with 
ScriptMethods
, because they’re easiest. You’ll add a method that returns the 
string that it’s associated with, reversed. First, let’s find an easy way to reverse a string. 
If you examine 
[string]
, you’ll see that there is (unfortunately) no reverse method on 
the string class. There is, though, a static reverse method on 
[array]
that you can use:
PS (1) > [array] | Get-Member -Static reverse
TypeName: System.Array
Name    MemberType Definition 
----    ---------- ----------
Reverse Method     static System.Void Reverse(Array array), s...
This method takes an array and, because it’s void, it must (obviously) reverse the array 
in place. This tells us two things: we need to turn the string into an array (of charac-
ters) and then save it in a variable so it can be reversed in place. Converting the string 
to an array of characters is simple—you can use a cast:
PS (19) > $s
Hi there 
PS (20) > $a = [char[]] $s
Casting a string into the type 
[char[]]
(array of characters) produces a new object 
that’s the array of individual characters in the original string. Just to verify this:
PS (21) > $a.GetType().FullName 
System.Char[]
PS (22) > "$a"
H i   t h e r e
You see that the type of the new object is 
[char[]]
and it does contain the expected 
characters. Now reverse it using the 
[array]::reverse()
static method:
PS (23) > [array]::reverse($a) 
PS (24) > "$a" 
e r e h t   i H
When you look at the contents of the array, you see that the array has been reversed. 
But it’s still an array of characters. The final step is to turn this back into a string. To 
do this, you’ll use the unary 
-join
operator:
PS (25) > $ns = -join $a 
PS (26) > $ns
B
UILDING
AND
MANIPULATING
OBJECTS
407
ereht iH
PS (27) > $ns.GetType().FullName 
System.String
At this point you have the reversed string in 
$ns
. But the goal of this effort was to 
attach this as a method to the string object itself. To do so, you need to construct a 
scriptblock to use as the body of the 
ScriptMethod
. This definition looks like
PS (28) > $sb = { 
>>     $a = [char[]] $this 
>>     [array]::reverse($a) 
>>     -join $a 
>> } 
>>
This example introduces a new “magic” variable, which is defined only for script-
blocks that are used as methods or properties: the 
$this
variable. 
$this
holds the 
reference to the object that the 
ScriptMethod
member was called from. Now let’s 
bind this scriptblock to the object as a 
ScriptMethod
using 
Add-Member
:
PS (29) > Add-Member -in $s ScriptMethod Reverse $sb
Try it out:
PS (30) > $s.reverse() 
ereht iH
You get the reversed string as desired.
Adding ScriptProperty members
The next type of member we’ll look at is the 
ScriptProperty
. A 
ScriptProperty 
has up to two methods associated with it—a getter and (optionally) a setter, just like 
a .
NET
property. These methods are expressed using two scriptblocks. As was the case 
with the 
ScriptMethod
, the referenced object is available in the 
$this
member. And, 
in the case of the setter, the value being assigned is available in 
$args[0]
. Here’s an 
example. You’re going to add a 
ScriptProperty
member, 
desc
, to 
$s
that will pro-
vide an alternate way to get at the description 
NoteProperty
you added earlier, with 
one difference: you’re only going to allow values to be assigned that are already strings. 
An attempt to assign something that isn’t a string will result in an error.
Here’s the definition of this property:
PS (31) > Add-Member -in $s ScriptProperty Desc ` 
>>   {$this.Description} ` 
>>   { 
>>     $t = $args[0] 
>>     if ($t -isnot [string]) { 
>>       throw "this property only takes strings" 
>>     } 
>>     $this.Description = $t 
>>   } 
>>
408
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
The first scriptblock
{$this.Description}
is the code that will be executed when getting the property’s value. All it does is return 
the value stored in the description 
NoteProperty
. Because the setter needs to do 
some additional work, its scriptblock is more complex:
{
$t = $args[0]
if ($t -isnot [string])
{
throw "this property only takes strings"
}
$this.Description = $t 
}
First, it saves the value to be assigned into a local variable, 
$t
. Next, it checks whether 
this variable is of the correct type. If not, it throws an exception, failing the assignment.
Let’s try out this property. First, directly set the note property to the string “Old 
description”:
PS (32) > $s.Description = "Old description"
Now use the 
ScriptProperty
getter to retrieve this value:
PS (33) > $s.Desc 
Old description
You see that it’s changed as expected. Next use the 
ScriptProperty
to change the 
description:
PS (34) > $s.desc = "New description"
Verify the change by checking both the 
NoteProperty
and the 
ScriptProperty
:
PS (35) > $s.Description 
New description 
PS (36) > $s.desc 
New description 
PS (37) >
Yes, it’s been changed. Now try assigning a 
[datetime]
object to the property as you 
did with the description 
NoteProperty
previously:
PS (37) > $s.desc = Get-Date 
Exception setting "desc": "this property only takes strings" 
At line:1 char:4 
+ $s.d <<<< esc = Get-Date
The assignment failed. Using 
ScriptProperty
members is a way to do validation 
and transformation in properties on objects.
NOTE
The idea of adding properties to synthetic objects may seem 
like an academic exercise, but it turns out to be useful. In particular,
B
UILDING
AND
MANIPULATING
OBJECTS
409
it’s incredibly useful when you need to adapt existing utilities so that 
they work effectively in the  PowerShell environment. For example, 
section 11.7 shows how to adapt the output of the task scheduler util-
ity 
schtasks.exe
so that it can work effectively in the PowerShell 
environment.  Another  useful  scenario  for  this  technique  is  joining 
two collections of data properties into a single object, as illustrated in 
appendix B.
11.2.3
Adding note properties with New-Object
The most common case for adding members is when creating a synthetic object with 
a set of note properties. This is equivalent to creating records in other languages. In 
many cases, hashtables are sufficient for record-like scenarios, creating objects has 
some advantages—the formatting system treats objects in a more sophisticated way, 
and assigning to a member that doesn’t exist is treated as an error, whereas assigning 
to a member that doesn’t exist in a hashtable simply creates a new member. This is a 
common enough scenario that there’s special support for this in PowerShell v2 with a 
new  parameter  on  the 
New-Object
cmdlet: 
-Property
 This  parameter  takes  a 
hashtable  and sets each member on the object being created that corresponds to 
member in the hashtable. If the member doesn’t exist, then a note property is added. 
If the object being created is a 
PSObject
, then you end up with a pure synthetic 
object. Here’s an example of how this works:
PS (1) > $obj = New-Object PSObject -Property @{a=1; b=2; c=3}
In this example, you created a new object with three properties: a, b, and c:
PS (2) > $obj | Format-Table -auto 
a b c 
- - -
1 2 3
Using 
Get-Member
you can see that they are all of type 
NoteProperty:
PS (3) > $obj | Get-Member
TypeName: System.Management.Automation.PSCustomObject
Name        MemberType   Definition 
----        ----------   ----------
Equals      Method       bool Equals(System.Object obj) 
GetHashCode Method       int GetHashCode()
GetType     Method       type GetType()
ToString    Method       string ToString() 
          NoteProperty System.Int32 a=1 
          NoteProperty System.Int32 b=2 
          NoteProperty System.Int32 c=3
Also notice that the type of the object returned is 
System.Management.Automation 
.PSCustomObject
, which isn’t a type you’ve seen before. This type of object is used as
Documents you may be interested
Documents you may be interested