c# pdf viewer itextsharp : Change pdf page order online control software system web page windows azure console Windows%20Powershell%20in%20Action%202nd%20Edition89-part1548

860
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
approved verbs list and it’s not what you want to do anyway. You registered event sub-
scriptions with 
Register-ObjectEvent
, so what you need to do is unregister the 
subscription, which you’ll do with 
Unregister-Event
. The cmdlet noun in this case 
is 
Event
, not 
ObjectEvent
, because you can use a common mechanism to unregister 
any kind of event. It’s only the registration part that varies. The rest of the eventing 
cmdlets remain the same. 
When you’re unregistering an event subscription, there are two ways of identify-
ing the event to unregister: by the 
SubscriptionId
property or by the 
Source-
Identifier
. The subscription 
ID
is simply an integer that’s incremented each time 
an event subscription is created. Because you didn’t give your event registration a 
friendly name, you’ll use the 
SubscriptionId
to unregister it:
PS (4) > Unregister-Event -SubscriptionId 1 -Verbose 
VERBOSE: Performing operation "Unsubscribe" on Target "Event 
subscription 'timertest2'".
PS (5) >
Note that you included the 
-Verbose
flag in this command so that you could see 
something happening. Let’s try running the command again
PS (5) > Unregister-Event -SubscriptionId 1 
Unregister-Event : Event subscription with identifier '1' does not 
exist.
At line:1 char:17 
+ Unregister-Event <<<<  -SubscriptionId 1
+ CategoryInfo          : InvalidArgument: (:) [Unregister-Event
], ArgumentException
+ FullyQualifiedErrorId : INVALID_SUBSCRIPTION_IDENTIFIER,
Microsoft.PowerShell.Commands.UnregisterEventCommand
and it results in an error. The 
Unregister-Event
cmdlet is silent as long as nothing 
goes wrong. If something does go wrong, you get an error.
We’ve  covered  the  basics  of  creating  and  managing  event  subscriptions.  But 
before the handlers for these events can do much useful work, they’ll need access to 
additional information. In the next section, you’ll write more sophisticated handlers 
and see how they can use the automatic variables provided by the eventing subsystem.
20.5
A
SYNCHRONOUS
EVENT
HANDLING
WITH
SCRIPTBLOCKS
In this section, we’ll look at the automatic variables and other features that Power-
Shell provides to allow scriptblocks to be used as effective event handlers. 
20.5.1
Automatic variables in the event handler
In PowerShell eventing, the scriptblock that handles the event action has access to a 
number  of  variables  that  provide  information  about  the  event  being  handled: 
$event
$eventSubscriber
$sender
$sourceEventArgs
 and 
$sourceArgs
These variables are described in table 20.2.
Change pdf page order online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
pdf page order reverse; how to reorder pdf pages in reader
Change pdf page order online - 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 pages in pdf file; reordering pdf pages
A
SYNCHRONOUS
EVENT
HANDLING
WITH
SCRIPTBLOCKS
861
Let’s write a quick test event handler to see what’s in the object in 
$Event
. You’ll use 
the timer event again:
PS (1) > $timer = New-Object System.Timers.Timer -Property @{ 
>>   Interval = 1000; Enabled = $true; AutoReset = $false } 
>>
In the event subscription action, you’ll display the contents of the event object:
PS (2) > Register-ObjectEvent $timer Elapsed -Action { 
>>     $Event | Out-Host 
>> } 
>>
Id              Name            State      HasMoreData     Locat
ion 
--              ----            -----      -----------     -----
              9e3586c3-534... NotStarted False 
You’ll start the timer to generate the event:
PS (3) > $timer.Start() 
PS (4) >
ComputerName     :
RunspaceId       : 373d0ee9-47a5-4ceb-89e5-61e6389d6838 
EventIdentifier  : 7 
Sender           : System.Timers.Timer 
SourceEventArgs  : System.Timers.ElapsedEventArgs 
SourceArgs       : {System.Timers.Timer, System.Timers.ElapsedEv
entArgs}
SourceIdentifier : 9e3586c3-534b-465a-84b3-7404110a0f12
Table 20.2 The automatic variables available in the event handler scriptblock
Variable
Description
$event
This variable contains an object of type System.Management.Auto-
mation.PSEventArgs that represents the event that’s being handled. It 
allows you to access a wide variety of information about the event, as 
you’ll see in an example. The value of this variable is the same object that 
the Get-Event cmdlet returns.
$eventSubscriber
This variable contains the PSEventSubscriber object that represents 
the event subscriber of the event that’s being handled. The value of this 
variable is the same object that the Get-EventSubscriber cmdlet 
returns.
$sender
The value in this variable is the object that generated the event. This vari-
able is a shortcut for $EventArgs.Sender.
$sourceEventArgs
Contains objects that represent the arguments of the event that’s being 
processed. This variable is a shortcut for $Event.SourceArgs.
$sourceArgs
Contains the values from $Event.SourceArgs. Like any other script-
block, if there is a param statement, the parameters defined by that 
statement will be populated and $args will only contain leftover values 
for which there were no parameters.
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# File: Split PDF; C# Page: Insert PDF pages
how to move pages in pdf acrobat; change pdf page order preview
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page from PDF file and changing the position, orientation and order of PDF file into two or small files, you may refer to this online guide. PDF Page inserting.
rearrange pages in pdf reader; reorder pages pdf file
862
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
TimeGenerated    : 8/10/2010 12:17:40 PM 
MessageData      :
In this output, you see the properties on the 
PSEvent
object that correspond to the 
variables listed in table 20.2. The 
Timer
object that generated the event is available 
through the 
Sender
property on the object and the 
$sender
variable in the script-
block. The 
PSEvent
object also includes context data about the event, including the 
time the event occurred, the event identifier, and the 
RunspaceId
this event is associ-
ated with. (Runspaces were discussed briefly in section 15.2.1.) The 
ComputerName 
property is blank because this is a local event; but in the case of a remote event, it 
would contain the name of the computer where the event occurred. (Section 20.9 
covers remote events.)
20.5.2
Dynamic modules and event handler state
Because an event can fire at any time, you could never know what variables were in 
scope and this, in turn, could make it hard to know what state will exist when the 
action is executed. Instead, you want to be able to run the event handlers in a well-
defined, isolated environment. This objective aligns with the design goals for Power-
Shell modules, so you can leverage this feature by creating a dynamic module (section
11.4) for the action scriptblock. The eventing subsystem does this by calling the 
New-
BoundScriptBlockScriptblock()
method to attach a dynamic module to the 
handler scriptblock (section 11.4.2).
Beyond ensuring a coherent runtime environment for your event handler script-
block, the module also allows it to have private state. This ability can be quite useful 
when you’re monitoring a system’s behavior over a period of time. The information 
can be accumulated privately and then processed once enough samples have been 
gathered. Let’s look at an example that illustrates how this state isolation works. The 
following is a trivial example where you maintain a count of the number of timer 
events fired. Once you reach a predetermined limit, the timer will be stopped. Let’s 
walk through the example. First, you create the 
Timer
object:
PS (1) > $timer = New-Object System.Timers.Timer -Property @{ 
>>   Interval = 500; AutoReset = $true} 
>>
As usual, subscribe to the 
Elapsed
event on the timer:
PS (2) > Register-ObjectEvent -InputObject $timer ` 
>>    -MessageData 5 ` 
>>   -SourceIdentifier Stateful -EventName Elapsed -Action { 
>>     $script:counter += 1 
>>     Write-Host "Event counter is $counter" 
>>     if ($counter -ge $Event.MessageData) 
>>     { 
>>        Write-Host "Stopping timer" 
>>        $timer.Stop() 
>>     } 
>>   } > $null 
>> 
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
move pages in a pdf file; change page order pdf preview
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
move pages within pdf; how to move pdf pages around
Q
UEUED
EVENTS
AND
THE
W
AIT
-E
VENT
CMDLET
863
In the handler scriptblock for this event, you’re updating a script-scoped variable 
$script:counter
, which holds the number of times the event has fired. This variable 
will only be visible within the dynamic module associated with the event, thus prevent-
ing your 
$counter
from colliding with any other users of a variable called 
$counter
After the variable is incremented, you print the event count and then check to see if the 
limit has been reached. Notice that you’re making use of the 
-MessageData
parameter 
to pass the limit to the event handler, which it retrieves from the 
MessageData
prop-
erty on the 
Event
object. Now start the timer running to see it in action:
PS (3) > $timer.Start()
PS (4) >
PS (5) > Event counter is 1 
Event counter is 2 
Event counter is 3 
Event counter is 4 
Event counter is 5 
Stopping timer
PS (6) >
As intended, the timer message is displayed five times and then the timer is stopped. 
This example can easily be modified to, for example, monitor 
CPU
usage or process 
working sets over a period of time.
Setting up action scriptblocks for asynchronous events allows you to efficiently 
handle events in the background. This, in turn, lets the main thread of your script 
continue execution in the foreground or, in interactive sessions, allows you to con-
tinue entering commands at the shell prompt. There are, however, many monitor-
ing scenarios where there’s no main thread and all you want to do is wait for events 
to happen. For example, if a service process crashes or faults, you want to be noti-
fied so you can take action to restart it. Otherwise, you simply wait for the next 
event to arrive. This “wait for an event” pattern is addressed using the 
Wait-Event 
cmdlet.
20.6
Q
UEUED
EVENTS
AND
THE
W
AIT
-E
VENT
CMDLET
As an alternative to setting up a lot of individual event handler actions, you can use 
the 
Wait-Event
cmdlet to process events in a loop. This cmdlet allows you to block, 
waiting until an event or events happen. When the event arrives, you can take what-
ever action is required, then loop and wait for the next event. This event loop pattern 
is very common, especially in 
GUI
programming. The syntax for the 
Wait-Event 
command is simple:
Wait-Event [[-SourceIdentifier] <string>] [-Timeout <int>]
By using  the 
-SourceIdentifier
parameter you can wait for a specific named 
event. If you don’t use it, then any unhandled event will unblock you. By using the 
-Timeout
parameter, you can limit the length of time you'll wait for the event. This
C# Word - Process Word Document in C#
For example, you may change your Word document order from 1, 2, 3, 4, 5 to 3, 5, 4, 2,1 with C# coding. C#.NET: Extracting Page(s) from Word.
how to rearrange pdf pages reader; change page order in pdf file
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
Enable C#.NET developers to change the page order of source PDF document file; Allow C#.NET developers to add image to specified area of source PDF
reorder pages in pdf document; rearrange pages in pdf online
864
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
allows you to take remedial actions if the event you’re waiting for failed to occur in 
the prescribed time.
NOTE
You can either register an action for an event or wait for an 
event but you can’t do both. If an action has been registered, when the 
event fires the event object will be removed from the queue and passed 
to the action scriptblock for processing. As a result, any 
Wait-Event 
calls listening for this event will never receive it and will block forever. 
Let’s experiment with this cmdlet using something other than the timer event. In this 
example, you’ll work with the file system watcher class: 
System.IO.FileSystem-
Watcher
. This class is used to generate events when changes are made to monitored 
portions of the file system. Let’s look at the events exposed by this type:
PS (1) > [System.IO.FileSystemWatcher].GetEvents() | 
>>   Select-String . 
>>
System.IO.FileSystemEventHandler Changed 
System.IO.FileSystemEventHandler Created 
System.IO.FileSystemEventHandler Deleted 
System.IO.ErrorEventHandler Error 
System.IO.RenamedEventHandler Renamed 
System.EventHandler Disposed
Using this class, you can register for notifications when a file or directory is created, 
changed, deleted, or renamed. You can create a 
FileSystemWatcher
object that will 
monitor changes to your desktop. First, you need to get the resolved path to the desk-
top folder:
PS (2) > $path = (Resolve-Path ~/desktop).Path
You have to do this because, as discussed previously, when you use PowerShell paths 
as arguments to .
NET
methods (including constructors) you must pass in a fully 
resolved  path  because  .
NET
doesn’t  understand  PowerShell’s  enhanced  notion  of 
paths. Now, construct the file watcher object for the target path:
PS (3) > $fsw = [System.IO.FileSystemWatcher] $path
Set up an event subscription for the 
Created
and 
Changed
events:
PS (4) > Register-ObjectEvent -InputObject $fsw –EventName Created ` 
>> -SourceIdentifier fsw1 
PS (5) > Register-ObjectEvent -InputObject $fsw –EventName Changed ` 
>> -SourceIdentifier fsw2
Finally, enable event generation by the object:
PS (6) > $fsw.EnableRaisingEvents = $true
At this point when you call 
Get-Event
, you should see nothing:
PS (7) > Get-Event
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# users to reorder and rearrange multi-page Tiff file Tiff image management library, you can easily change and move pages or make a totally new order for all
how to move pages around in pdf; move pages in pdf online
RasterEdge.com General FAQs for Products
receive a copy of email containing order confirmation and via the email which RasterEdge's online store sends & profession imaging controls, PDF document, image
change pdf page order reader; move pages in pdf document
Q
UEUED
EVENTS
AND
THE
W
AIT
-E
VENT
CMDLET
865
This assumes that no other process is writing to the desktop while you’re doing this. 
Let’s perform an operation that will trigger the event. Create a new file on the desk-
top:
PS (8) > Get-Date > ~/desktop/date.txt
You didn’t set up an action for either of the event registrations, so you won’t see any-
thing happen immediately. The events, however, haven’t been lost. Unhandled events 
are added to the session event queue where they can be retrieved later. Let’s see what’s 
in the queue at this point:
PS (9) > Get-Event | select SourceIdentifier
SourceIdentifier 
----------------
fsw1 
fsw2
In the output, you see that two events have been added: one for the creation of the 
date.txt file and a second indicating that a change to the containing directory has 
occurred. Note that simply reading the events doesn’t remove them from the queue. 
You need to use the 
Remove-Event
cmdlet to do this; otherwise, you’ll keep reread-
ing the same event objects. The 
Remove-Event
cmdlet allows events to be removed 
either by 
SourceIdentifier
or by 
EventIdentifier
. To discard all the events in 
the queue, pipe 
Get-Event
into 
Remove-Event
:
PS (10) > Get-Event | Remove-Event
The queue is now empty, so you can call 
Wait-Event
and the session will block until 
a new event is generated (or you press Ctrl-C):
PS (11) > Wait-Event
To trigger  an  event,  from another PowerShell  session  update the  date.txt  file  by 
using this:
Get-Date > ~/desktop/date.txt
This code will cause an event to be added to the queue, terminating the 
Wait-Event
which will write the terminating event object to the output stream:
PS (11) > Wait-Event
ComputerName     :
RunspaceId       : 9c3c1728-7704-4e05-bba1-50ccc16d651f 
EventIdentifier  : 3 
Sender           : System.IO.FileSystemWatcher 
SourceEventArgs  : System.IO.FileSystemEventArgs 
SourceArgs       : {System.IO.FileSystemWatcher, date.txt} 
SourceIdentifier : fsw2 
TimeGenerated    : 8/9/2010 3:57:13 PM 
MessageData      :
866
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
Although you’re unblocked, the event hasn’t technically been handled, so it still exists 
in the queue and you still have to manually remove it from the queue:
PS (12) > Get-Event | Remove-Event
Let’s call 
Wait-Event
again but with a 2-second timeout and let the timeout expire:
PS (13) > Wait-Event -Timeout 2 
PS (14) >
In this case, you were unblocked but no object was written. This makes it easy to dis-
tinguish between a timeout and an actual event.
Now let’s move on to the second type of events that can be handled by the Power-
Shell eventing infrastructure: 
WMI
events.
20.7
W
ORKING
WITH
WMI 
EVENTS
In this section, we’re going to cover how to work with 
WMI
events in PowerShell. As 
was the case with .
NET
events, you handle 
WMI
events using a cmdlet to register 
actions associated with the events: the 
Register-WmiEvent
cmdlet syntax is shown 
in figure 20.3.
All  the other eventing  cmdlets remain the same as  you saw for object events. 
(You’ll see that this is also the case for engine events [section 20.8] and would also be 
the same for any new object sources that might be added in the future.)
20.7.1
WMI event basics
WMI
events are, in some ways, considerably more sophisticated than .
NET
events. 
First, 
WMI
events are represented as 
WMI
objects and so, like all 
WMI
objects, can be 
retrieved  from  either  a  local  or  remote  computer  in  a  transparent  way.  Second, 
because 
WMI
event subscriptions can take the form of a 
WQL
query, event filtering
Register-WmiEvent 
[-Class] <string>
[-Query] <string>
[-Namespace <string>]
[[-SourceIdentifier] <string>]
[[-Action] <scriptblock>]
[-ComputerName <string>]
[-Credential <PSCredential>]
[-Forward] 
[-MessageData <psobject>]
[-SupportEvent] 
[-Timeout <Int64>]
Forward event to remote
computer using 
PowerShell remoting
Event handler supports more
complex operation and
shouldn’t be visible on its own
Scriptblock that defines
action to take (optional)
Object to pass to event
handler (optional)
Namespace
containing class
Computer to access
Credentials to use
in this query
Maximum amount of time
to wait for event
WMI event trace class name
or WQL event query
Friendly name to use for
this event subscription
Figure 20.3 The signature of the 
Register-WmiEvent
cmdlet. This cmdlet is used to set 
up event handling for asynchronous WMI events.
W
ORKING
WITH
WMI 
EVENTS
867
can take place at the event source instead of transmitting all events to the receiver, 
who is forced to do all the filtering. This is important if you’re monitoring a small set 
of  events  on a  large number  of  computers. By  doing the  filtering  at the  source 
(remote) end, far less data is transmitted to the receiver and much less processing 
needs to be done by the receiver, allowing for the overall monitoring task to scale to 
far more computers than would otherwise be possible.
NOTE
On the other hand, unlike object events, there’s no notion of 
synchronous 
WMI
events so all event handling must go through the 
eventing subsystem.
We’ll begin our exploration of 
WMI
events by looking at the 
Win32_*Trace
classes, 
which are much simpler to deal with than the full query-based event subscriptions.
20.7.2
Class-based WMI event registration
Before jumping into the full  complexity of query-based  event subscriptions, we’ll 
look at some predefined 
WMI
event classes. These classes hide a lot of the complexity 
required by query-based event registration, making them easier to use. You can use 
the following command to get a list of these classes. You’ll also display their super-
classes to see the relationships between the classes:
PS (1) > Get-WmiObject -List Win32_*trace | 
>>   Format-List Name,__SUPERCLASS 
>>
Name         : Win32_SystemTrace 
__SUPERCLASS : __ExtrinsicEvent
Name         : Win32_ProcessTrace 
__SUPERCLASS : Win32_SystemTrace
Name         : Win32_ProcessStartTrace 
__SUPERCLASS : Win32_ProcessTrace
Name         : Win32_ProcessStopTrace 
__SUPERCLASS : Win32_ProcessTrace
Name         : Win32_ThreadTrace 
__SUPERCLASS : Win32_SystemTrace
Name         : Win32_ThreadStartTrace 
__SUPERCLASS : Win32_ThreadTrace
Name         : Win32_ThreadStopTrace 
__SUPERCLASS : Win32_ThreadTrace
Name         : Win32_ModuleTrace 
__SUPERCLASS : Win32_SystemTrace
Name         : Win32_ModuleLoadTrace 
__SUPERCLASS : Win32_ModuleTrace
868
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
By inspecting the class/superclass relationships, you can see that these classes form a 
hierarchy of event sources, where the further you go from the root, the more specific 
the event becomes. This hierarchy is illustrated in figure 20.4.
Let’s work through an example that shows how this works.
NOTE
Because these event sources fire for any process event, regard-
less of who starts them, these commands must be run from an elevated 
shell on Windows Vista, Window 7, Windows Server 2008, and Win-
dows Server 2008 R2. Also be aware that, because you’re recording all 
process events in the first set of examples, you may see additional out-
put from other processes starting and stopping.
Using the Win32_ProcessTrace events
You’ll use the 
Win32_Process*Trace
classes in this experiment. First you’ll set up an 
event subscription to the 
Win32_ProcessStartTrace
, which will fire every time a 
process starts:
PS (2) > Register-WmiEvent -Class Win32_ProcessStartTrace ` 
>>   -Action { 
>>     "Process Start: " + 
>>       $event.SourceEventArgs.NewEvent.ProcessName | 
>>         Out-Host 
>>   } 
>> 
In this class hierarchy, most
derived class represents most
specific event source
Win32_*Trace event class hierarchy
Win32_SystemTrace
Win32_ProcessTrace
Win32_ProcessStartTrace
Win32_ProcessStopTrace
Win32_ThreadTrace
Win32_ThreadStartTrace
Win32_ThreadStopTrace
Win32_ModuleTrace
Win32_ModuleLoadTrace
Figure 20.4 This figure shows the hierarchy of classes representing simplified WMI 
event sources. The most derived class matches the most specific event. 
Win32_ProcessStartTrace
will only fire for process starts whereas 
Win32_ProcessTrace
will fire for both process starts and process stops.
W
ORKING
WITH
WMI 
EVENTS
869
Id              Name            State      HasMoreData     Location 
--              ----            -----      -----------     -----
18              d999e74a-57c... NotStarted False
You can assign an action scriptblock to these event subscriptions, just as you did with 
object events. In the body of the scriptblock, you’ll write a message indicating what 
type of event was fired along with the process name. You’ll set up similar event han-
dlers for the 
Win32_ProcessStopTrace
and 
Win32_ProcessTrace
events, again 
displaying the type of the event and the process name:
PS (3) > Register-WmiEvent -Class Win32_ProcessStopTrace ` 
>>   -Action { 
>>     "Process Stop: " + 
>>       $event.SourceEventArgs.NewEvent.ProcessName | 
>>         Out-Host 
>>   } 
>> 
Id              Name            State      HasMoreData     Location 
--              ----            -----      -----------     -----
19              c4b4bf9d-368... NotStarted False 
PS (4) > Register-WmiEvent -Class  Win32_ProcessTrace ` 
>>   -Action { 
>>     "Process Any: " + 
>>       $event.SourceEventArgs.NewEvent.ProcessName | 
>>         Out-Host 
>>   } 
>> 
Id              Name            State      HasMoreData     Location 
--              ----            -----      -----------     -----
20              e4a5ad65-d35... NotStarted False
From  the  hierarchy  (and  the  names  of  the  events),  you  know  that 
Win32_ProcessStartTrace
fires when a process starts, 
Win32_ProcessStopTrace 
fires when a process is terminated, and 
Win32_ProcessTrace
fires on either kind of 
process event. To test these subscriptions, run the following command, which will 
start and stop an instance of the 
calc
process a number of times: 
PS (5) > & { 
>> $p = Start-Process calc -PassThru 
>> Start-Sleep 3 
>> $p | Stop-Process 
>> Start-Sleep 3 
>> $p = Start-Process calc -PassThru 
>> Start-Sleep 3 
>> $p | Stop-Process 
>> Start-Sleep 3 
>> } 
>>
In  this  command  you’re  using 
Start-Process
to start the 
calc
process with 
-PassThru
to capture the process object and save it in a variable. Then, after three 
seconds,  you  pass  the  captured  object  to 
Stop-Process
to terminate the 
calc
Documents you may be interested
Documents you may be interested