c# pdf viewer free : Move pages in pdf document Library control class asp.net web page winforms ajax Windows%20Powershell%20in%20Action%202nd%20Edition44-part1499

410
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
the base for all pure synthetic objects. Because the properties you added are note prop-
erties, you can change their values:
PS (4) > $obj.a = 5 
PS (5) > $obj | Format-Table -auto 
a b c 
- - -
5 2 3
But if you try to assign to a nonexistent property
PS (6) > $obj.d = 10 
Property 'd' cannot be found on this object; make sure it exists
and is settable. 
At line:1 char:6 
+ $obj. <<<< d = 10
+ CategoryInfo          : InvalidOperation: (:) [], Runtime
Exception
+ FullyQualifiedErrorId : PropertyAssignmentException
you get an error. This can help catch runtime bugs in your code and is one reason to 
favor synthetic objects over hashtables.
All 
New-Object -Property
is doing is creating and attaching note properties in 
the cmdlet instead of requiring the user do it one at a time. There’s another way to do 
this that’s available in both v1 and v2 of PowerShell: the 
Select-Object
cmdlet. 
Let’s look at how this cmdlet lets you build custom objects.
11.3
U
SING
THE
S
ELECT
-O
BJECT
CMDLET
Now that you know how to attach members using 
Add-Member
and 
New-Object
let’s explore some other ways to build synthetic objects. The 
Select-Object
cmdlet, 
which is used to select a subset of properties on an object, creates a synthetic object to 
hold these properties.
The 
Select-Object
cmdlet is also a way to select elements from a stream of 
objects. You can select a range of objects:
PS (1) > 1..10 | Select-Object -First 3 
3
Here you’ve selected the first three elements. But, much more interesting for this dis-
cussion, it’s a way to select fields from an object:
PS (1) > dir | Select-Object name,length
Name                                                      Length 
----                                                      ------
a.txt                                                         98
b.txt                                                         42
c.txt                                                        102
d.txt                                                         66
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
reorder pages in pdf document; how to move pages in pdf reader
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 pdf pages in preview; reverse page order pdf
U
SING
THE
S
ELECT
-O
BJECT
CMDLET
411
At first this looks a lot like 
Format-Table
. Let’s use 
Get-Member
to see how different 
it is:
PS (2) > dir | Select-Object name,length | 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()
ToString    Method       System.String ToString()
Length      NoteProperty System.Int64 Length=98 
Name        NoteProperty System.String Name=a.txt
As was the case with the objects returned from 
New-Object -Property
, the type of 
the object is 
System.Management.Automation.PSCustomObject
. As mentioned in 
the previous section, this is a PowerShell-specific type that’s used as the base for pure 
synthetic objects. An object whose base is 
PSCustomObject
has only synthetic mem-
bers and is therefore called a synthetic object.
Even though it’s a synthetic object, it’s still a “first-class” citizen in the PowerShell 
environment. You can sort these objects
PS (3) > dir | Select-Object Name,Length | sort Length
Name                                                      Length 
----                                                      ------
b.txt                                                         42
d.txt                                                         66
a.txt                                                         98
c.txt                                                        102
or do anything else that you can do with a regular object. 
But there’s more to using 
Select-Object
than simply selecting from the existing 
set of members. For example, say you want to add a new field “minute” to these 
objects. This will be a calculated field as follows:
PS (9) > dir | foreach {$_.LastWriteTime.Minute} 
51 
56 
54
In other words, it will be the minute at which the file was last written. You attach this 
field by passing a specially constructed hashtable describing the member to 
Select-
Object
. This hashtable has to have two members: name and expression (which can 
be shortened to “n” and “e” for brevity). The name is the name to call the property, 
and the expression is the scriptblock used to calculate the value of the field. The defi-
nition will look like this:
@{Name="minute";Expression={$_.LastWriteTime.Minute}}
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 acrobat; change page order pdf preview
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.
pdf reorder pages online; how to reverse page order in pdf
412
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Let’s use it in the pipeline:
PS (11) > dir | Select-Object Name,Length, 
>>  @{Name="Minute";Expression={$_.LastWriteTime.Minute}} 
>>
Name                                 Length               minute 
----                                 ------               ------
a.txt                                    98                   55
b.txt                                    42                   51
c.txt                                   102                   56
d.txt                                    66                   54
As intended, the result has three fields, including the synthetic 
minute
property you 
specified with the hashtable. Use 
Get-Member
to see what the object looks like:
PS (12) > dir | Select-Object  name,length, 
>>  @{n="minute";e={$_.lastwritetime.minute}} | 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()
ToString    Method       System.String ToString()
Length      NoteProperty System.Int64 Length=98 
minute      NoteProperty System.Management.Automation.PSObjec... 
Name        NoteProperty System.String Name=a.txt
You see that there are now three 
NoteProperty
members on the objects that were 
output.
For the last few sections, we’ve been focusing on individual functions (script-
blocks) and object members. Let’s switch gears a bit and look at how modules fit into 
all of this. In chapters 9 and 10, we talked only about modules that that were loaded 
from disk, but there’s also a way to create modules dynamically.
11.4
D
YNAMIC
MODULES
Dynamic modules are modules created  in  memory at runtime rather than being 
loaded from disk. Dynamic modules relate to regular modules in much the same way 
as functions are related to scripts. In this section, we’ll cover how to use dynamic 
modules  to  encapsulate  local  state  in  scripts,  how  they’re  used  to  implement  a 
dynamic equivalent of the closure feature found in other languages, and finally, how 
they can be used to simplify the way you create custom objects.
11.4.1
Dynamic script modules
Just as there were two types of on-disk modules—script modules and binary modules 
(we can ignore manifest modules for this discussion)—there are also two types of
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.
how to move pages within a pdf document; reorder pages pdf
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.
how to change page order in pdf document; pdf reverse page order online
D
YNAMIC
MODULES
413
dynamic modules. The first type is the dynamic script module. Let’s create one and 
see what’s involved.
To create a dynamic module, use the 
New-Module
cmdlet. This cmdlet takes a 
scriptblock as an argument. This scriptblock is executed to define the modules con-
tents. Here’s what it looks like:
PS (1) > $dm = New-Module { 
>>     $c=0 
>>     function Get-NextCount 
>>         { $script:c++; $script:c }} 
>>
Other than how they’re created, the content of the module looks pretty much like the 
on-disk modules you created in chapter 9. This is by design and means that all of the 
concepts you learned for on-disk modules also apply to dynamic modules. As we dis-
cussed in the previous chapter, if there’s no call to 
Export-ModuleMember
, all of the 
functions defined in the module are exported and the other types of module members 
aren’t. Verify this by calling the function you defined
PS (2) > Get-NextCount 
PS (3) > Get-NextCount 
2
which works properly. And, because it wasn’t exported, there’s no variable 
$c
:
PS (4) > $c
(Or at least not one related to this dynamic module.) Now try to use 
Get-Module
to 
look at the module information
PS (5) > Get-Module
and you don’t see anything. So what happened? Well, dynamic modules are objects 
like everything else in PowerShell. The 
New-Module
cmdlet has created a new mod-
ule object but hasn’t added it to the module table. This is why you assigned the out-
put of the cmdlet to a variable—so you’d have a reference to the module object. Let’s 
look at that object:
PS (6) > $dm | fl
Name              : __DynamicModule_55b674b0-9c3c-4db0-94a3-a095
a4ac984e 
Path              : 55b674b0-9c3c-4db0-94a3-a095a4ac984e 
Description       : 
ModuleType        : Script 
Version           : 0.0 
NestedModules     : {}
ExportedFunctions : Get-NextCount 
ExportedCmdlets   : {}
ExportedVariables : {}
ExportedAliases   : {}
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
change pdf page order reader; how to rearrange pages in a pdf file
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#.
reorder pdf pages online; pdf reverse page order preview
414
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
The interesting fields are the name and path fields. Because no file is associated with 
the module, you had to make up a unique “path” for that object. Likewise, you didn’t 
specify a name, so the runtime made one up for you. So why did it do these things? It 
did this because, although a dynamic module isn’t registered by default, it can be 
added to the module table by piping it to 
Import-Module
. Let’s give it a try:
PS (6) > $dm | Import-Module
Now check the module table:
PS (7) > Get-Module
ModuleType Name                      ExportedCommands 
---------- ----                      ----------------
Script     __DynamicModule_b6dea7... Get-NextCount
There it is, ugly name and all. Now you can give a dynamic module a specific name 
using the 
-Name
parameter on the 
New-Module
cmdlet. First, clean up from the last 
example
PS (1) > Get-Module | Remove-Module
and define a new dynamic module, with the same body as last time:
PS (2) > New-Module -Name Dynamic1 { 
>>     $c=0 
>>     function Get-NextCount 
>>         { $script:c++; $script:c }} | 
>>             Import-Module 
>>
Rather  than saving  the result  to  a variable, you’re  piping it  directly  to 
Import-
Module
. Now look at the result:
PS (3) > Get-Module
ModuleType Name                      ExportedCommands 
---------- ----                      ----------------
Script     Dynamic1                  Get-NextCount
This time the module is registered in the table with a much more reasonable name.
So when would you use dynamic modules? When you need to create a function or 
functions that have persistent resources that you don’t want to expose at the global 
level. This is basically the same scenario as the on-disk case, but this way you can 
package the module or modules to load into a single script file.
There’s also another way the dynamic module feature is used: to implement the 
idea of closures in PowerShell. Let’s move on and see how that works.
11.4.2
Closures in PowerShell
PowerShell uses dynamic modules to create dynamic closures. A closure in computer 
science terms (at least as defined in Wikipedia) is “a function that is evaluated in an 
environment containing one or more bound variables.” A bound variable is, for our
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.
moving pages in pdf; switch page order pdf
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
how to reorder pages in pdf online; reorder pages in pdf reader
D
YNAMIC
MODULES
415
purposes, a variable that exists and has a value. The environment in our case is the 
dynamic module. Finally, the function is just a scriptblock. In effect, a closure is the 
inverse of an object, as discussed in chapter 1. An object is data with methods (func-
tions) attached to that data. A closure is a function with data attached to that method.
The best way to understand what all this means is to look at an example. You’ll use 
closures to create a set of counter functions, similar to what you did in chapter 9. The 
advantage closures give you over plain functions is that you can change what incre-
ment to use after the counter function has been defined. Here’s the basic function:
function New-Counter ($increment=1) 
{
$count=0;
$script:count += $increment
$count
}.GetNewClosure() 
}
There’s nothing you haven’t seen so far—you create a variable and then a scriptblock 
that increments that variable—except for returning the result of the call to the 
Get-
NewClosure()
method. Let’s try this function to see what it does. First, create a counter:
PS (1) > $c1 = New-Counter 
PS (2) > $c1.GetType().FullName 
System.Management.Automation.ScriptBlock 
Looking at the type of the object returned, you see that it’s a scriptblock, so you use 
the 
&
operator to invoke it:
PS (3) > & $c1 
PS (4) > & $c1 
The scriptblock works as you’d expect a counter to work. Each invocation returns the 
next number in the sequence. Now, create a second counter, but this time set the 
increment to 2:
PS (5) > $c2 = New-Counter 2 
Invoke the second counter scriptblock:
PS (6) > & $c2 
PS (7) > & $c2 
PS (8) > & $c2 
It counts up by 2. But what about the first counter? 
PS (9) > & $c1 
3
416
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
PS (10) > & $c1 
The first counter continues to increment by 1, unaffected by the second counter. So the 
key thing to notice is that each counter instance has its own copies of the 
$count
and 
$increment
variables. When a new closure is created, a new dynamic module is cre-
ated, and then all the variables in the caller’s scope are copied into this new module.
Here are some more examples of working with closures to give you an idea of how 
flexible the mechanism is. First, you’ll create a new closure using a 
param
block to set 
the bound variable 
$x
. This is essentially the same as the previous example, except 
that you’re using a scriptblock to establish the environment for the closure instead of 
a named function
:
PS (11) > $c = & {param ($x) {$x+$x}.GetNewClosure()} 3.1415 
Now evaluate the newly created closed scriptblock:
PS (12) > & $c
6.283
This evaluation returns the value of the parameter added to itself. Because closures are 
implemented using dynamic modules, you can use the same mechanisms you saw in 
chapter 9 for manipulating a modules state to manipulate the state of a closure. You 
can do this by accessing the module object attached to the scriptblock. You’ll use this 
object to reset the module variable 
$x
by evaluating 
sv
(
Set-Variable
) in the clo-
sure’s module context:
PS (13) > & $c.Module Set-Variable x "Abc" 
Now evaluate the scriptblock to verify that it’s been changed:
PS (14) > & $c
AbcAbc
Next, create another scriptblock closed over the same module as the first one. You can 
do this by using the 
NewBoundScriptBlock()
method on the module to create a 
new scriptblock attached to the module associated with the original scriptblock:
PS (15) > $c2 = $c.Module.NewBoundScriptBlock({"x ia $x"}) 
Execute the new scriptblock to verify that it’s using the same 
$x
:
PS (16) > & $c2 
x ia Abc 
Now use 
$c2.module
to update the shared variable:
PS (17) > & $c2.module sv x 123 
PS (18) > & $c2 
x ia 123 
And verify that it’s also changed for the original closed scriptblock:
PS (19) > & $c 
246 
D
YNAMIC
MODULES
417
Finally, create a named function from the scriptblock using the function provider
PS (20) > $function:myfunc = $c
and verify that calling the function by name works:
PS (21) > myfunc 
246 
Set the closed variable yet again, but use 
$c2
to access the module this time:
PS (22) > & $c2.Module sv x 3
And verify that it’s changed when you call the named function:
PS (23) > myfunc 
6
These examples should give you an idea how all of these pieces—scriptblocks, mod-
ules, closures, and functions—are related. This is how modules work. When a mod-
ule is loaded, the exported functions are closures bound to the module object that 
was created. These closures are assigned to the names for the functions to import. A 
fairly small set of types and concepts allows you to achieve advanced programming 
scenarios.  In  the  next  section,  we’ll  go  back  to  looking  at  objects  and  see  how 
dynamic modules make it easier to create custom object instances.
11.4.3
Creating custom objects from modules
There’s one more thing you can do with dynamic modules: provide a simpler way to 
build custom objects. This is a logical step because modules have private data and 
public members just like objects. As modules, they’re intended to address a different 
type of problem than objects, but given the similarity between objects and modules, 
it would make sense to be able to construct an object from a dynamic module. This is 
done using the 
-AsCustomObject
parameter on 
New-Module
. You’ll use this mecha-
nism to create a “point” object from a module. Here’s what this looks like:
PS (1) > function New-Point 
>> { 
>>     New-Module -ArgumentList $args -AsCustomObject { 
>>         param ( 
>>             [int] $x = 0, 
>>             [int] $y = 0 
>>         ) 
>>         function ToString() 
>>         { 
>>            "($x, $y)" 
>>         } 
>>         Export-ModuleMember -Function ToString -Variable x,y 
>>     } 
>> } 
>>
418
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Now let’s try it. Begin by defining two points, 
$p1
and 
$p2
:
PS (2) > $p1 = New-Point 1 1 
PS (3) > $p2 = New-Point 2 3
You’ll use string expansion to display these objects, which will call the 
ToString() 
method you exported from the module:
PS (4) > "p1 is $p1" 
p1 is (1, 1)
PS (5) > "p2 is $p2" 
p2 is (2, 3)
Now try to assign a string to the 
X
member on one of the points:
PS (6) > $p1.X = "Hi"
Cannot convert value "Hi" to type "System.Int32". Error: "Input 
string was not in a correct format."
At line:1 char:5 
+ $p1. <<<< X = "Hi"
+ CategoryInfo          : InvalidOperation: (:) [], Runtime
Exception
+ FullyQualifiedErrorId : PropertyAssignmentException
PS (7) >
This results in an error because the exported variable is a special type of note property 
that is backed by the variable. Because it’s backed by the variable, any constraints on 
the variable also apply to the note property, allowing you to create strongly typed 
members on a synthetic object.
So far we’ve covered scriptblocks, modules, and closures in PowerShell. Although 
these features are somewhat exotic, they’re found in most modern (or modernized) 
languages, including Java, JavaScript, Visual Basic, 
C
#, Python, and so on. In the 
next section, we’re going to cover a related feature that’s unique to PowerShell: step-
pable pipelines. Normally once a pipeline starts, it runs to completion. With a steppa-
ble pipeline, you can cause the pipeline to process one object at a time (with some 
limitations.) This is a concrete form of metaprogramming, where one script has pre-
cise control over the sequence of operations in another.
11.5
S
TEPPABLE
PIPELINES
Steppable pipelines existed in PowerShell v1 but were not exposed to the end user. In 
v2 this feature was made available to the end user. The core use of this feature is to allow 
one command to wrap, or proxy, other commands. In this section, we’ll begin with a 
look at how the feature works and then explore a useful example showing its value.
11.5.1
How steppable pipelines work
The  central  concept  in  PowerShell  programs  is  the  pipeline,  which  processes  a 
sequence of objects, one at a time. In chapter 2, we illustrated this with a diagram of 
the pipeline processor. Let’s take another look (see figure 11.3).
S
TEPPABLE
PIPELINES
419
Each object is processed completely (ignoring things like sorting) before processing 
begins on the next one, but the pipeline itself has to process all objects in one go. 
There are times when it’s useful to be able to start a pipeline and then feed it objects 
as needed. This is what a steppable pipeline lets you do. You can create a pipeline, start 
it (so all the 
begin
clauses are executed), and then pass objects to it for processing one 
at a time. Let’s see how to do this.
To get a steppable pipeline object, you need to have some object representation of 
a pipeline. The obvious way to do this is with a scriptblock object, and that’s exactly 
how it works. First, create a scriptblock with exactly one pipeline in it:
PS (1) > $sb = { Select-Object name, length }
The “one pipeline” part is important—a steppable pipeline maps to a single pipeline, 
so the scriptblock used to create it must have only a single pipeline. Now get a steppa-
ble pipeline object:
PS (2) > $sp = $sb.GetSteppablePipeline()
Let’s look at the type of object you got back and see what its members are:
PS (3) > $sp | Get-Member
TypeName: System.Management.Automation.SteppablePipeline
Name        MemberType Definition 
----        ---------- ----------
Begin       Method     System.Void Begin(bool expectInpu... 
Dispose     Method     System.Void Dispose()
End         Method     array End()
Equals      Method     bool Equals(System.Object obj) 
GetHashCode Method     int GetHashCode()
GetType     Method     type GetType()
Process     Method     array Process(System.Object input... 
ToString    Method     string ToString()
Figure 11.3 Objects 
flow through a pipeline 
one at a time. A common 
parser constructs each of 
the command objects 
and then starts the pipe-
line processor, stepping 
each object through all 
stages of the pipeline.
Documents you may be interested
Documents you may be interested