c# pdf viewer free : Rearrange pages in pdf document control SDK system web page wpf azure console Windows%20Powershell%20in%20Action%202nd%20Edition45-part1500

420
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
In this list of members, you can see that there are methods that correspond to the 
clauses in a function: 
Begin()
Process()
, and 
End()
. These do what you’d expect: 
Begin()
runs all the 
begin
clauses in all of the commands in the pipeline, 
Pro-
cess()
runs all the 
process
clauses, and 
End()
runs all the 
end
clauses. Let’s try 
running this pipeline. When you call 
Begin()
you have to pass a Boolean value tell-
ing the runtime whether to expect input. If there’s no input, the pipeline will run to 
completion in a single step. You do want to pass input objects to the pipeline, so call 
Begin()
with 
$true
:
PS (4) > $sp.Begin($true)
You need to get some data objects to pass through the pipeline—you’ll get a list of 
DLL
s in the PowerShell install directory:
PS (5) > $dlls = dir $pshome -Filter *.dll
Now loop through this list, passing each element to the steppable pipeline:
PS (6) > foreach ($dll in $dlls) { $sp.Process($dll) }
Name                                                 Length 
----                                                 ------
CompiledComposition.Micros...                        126976 
PSEvents.dll                                          20480 
pspluginwkr.dll                                      173056 
pwrshmsg.dll                                           2048 
pwrshsip.dll                                          28672
And you see that each element is processed through the pipeline. Finally, call the 
End()
and 
Dispose()
methods to clean up the pipeline:
PS (7) > $sp.End()
PS (8) > $sp.Dispose() 
PS (9) >
What happens if you don’t call them? If you don’t call 
End()
, you may not get all of the 
output from the pipeline. For example, if you’re stepping a pipeline containing the 
sort
cmdlet, it doesn’t return its output until the 
end
clause. And if you don’t call 
Dis-
pose()
, then any resources held by cmdlets in the pipeline may not be cleaned up in 
a timely manner (for example, files may not be closed or other resources not released).
Now that you have an idea of how steppable pipelines work, let’s look at how you 
can use them.
11.5.2
Creating a proxy command with steppable pipelines
In chapter 2, we discussed how the result of all of the things we type at the command 
line are streamed through 
Out-Default
to display them on the screen. 
Out-Default 
uses steppable pipelines to run the formatter cmdlets to do its rendering and then calls 
Out-Host
to display the formatted output. Let’s see how you can add a frequently 
requested feature to the interactive experience using a proxy for 
Out-Default
.
Rearrange 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
change page order in pdf reader; how to reorder pages in pdf file
Rearrange 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
how to rearrange pdf pages reader; reorder pages in pdf reader
S
TEPPABLE
PIPELINES
421
A commonly requested feature for interactive use is to capture the result of the last 
output object so it can be made available to the next pipeline. First, you enter a com-
mand that displays a result:
PS (1) > 2+2 
4
You want to use that result in the next command you type, so it should be available in 
a variable called 
$last
. This would let you do subsequent calculations like this:
PS (2) > $last+3 
PS (3) > $last*7 
49
This would be a nice feature, but it didn’t make it into the product. Fortunately, with 
steppable pipelines and proxy functions, you can add this feature yourself. The trick 
is to wrap the 
Out-Default
cmdlet in a proxy function. As mentioned in section
11.1.3, because functions are resolved before cmdlets, when the PowerShell host calls 
Out-Default
to display output, it will call your function first. Now you could sim-
ply collect all of the output from the command the user typed and display it all at 
once, but that doesn’t provide a good experience. Instead you’ll create a steppable 
pipeline that runs the 
Out-Default
cmdlet inside the 
Out-Default
function. Every 
time the function receives an object, this object will be passed to the steppable pipe-
line to be rendered immediately. In the process of passing this object along, you can 
also assign it to the global 
$LAST
variable. The function to do all of this is shown in 
the following listing.
function Out-Default 
{
[CmdletBinding(ConfirmImpact="Medium")]
param(
[Parameter(ValueFromPipeline=$true)] `
[System.Management.Automation.PSObject] $InputObject
)
begin
{
$wrappedCmdlet = $ExecutionContext.InvokeCommand.GetCmdlet(
"Out-Default")
$sb = { & $wrappedCmdlet @PSBoundParameters }
$__sp = $sb.GetSteppablePipeline() 
$__sp.Begin($pscmdlet)
}
process
{
$do_process = $true
if ($_ -is [System.Management.Automation.ErrorRecord])
{
Listing 11.1    Wrapper for the Out-Default cmdlet
Create steppable 
pipeline wrapping 
Out-Default
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.
how to move pages in pdf; how to move pages around in pdf
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page directly. Moreover, when you get a PDF document which is out of order, you need to rearrange the PDF document pages. In these
pdf reorder pages online; how to change page order in pdf document
422
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
if ($_.Exception -is      
[System.Management.Automation.CommandNotFoundException])
{
$__command = $_.Exception.CommandName
if (Test-Path -Path $__command -PathType container)
{
Set-Location $__command 
$do_process = $false
}
elseif ($__command -match
'^http://|\.(com|org|net|edu)$')
{
if ($matches[0] -ne "http://")
{
$__command = "HTTP://" + $__command
}
[System.Diagnostics.Process]::Start($__command)
$do_process = $false
}
}
}
if ($do_process)             
{
$global:LAST = $_;
$__sp.Process($_)
}
}
end
{
$__sp.End()
}
There are a couple of things to notice in this listing. First, when you start the steppa-
ble pipeline, rather than passing in a Boolean, you pass in the 
$PSCmdlet
object (see 
chapter 8) for the function. This allows the steppable pipeline to write directly into 
the function’s output and error streams so the function doesn’t have to deal with any 
output from the pipeline. The next thing to notice is that this function does a couple 
of other useful things besides capturing the last output object. If the last command 
typed resulted in a “command not found” exception, then you check to see if the 
command was actually a path to a directory. If so, you set the current location to that 
directory. This allows you to type
c:\mydir\mysubdir
instead of 
cd c:\mydir\mysubdir
The other thing you check is to see if the command looks like a 
URL
. If it does, then 
try to open it in the browser. This lets you open a web page simply by typing the 
URL
. Both of these are minor conveniences, but along with the 
$LAST
variable, they
Check for 
command-not-
found exceptions
If directory, cd there; 
if URL, open browser
Capture last 
output object
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
do if you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed & profession imaging controls, PDF document, image to
how to change page order in pdf acrobat; how to move pages within a pdf
C# PowerPoint - How to Process PowerPoint
It enables you to move out useless PowerPoint document pages simply with a few a very easy PPT slide dealing solution to sort and rearrange PowerPoint slides
pdf page order reverse; pdf move pages
CLOSER
LOOK
AT
THE
TYPE
-
SYSTEM
PLUMBING
423
make interactive use of PowerShell a more pleasant experience. This example should 
give you a sense of the flexibility that steppable pipelines provide. 
We began this chapter with scriptblocks, moved from there to synthetic objects, 
then on to dynamic modules and closures, and finally to steppable pipelines. Now 
we’re going to circle back to the type system and look at it in a bit more detail. We’ve 
covered the “nice” ways to add members to objects and build synthetic objects, so 
let’s dig into the actual plumbing of the PowerShell type system. In the next section, 
we’ll look at what’s happening under the covers.
11.6
CLOSER
LOOK
AT
THE
TYPE
-
SYSTEM
PLUMBING
Earlier in this chapter, we said that the core of the PowerShell type system was the 
PSObject
type. This type is used to wrap other objects, providing adaptation and 
inspection capabilities as well as a place to attach synthetic members. You’ve used 
Get-Member
to explore objects and the 
Add-Member
New-Object
, and 
Select-
Object
cmdlets to extend and create objects. In fact, you can do all of this directly by 
using the 
PSObject
class itself. There’s one thing you can’t do without understanding 
PSObject
: wrapping or shadowing an existing property. In this technique, the syn-
thetic property calls the base property that it’s hiding. (Don’t worry; this is less eso-
teric than it sounds. A simple example will clarify what we’re talking about here.)
NOTE
If you’ve done much object-oriented programming, this con-
cept is similar to creating an override to a virtual method that calls the 
overridden method on the base class. The difference here is that it’s all 
instance based; no new type is involved. 
Let’s look at 
PSObject
in more detail. First, let’s examine the properties on this object:
PS (1) > [psobject].getproperties() | %{$_.name} 
Members 
Properties 
Methods 
ImmediateBaseObject 
BaseObject 
TypeNames
From the list, you see some obvious candidates of interest. But how do you get at 
these members, given that the whole point of 
PSObject
is to be invisible? The answer 
is that there’s a special property attached to all objects in PowerShell called (surprise) 
PSObject
. Let’s look at this. First, you need a test object to work on. Use 
Get-Item 
to retrieve the 
DirectoryInfo
object for the 
C
: drive:
PS (2) > $f = Get-Item c:\ 
PS (3) > $f
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         5/29/2006   3:11 PM            C:\
Online Merge PDF files. Best free online merge PDF tool.
By dragging your pages in the editor area you can rearrange them or delete single pages. We try to make it as easy as possible to merge your PDF files.
rearrange pages in pdf online; how to reverse pages in pdf
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages extracting single or multiple Word pages at one & profession imaging controls, PDF document, image to
pdf reorder pages; pdf change page order
424
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
Now let’s look at the 
PSObject
member attached to this object:
PS (4) > $f.psobject
Members             : {PSPath, PSParentPath, PSChildName, PSDriv
e...}
Properties          : {PSPath, PSParentPath, PSChildName, PSDriv
e...}
Methods             : {get_Name, get_Parent, CreateSubdirectory,
Create...}
ImmediateBaseObject : C:\
BaseObject          : C:\
TypeNames           : {System.IO.DirectoryInfo, System.IO.FileSy
stemInfo, System.MarshalByRefObject, Syste
m.Object}
Right away you see a wealth of information: all the properties you saw on the 
PSOb-
ject
type, populated with all kinds of interesting data. First, let’s look at the 
Type-
Names
member:
PS (6) > $f.psobject.typenames 
System.IO.DirectoryInfo 
System.IO.FileSystemInfo 
System.MarshalByRefObject 
System.Object
This member contains the names of all the types in the inheritance hierarchy for a 
DirectoryInfo
object. (These types are all documented in the .
NET
class library 
documentation that’s part of the Microsoft Developer Network [
MSDN
] collection. 
See http://msdn.microsoft.com for more information.)
We’ll look at the 
Properties
member next. This collection contains all the prop-
erties defined by this type. Let’s get information about all the properties that contain 
the pattern “name”:
PS (7) > $f.psobject.properties | where {$_.name -match "name"}
MemberType      : NoteProperty 
IsSettable      : True 
IsGettable      : True 
Value           : C:\ 
TypeNameOfValue : System.String 
Name            : PSChildName 
IsInstance      : True
MemberType      : Property 
Value           : C:\ 
IsSettable      : False 
IsGettable      : True 
TypeNameOfValue : System.String 
Name            : Name 
IsInstance      : True
MemberType      : Property 
Value           : C:\
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
change page order in pdf reader; rearrange pdf pages online
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image to
how to move pages in a pdf file; move pages in a pdf file
CLOSER
LOOK
AT
THE
TYPE
-
SYSTEM
PLUMBING
425
IsSettable      : False 
IsGettable      : True 
TypeNameOfValue : System.String 
Name            : FullName 
IsInstance      : True
This returned information on three properties, one 
NoteProperty
PSPath
and two 
base object properties, 
Name
and 
FullName
. You’ve seen these properties before; this 
is the same information that would be returned from 
Get-Member
. This is exactly 
what 
Get-Member
does—it uses the 
PSObject
properties to get this information.
11.6.1
Adding a property
Now let’s add a new member to this object. You could use 
Add-Member
(and typically 
you would), but we’re talking about the plumbing here, so we’ll do it the hard way. 
First, you need to create the 
NoteProperty
object that you want to add. Do this 
with the 
New-Object
cmdlet:
PS (8) > $np = New-Object  ` 
>> System.Management.Automation.PSNoteProperty ` 
>> hi,"Hello there" 
>>
Next, add it to the member collection:
PS (9) > $f.PSObject.Members.add($np)
And you’re finished (so it wasn’t really that hard after all). The 
hi
member has been 
added to this object, so try it out:
PS (10) > $f.hi 
Hello there
All of the normal members are still there:
PS (11) > $f.name 
C:\
Now look at the member in the member collection:
PS (12) > $f.PSObject.Members | where {$_.name -match "^hi"}
MemberType      : NoteProperty 
IsSettable      : True 
IsGettable      : True 
Value           : Hello there 
TypeNameOfValue : System.String 
Name            : hi 
IsInstance      : True
Notice the 
Value
member on the object. Because you can get at the member, you can 
also set the member
PS (13) > ($f.PSObject.Members | where { 
>> $_.name -match "^hi"}).value = "Goodbye!"
426
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
>>
PS (14) > $f.hi 
Goodbye!
which is equivalent to setting the property directly on 
$f
:
PS (15) > $f.hi = "Hello again!"
PS (16) > $f.PSObject.Members | where {$_.name -match "^hi"}
MemberType      : NoteProperty 
IsSettable      : True 
IsGettable      : True 
Value           : Hello again! 
TypeNameOfValue : System.String 
Name            : hi 
IsInstance      : True
The 
Value
member on the note property is “Hello again!”
In section 11.4.3 you saw a different type of note property used when construct-
ing objects out of modules. This type of note property is backed by a variable. You 
can also create an instance of this type of property. But first you need a variable to use 
to back the property value:
PS (15) > [int] $VariableProperty = 0
Now create the 
PSVariableProperty
object, passing in the variable to bind:
PS (16) > $vp = New-Object ` 
>>     System.Management.Automation.PSVariableProperty ` 
>>     (Get-Variable VariableProperty) 
>>
Note that the name of the property and the name of the variable will be the same. 
Add the property
PS (17) > $f.psobject.members.add($vp)
and verify that it can be read and written:
PS (18) > $f.VariableProperty 
PS (19) > $f.VariableProperty = 7 
PS (20) > $f.VariableProperty 
7
So you can read and write integers, but the backing variable was constrained to be an 
integer. Let’s verify that the constraint was preserved by trying to assign a string to it:
PS (21) > $f.VariableProperty = "Hi"
Cannot convert value "Hi" to type "System.Int32". Error: "Input 
string was not in a correct format."
At line:1 char:4 
+ $f. <<<< VariableProperty = "Hi"
+ CategoryInfo          : InvalidOperation: (:) [], Runtime
Exception
+ FullyQualifiedErrorId : PropertyAssignmentException
CLOSER
LOOK
AT
THE
TYPE
-
SYSTEM
PLUMBING
427
You get the error just like you saw in section 11.4.3 when you exported a constrained 
variable from a module as a property.
11.6.2
Shadowing an existing property
There’s one last item to cover in our discussion of the plumbing: the mechanism that 
allows you to bypass the adapted members and lets you get at the raw object under-
neath. This is accomplished through another special member on 
PSObject
called 
PSBase
. This member allows you to get at the object directly, bypassing all the syn-
thetic member lookup. It also makes it possible to create a synthetic member to adapt 
an existing member. We can clarify this with an example. Say you want to change the 
name
property on a 
DirectoryInfo
object to always return the name in uppercase. 
Here’s what it looks like unadapted:
PS (18) > $f = Get-Item c:\windows 
PS (19) > $f.name 
windows
To do this, create a new 
PSProperty
object called 
Name
that will “shadow” the exist-
ing property:
PS (20) > $n=New-Object Management.Automation.PSScriptProperty ` 
>>     name,{$this.psbase.name.ToUpper()} 
>>
In the body of the scriptblock for this 
PSProperty
, you’ll use 
$this.psbase
to get 
at the 
name
property on the base object (if you just accessed the 
name
property 
directly, you’d be calling yourself). You apply the 
ToUpper()
method on the string 
returned by name to acquire the desired result. Now add the member to the object’s 
member collection
PS (21) > $f.psobject.members.add($n)
and try it out: 
PS (22) > $f.name 
WINDOWS
When you access the 
name
property on this object, the synthetic member you created 
gets called instead of the base member, so the name is returned in uppercase. The 
base object’s 
name
property is unchanged and can be retrieved through 
psbase.name
:
PS (23) > $f.psbase.name 
windows 
PS (24) >
Although this isn’t a technique that you’ll typically use on a regular basis, it allows you 
to do some pretty sophisticated work. You could use it to add validation logic, for 
example, and prevent a property from being set to an undesired value. You could also 
use it to log accesses to a property to gather information about how your script or 
application is being used.
428
CHAPTER 11
M
ETAPROGRAMMING
WITH
SCRIPTBLOCKS
AND
DYNAMIC
CODE
With  a solid  understanding  of the  plumbing,  you’re  ready  to  use  everything 
you’ve learned and do some applied metaprogramming. In the next section, you’ll 
learn how to write a domain-specific extension to PowerShell.
11.7
E
XTENDING
THE
P
OWER
S
HELL
LANGUAGE
In the previous section, you learned how to add members to existing objects one at a 
time, but sometimes you’ll want to construct new types rather than extend the exist-
ing types. In this section, we’ll explain how to do that and also how to use scripting 
techniques to “add” the ability to create objects to the PowerShell language.
11.7.1
Little languages
The idea of little languages—small, domain-specific languages—has been around for a 
long time. This was one of the powerful ideas that made the 
UNIX
environment so 
attractive. Many of the tools that were the roots for today’s dynamic languages came 
from this environment.
In effect, all programs are essentially an exercise in building their own languages. 
You create the nouns (objects) and verbs (methods or functions) in this language. 
These patterns are true for all languages that support data abstraction. Dynamic lan-
guages go further because they allow you to extend how the nouns, verbs, and modi-
fiers are composed in the language. For example, in a language such as 
C
#, it’d be 
difficult to add a new looping construct. In PowerShell, this is minor. To illustrate 
how easy it is, let’s define a new looping keyword called loop. This construct will 
repeat the body of the loop for the number of times the first argument specifies. You 
can add this keyword by defining a function that takes a number and scriptblock. 
Here’s the definition:
PS (1) > function loop ([int] $i, [scriptblock] $b) { 
>> while ($i-- -gt 0) { . $b } 
>> } 
>>
Try it out:
PS (2) > loop 3 { "Hello world" } 
Hello world 
Hello world 
Hello world 
PS (3) >
In a few lines of code, you’ve added a new flow-control statement to the PowerShell 
language that looks pretty much like any of the existing flow-control statements.
You can apply this technique to creating language elements that allow you to 
define your own custom types. Let’s add some “class” to PowerShell!
11.7.2
Adding a CustomClass keyword to PowerShell
Next you’ll use the technique from the previous section to extend the PowerShell 
language  to  allow  you to  define your  own  custom  classes.  First,  let’s  gather  the
E
XTENDING
THE
P
OWER
S
HELL
LANGUAGE
429
requirements. You want the syntax for defining a class to look fairly natural (at least 
for PowerShell). Here’s what you want a class definition to look like:
CustomClass point {
note x 0
note y 0
method ToString { "($($this.x), $($this.y))"}
method scale {
$this.x *= $args[0]
$this.y *= $args[0]
}
Once you’ve defined this custom class, you want to be able to use it as follows. First, 
create a new instance of the 
point
class:
$p = new point
NOTE
The 
new
command here is not an alias for the 
New-Object 
cmdlet. The cmdlet creates new instances of .
NET
or 
COM
objects. It 
doesn’t know anything about the “classes” we’re defining here. Instead, 
it’s a custom function that we’ll get to in a minute.
Then, set the 
x
and 
y
members on this instance to particular values:
$p.x=2 
$p.y=3
Finally, call the 
ToString()
method to display the class:
$p.ToString()
This will give you a natural way to define a class in PowerShell. Now let’s look at 
implementing these requirements.
NOTE
In section 11.4.3 you saw how you could do this with dynamic 
modules. The focus here is to see how you can directly implement this 
type  of  facility.  In  practical  circumstances,  this  dynamic  module 
approach is certainly easier.
We’ll put the code for this script in a file called class.ps1. Let’s go over the contents of 
that script a piece at a time. (The complete script is included in the book’s source 
code.)
First, you need a place to store the types you’re defining. You need to use a global 
variable for this, because you want it to persist for the duration of the session. Give it 
a name that’s unlikely to collide with other variables (you’ll put two underscores at 
each end to help ensure this) and initialize it to an empty hashtable:
$global:__ClassTable__ = @{}
Next, define the function needed to create an instance of one of the classes you’ll cre-
ate.  This  function  will  take  only  one  argument:  the  scriptblock  that  creates  an
Documents you may be interested
Documents you may be interested