c# pdf viewer free : Reorder pages pdf file application software cloud windows azure .net class Windows%20Powershell%20in%20Action%202nd%20Edition46-part1501

430
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
instance of this class. This function will invoke the scriptblock provided to it. This 
scriptblock is expected to return a collection of synthetic member objects. The func-
tion will then take these members and attach them to the object being created. This is 
a helper function that also has to be global, so  again you’ll give  it a name that’s 
unlikely to collide with other global functions:
function global:__new_instance ([scriptblock] $definition) 
{
At this point you define some local  functions to use in the body  of the 
__new_ 
instance
function. First, define a helper method for generating error messages:
function elementSyntax ($msg)
{
throw "class element syntax: $msg"
   
In the example, you had keywords for each of the member types you could add. You’ll 
implement this by defining functions that implement these keywords. Because of the 
way dynamic scoping works (see chapter 7), these functions will be visible to the script-
block when it’s invoked, because they’re defined in the enclosing dynamic scope.
First, define the function for creating a note element in the class. This implements 
the note keyword in the class definition. It takes the name of the note and the value 
to assign to it and returns a 
PSNoteProperty
object to the caller:
function note ([string]$name, $value)
{
if (! $name) {
elementSyntax "note name <value>"
}
New-Object Management.Automation.PSNoteProperty `
$name,$value
}
Next, define the function that implements the method keyword. This function takes 
the method name and scriptblock that will be the body of the method and returns a 
PSScriptMethod
object:
function method ([string]$name, [scriptblock] $script)
{
if (! $name) {
elementSyntax "method name <value>"
}
New-Object Management.Automation.PSScriptMethod `
$name,$script
}
You could continue to define keyword functions for all the other member types, but 
to keep it simple, stick with just these two. 
Having defined your keyword functions, you can look at the code that actually 
builds the object. First, create an empty 
PSObject
with no methods or properties:
$object = New-Object Management.Automation.PSObject
Reorder pages pdf file - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to reverse page order in pdf; pdf reverse page order preview
Reorder pages pdf file - 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 change page order online; switch page order pdf
E
XTENDING
THE
P
OWER
S
HELL
LANGUAGE
431
Next, execute the scriptblock that defines the body of this class. As mentioned previ-
ously, the result of that execution will be the set of members to attach to the new 
object you’re creating:
$members = &$definition
Finally, attach the members to the object:
foreach ($member in $members) {
if (! $member) {
Write-Error "bad member $member"
} else {
$object.psobject.members.Add($member)
}
}
The last thing to do is return the constructed object:
$object 
}
As mentioned, the 
_new_instance
function was a worker function; the user never 
calls it directly. Now define the function that the user employs to define a new class. 
Again, this has to be a global function, but this time, because the user calls it, you’ll 
give it a conventional name:
function global:CustomClass 
{
This function takes the name of the class and the scriptblock to execute to produce 
the members that will be attached to that class:
param ([string] $type, [scriptblock] $definition)
If there’s already a class defined by the name that the user passed, throw an error:
if ($global:__ClassTable__[$type]) {
throw "type $type is already defined"
}
At this point, you’ll execute the scriptblock to build an instance of the type that will 
be discarded. You do this to catch any errors in the definition at the time the class is 
defined, instead of the first time the class is used. It’s not strictly necessary to do this, 
but it will help you catch any errors sooner rather than later:
__new_instance $definition > $null
Finally, add the class to the hashtable of class definitions
$global:__ClassTable__[$type] = $definition 
}
and you’re finished implementing the 
class
keyword. Next you have to define the 
new keyword. This turns out to be a simple function. The new keyword takes the
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
move pages in pdf; reorder pages in pdf
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split may choose to only rotate a single page of PDF file or all
how to move pages in a pdf document; how to reorder pages in pdf reader
432
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
name of the class you want to create an instance of, looks up the scriptblock to exe-
cute, and calls 
__new_instance
to build the object:
function global:new ([string] $type) 
{
$definition = $__ClassTable__[$type]
if (! $definition) {
throw "$type is undefined"
}
__new_instance $definition 
}
Finally, add one last helper function that will allow you to remove a class definition 
from the hashtable:
function remove-class ([string] $type) 
{
$__ClassTable__.remove($type) 
}
This, then, is the end of the class.ps1 script. You should try it out with the point 
example you saw at the beginning of this section. First run the script containing the 
code to set up all the definitions. (Because you explicitly defined things to be global 
in the script, there’s no need to “dot” this script.) 
PS (1) > ./class
Now define the point class:
PS (2) > CustomClass point { 
>>     note x 0 
>>     note y 0 
>>     method ToString { "($($this.x), $($this.y))"} 
>>     method scale { 
>>         $this.x *= $args[0] 
>>         $this.y *= $args[0] 
>>     } 
>> } 
>>
Next, create an instance of this class:
PS (3) > $p = new point
Use 
Get-Member
to look at the members on the object that was created:
PS (4) > $p | Get-Member
TypeName: System.Management.Automation.PSCustomObject
Name        MemberType   Definition 
----        ----------   ----------
Equals      Method       System.Boolean Equals(Object obj) 
GetHashCode Method       System.Int32 GetHashCode() 
GetType     Method       System.Type GetType()
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
change page order pdf preview; change page order pdf reader
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 reorder pages in pdf online; reordering pages in pdf
E
XTENDING
THE
P
OWER
S
HELL
LANGUAGE
433
          NoteProperty System.Int32 x=0 
          NoteProperty System.Int32 y=0 
scale       ScriptMethod System.Object scale(); 
ToString    ScriptMethod System.Object ToString();
You see the actual type of the object is 
PSCustomType
—the type that PowerShell uses 
for pure synthetic objects. You can also see the members you defined in the class defi-
nition:  the  two  note  properties, 
x
and 
y
 and  the  two  methods, 
scale()
and 
ToString()
. To try them out, first call 
ToString()
:
PS (5) > $p.tostring() 
(0, 0)
You see the default values for the note members, formatted as intended. Next, set the 
note members to new values:
PS (6) > $p.x=2
PS (7) > $p.y=3
Verify that they’ve been set:
PS (8) > $p.tostring() 
(2, 3)
Now call the 
scale()
method to multiply each note member by a scale value:
PS (9) > $p.scale(3)
And again, verify the values of the note members with 
ToString()
:
PS (10) > $p.tostring() 
(6, 9)
The values have been scaled. 
Finally, to see how well this all works, use this object with the format operator, 
and you’ll see that your 
ToString()
method is properly called:
PS (11) > "The point p is {0}" -f $p 
The point p is (6, 9)
So, in less than 100 lines of PowerShell script, you’ve added a new keyword that lets 
you define you own classes in PowerShell. Obviously, this isn’t a full-featured type 
definition system; it doesn’t have any form of inheritance, for example. But it does 
illustrate how you can use scriptblocks along with dynamic scoping to build new lan-
guage features in PowerShell in a sophisticated way.
Now let’s change gears a bit to talk about types. 
11.7.3
Type extension
You might have noticed that all the examples we’ve looked at so far involve adding 
members to instances. But what about adding members to types? Having to explicitly 
add members to every object you encounter would be pretty tedious, no matter how 
clever you are. You need some way to extend types. Of course, PowerShell also lets
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
delete or remove certain page from PDF document file. C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize
rearrange pages in pdf; change pdf page order online
Read PDF in Web Image Viewer| Online Tutorials
for image viewing to read, edit, create or write PDF documents from file or stream in Extract images from PDF documents; Add, reorder pages in PDF
how to move pages in pdf converter professional; how to move pages in pdf files
434
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
you do this. In this section, we’ll introduce the mechanisms that PowerShell provides 
that let you extend types.
Type extension is performed in PowerShell through a set of 
XML
configuration 
files. These files are usually loaded at startup time, but they can be extended after the 
shell has started. In this section, you’ll learn how to take advantage of these features.
Let’s look at an example. Consider an array of numbers. It’s fairly common to 
sum up a collection of numbers; unfortunately, there’s no 
Sum()
method on the 
Array
class:
PS (1) > (1,2,3,4).sum()
Method invocation failed because [System.Object[]] doesn't conta 
in a method named 'sum'.
At line:1 char:14 
+ (1,2,3,4).sum( <<<< )
Using the techniques we’ve discussed, you could add such a method to this array:
PS (3) > $a = Add-Member -PassThru -in $a scriptmethod sum { 
>> $r=0 
>> foreach ($e in $this) {$r += $e} 
>> $r 
>> } 
>>
And finally use it:
PS (4) > $a.sum() 
10
But this would be painful to do for every instance of an array. What you need is a way 
to attach new members to a type, rather than through an instance. PowerShell does 
this through type configuration files. These configuration files are stored in the instal-
lation directory for PowerShell and loaded at startup. The installation directory path 
for PowerShell is stored in the 
$PSHome
variable, so it’s easy to find these files. They 
have the word type in their names and have an extension of .ps1xml:
PS (5) > dir $pshome/*type*.ps1xml
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Program
Files\Windows PowerShell\v1.0
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---         4/19/2006   4:12 PM      50998 DotNetTypes.Format.
ps1xml 
-a---         4/19/2006   4:12 PM     117064 types.ps1xml
You don’t want to update the default installed types files because when you install 
updates  for  PowerShell,  they’ll  likely  be  overwritten  and  your  changes  will  be 
lost. Instead, create your own custom types file containing the specification of the 
new  member  for 
System.Array
 Once  you’ve  created  the  file,  you  can  use  the
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 rearrange pages in pdf document; how to rearrange pages in a pdf document
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 reorder pdf pages in; reorder pages in pdf document
E
XTENDING
THE
P
OWER
S
HELL
LANGUAGE
435
Update-TypeData
cmdlet to load it. Here’s the definition for the 
Sum()
method 
extension you want to add to 
System.Array
:
<Types>
<Type>
<Name>System.Array</Name>
<Members>
<ScriptMethod>
<Name>Sum</Name>
<Script>
$r=$null
foreach ($e in $this) {$r += $e}
$r
</Script>
</ScriptMethod>
</Members>
</Type> 
</Types>
This definition is saved to a file called SumMethod.ps1xml. Now load the file and 
update the type system definitions:
PS (9) > Update-TypeData SumMethod.ps1xml
If the file loads successfully, you won’t see any output. You can now try out the 
sum() 
function:
PS (10) > (1,2,3,4,5).sum() 
15
It worked. And, because of the way the script was written, it will work on any type 
that can be added. So let’s add some strings:
PS (11) > ("abc","def","ghi").Sum() 
abcdefghi
You can even use it to add hashtables:
PS (12) > (@{a=1},@{b=2},@{c=3}).sum()
Name                           Value 
----                           -----
                             1 
                             2 
                             3
You can see that the result is the composition of all three of the original hashtables. 
You can even use it to put a string back together. Here’s the “hal” to “ibm” example 
from chapter 3, this time using the 
Sum()
method:
PS (13) > ([char[]] "hal" | %{[char]([int]$_+1)}).sum() 
ibm
Here you break the original string into an array of characters, add 1 to each character, 
and then use the 
Sum()
method to add them all back into a string.
436
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
You should take some time to examine the set of type configuration files that are 
part of the default PowerShell installation. Examining these files is a good way to see 
what you can accomplish using these tools.
We’ve covered an enormous amount of material so far in this chapter, introducing 
ideas that are pretty new to a lot of users. If you’ve hung on to this point, congratula-
tions! There are only a few more topics to complete your knowledge of metaprogram-
ming with PowerShell. Scriptblocks, dynamic modules, and closures can be passed 
around, invoked, and assigned at runtime, but the body of these blocks is still defined 
at compile time. In the next section we’ll expand our repertoire of techniques by 
looking at ways to dynamically create code. 
11.8
B
UILDING
SCRIPT
CODE
AT
RUNTIME
This final section presents the mechanisms that PowerShell provides for compiling 
script code and creating new scriptblocks at runtime. To saying that you’re “compil-
ing” when PowerShell is an interpreted language may sound a odd, but that’s essen-
tially  what  creating  a  scriptblock  is:  a  piece  of  script  text  is  compiled  into  an 
executable object. In addition, PowerShell provides mechanisms for directly executing 
a string, bypassing the need to first build a scriptblock. In the next few sections we’ll 
look at how each of these features works.
11.8.1
The Invoke-Expression cmdlet
The 
Invoke-Expression
cmdlet is a way to execute an arbitrary string as a piece of 
code. It takes the string, compiles it, and then immediately executes it in the current 
scope. Here’s an example:
PS (1) > Invoke-Expression '$a=2+2; $a' 
4
In this example, the script passed to the cmdlet assigned the result of 
2+2
to 
$a
and 
wrote 
$a
to the output stream. Because this expression was evaluated in the current 
context, it should also have affected the value of 
$a
in the global scope:
PS (2) > $a 
4
You see that it did. Now invoke another expression:
PS (3) > Invoke-Expression '$a++' 
PS (4) > $a 
5
Evaluating this expression changes the value of 
$a
to 5. 
There are no limits on what you can evaluate with 
Invoke-Expression
. It can 
take any arbitrary piece of script code. Here’s an example where you build a string 
with several statements in it and execute it:
PS (5) > $expr = '$a=10;'
PS (6) > $expr += 'while ($a--) { $a }'
B
UILDING
SCRIPT
CODE
AT
RUNTIME
437
PS (7) > $expr += '"A is now $a"'
PS (8) > [string](Invoke-Expression $expr) 
9 8 7 6 5 4 3 2 1 0 A is now -1
The first three commands in this example build a string to execute. The first line ini-
tializes the variable 
$a
, the second adds a 
while
loop that decrements and outputs 
$a
, and the third line outputs a string telling you the final value of 
$a
. Note the dou-
ble quoting in the last script fragment. Without the nested double quotes, it would 
try to execute the first word in the string instead of emitting the whole string.
11.8.2
The ExecutionContext variable
One of the predefined variables (also called automatic variables) provided by the Pow-
erShell engine is
$ExecutionContext
. This variable is another way to get at various 
facilities provided by the PowerShell engine. It’s intended to mimic the interfaces 
available to the cmdlet author. The services that matter most to us in this chapter are 
those provided through the 
InvokeCommand
member. Let’s look at the methods this 
member provides:
PS (1) > $ExecutionContext.InvokeCommand | Get-Member
TypeName: System.Management.Automation.CommandInvocationIntri 
nsics
Name           MemberType Definition 
----           ---------- ----------
Equals         Method     System.Boolean Equals(Object obj) 
ExpandString   Method     System.String ExpandString(String s... 
GetHashCode    Method     System.Int32 GetHashCode()
GetType        Method     System.Type GetType()
InvokeScript   Method     System.Collections.ObjectModel.Coll... 
NewScriptBlock Method     System.Management.Automation.Script... 
ToString       Method     System.String ToString()
The interesting methods in this list are 
ExpandString()
InvokeScript()
, and 
NewScriptBlock()
. These methods are covered in the next few sections.
11.8.3
The ExpandString() method
The 
ExpandString()
method lets you perform the same kind of variable interpola-
tion that the PowerShell runtime does in scripts. Here’s an example. First, set 
$a
to a 
known quantity:
PS (2) > $a = 13
Next, create a variable 
$str
that will display the value of 
$a
:
PS (3) > $str='a is $a'
Because the variable was assigned using single quotes, no string expansion took place. 
You can verify this by displaying the string:
PS (4) > $str 
a is $a
438
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Now call the 
ExpandString()
method, passing in 
$str
:
PS (5) > $ExecutionContext.InvokeCommand.ExpandString($str) 
a is 13
It returns the string with the variable expanded into its value.
11.8.4
The InvokeScript() method
The next method to look at is 
InvokeScript()
. This method does the same thing 
that the 
Invoke-Expression
cmdlet does (in fact, the cmdlet just calls the method). 
It takes its argument and evaluates it like a script. Call this method passing in the 
string “2+2”
PS (7) > $ExecutionContext.InvokeCommand.InvokeScript("2+2") 
4
and it will return 4. 
11.8.5
Mechanisms for creating scriptblocks
The final method is the 
NewScriptBlock()
method. Like 
InvokeScript()
, this 
method takes a string, but instead of executing it, it returns a scriptblock object that 
represents the compiled script. Let’s use this method to turn the string 
'1..4  | 
foreach {$_ * 2}'
into a scriptblock:
PS (8) > $sb = $ExecutionContext.InvokeCommand.NewScriptBlock( 
>> '1..4 | foreach {$_ * 2}') 
>>
You saved this scriptblock into a variable, so let’s look at it. Because the 
ToString() 
on a scriptblock is the code of the scriptblock, you just see the code that makes up the 
body of the scriptblock:
PS (9) > $sb
1..4 | foreach {$_ * 2}
Now execute the scriptblock using the 
&
call operator:
PS (10) > & $sb 
8
The scriptblock executed, printing out the even numbers from 2 to 8.
PowerShell v2 introduced a simpler way of doing this by using a static method on 
the 
ScriptBlock
class. Here’s how to use this static factory class:
PS (11) > $sb = [scriptblock]::Create('1..4 | foreach {$_ * 2}') 
PS (12) > & $sb 
6
B
UILDING
SCRIPT
CODE
AT
RUNTIME
439
8
PS (13) >
Using the 
[scriptblock]
type accelerator, the newer mechanism is significantly 
simpler than the rather long expression in the earlier example.
NOTE
Many people have asked why we (the PowerShell team) don’t 
allow you to cast a string to a scriptblock. The reason is that we want to 
make the system resilient against code injection attacks. We want to 
minimize the number of places where executable code can be injected 
into  the  system,  and  we  particularly  want  code  creation  to  be  an 
explicit act. Casts are more easily hidden, leading to accidental code 
injections, especially when the system may prompt for a string. We 
don’t want those user-provided strings to be converted into code with-
out some kind of check. See chapter 18 for more extensive discussions 
about security.
11.8.6
Creating functions using the function: drive
The final way to create a scriptblock is a side effect of creating elements in the func-
tion: drive. Earlier you saw that it’s possible to create a named function by assigning a 
scriptblock to a name in the function: drive:
PS (1) > $function:foo = {"Hello there"} 
PS (2) > foo 
Hello there
You could also use the 
Set-Item
or 
New-Item
cmdlet to do this. For example:
PS (3) > New-Item function:foo -value {"Hi!"} 
New-Item : The item at path 'foo' already exists. 
At line:1 char:9 
+ New-Item  <<<< function:foo -value {"Hi!"}
You received an error because the function already exists, so use the 
-Force
parame-
ter to overwrite the existing definition:
PS (4) > New-Item function:foo -value {"Hi!"} -Force
CommandType     Name                     Definition 
-----------     ----                     ----------
Function        foo                      "Hi!"
New-Item
returns the item created, so you can see that the function has been 
changed. But that’s using scriptblocks. What happens if you pass in strings? The 
interpreter will compile these strings into scriptblocks and then assign the scriptblock 
to the name. Here’s an example where the body of the function is determined by the 
expanded string:
PS (5) > $x=5
PS (6) > $y=6 
PS (7) > $function:foo = "$x*$y"
Documents you may be interested
Documents you may be interested