c# pdf viewer itextsharp : How to reorder pdf pages in reader software SDK dll winforms windows azure web forms Windows%20Powershell%20in%20Action%202nd%20Edition90-part1550

870
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
instance. This pattern is repeated three times and the whole thing is wrapped in a 
scriptblock to cause it to be executed as a single command. (This way, you avoid hav-
ing your commands mixed in with the output and cluttering things up. Alternatively, 
you could’ve used the PowerShell 
ISE
instead of the console shell; see section 15.1.1.) 
Here’s the output produced by this command:
Process Start: calc.exe 
Process Any: calc.exe 
Process Any: calc.exe 
Process Stop: calc.exe 
Process Start: calc.exe 
Process Any: calc.exe 
Process Any: calc.exe 
Process Stop: calc.exe
The first two records were generated by the first 
calc
process starting. You get both 
Win32_ProcessStartTrace
and 
Win32_ProcessTrace
firing but not 
Win32_ProcessStopTrace
. The 
calc
process is then stopped, resulting in two more 
records, and this is repeated one more time for a total of eight records. (The order in 
which the specific and general events are fired is nondeterministic, so the exact order 
will change with different runs of the start/stop command.)
Verifying that the events fired
To verify that the events fire for all process creations, let’s start and stop the Telnet ser-
vice. This will cause the service manager to start the 
TlntSvr
process, which should, 
in turn, trigger an event:
PS (6) > Start-Service TlntSvr; Stop-Service TlntSvr 
Process Any: tlntsvr.exe 
Process Start: tlntsvr.exe 
PS (7) > Process Stop: tlntsvr.exe 
Process Any: tlntsvr.exe
This is confirmed by the output, indicating that the service process was started and 
stopped.
The final step in this experiment is to clean up the event subscriptions you cre-
ated. Here’s the easiest way to do this:
PS (7) > Get-EventSubscriber | Unregister-Event 
PS (8) >
Note that this code removes all event subscriptions for this session. This is fine for 
experimentation but you should be careful doing this in a production environment 
and be selective about what is removed.
This completes the easy part of 
WMI
event handling. Although setting up event han-
dlers this way was easy, it was also very limited. In chapter 19, when you retrieved 
WMI 
object instances using 
Get-WmiObject
, you were able to do sophisticated filtering and 
could be precise about the objects you retrieved. You can be just as precise with events, 
but doing so requires the use of 
WQL
queries. We’ll cover this in the next section.
How to reorder pdf pages in reader - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
rearrange pages in pdf reader; pdf change page order
How to reorder pdf pages in reader - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to rearrange pages in a pdf file; move pdf pages in preview
W
ORKING
WITH
WMI 
EVENTS
871
20.7.3
Query-based WMI event registrations
In chapter 19 (section 19.2.2) you used the 
WMI
Q
uery 
L
anguage 
(WQL)
to select 
and filter 
WMI
objects. The format of those instance-based 
WQL
queries was
SELECT 
<
propertyList
>
FROM 
<
ObjectClass
>
WHERE 
<
predicateExpression
>
With a little bit of additional syntax, 
WQL
can also be used to select and filter 
WMI 
events.
NOTE
In 
CIM
parlance, what you actually filter is called a notification, 
not an event. 
CIM
defines an event as something that happens at a par-
ticular point in time like a process starting or a user logging on. Notifi-
cations  are  the  object  representation  (or  model)  for  these  event 
occurrences. For simplicity, we’re going to stick to using event for both 
cases in the rest this chapter.
The core syntax for event queries is the same as for instance queries but with some 
additional features. We’ll look at these features in the next couple of sections. 
The WITHIN keyword
The first of the additional keywords we’ll discuss is 
WITHIN
. This keyword is used in a 
query as follows:
SELECT <propertyList> FROM <EventClass> WITHIN <Seconds> WHERE 
<predicateExpression>
The 
WITHIN
keyword is used to specify the polling interval that the 
WMI
service 
should use to monitor and relay event data. The polling interval is the frequency with 
which the monitored resource is checked. The smaller the polling interval, the more 
often the monitored resource will be checked. This results in faster and more accurate 
event notifications, but it also places more burden on the monitored system. The 
argument to the 
WITHIN
keyword is a floating-point number. This means you could 
theoretically specify polling intervals of less than one second. However, specifying a 
value that’s too small (like 0.001 seconds) could cause the 
WMI
service to reject a 
query as not valid due to the resource-intensive nature of polling. The polling interval 
should be chosen based on the type of event being monitored. If the event doesn’t 
require instant action, it’s generally recommended that the polling interval be greater 
than 300 seconds (that is, 5 minutes).
The WMI intrinsic event classes
The objects you query for are also a bit different. With object events, you create an 
instance of an object  and then subscribe  to an event on that object. With 
WMI 
event  queries,  you  subscribe  to  the  type  of  event  and  then  specify  the  event-
generating  class  you’re  interested  in.  Some  of  the  most  useful  of  these  intrinsic 
event  classes  are 
_InstanceCreationEvent
__InstanceDeletionEvent
 and
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
move pages in pdf acrobat; change pdf page order online
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
just following attached links. C# PDF: Add, Delete, Reorder PDF Pages Using C#.NET, C# PDF: Merge or Split PDF Files Using C#.NET.
reordering pdf pages; move pages in a pdf
872
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
_InstanceModificationEvent
 which  are  all  derived  from 
_Instance-
OperationEvent
. These classes and their relationships are shown in figure 20.5.
These  classes  mirror  the  pattern  you  saw  in  the  previous  section  where 
Win32_ProcessTrace
was the root event with 
Win32_ProcessStartTrace
and 
Win32_ProcessStopTrace
as derived events. The difference here is that there’s no 
class like Win32_Process mentioned in these events. They are general-purpose events 
generated by all objects. So, when you want to register an event subscription for one 
of these events, you use the 
ISA
operator to select which class you’re interested in 
receiving instance notifications from. Let’s see what a query using the 
WITHIN
key-
word and these instance notifications events looks like:
SELECT * FROM __InstanceOperationEvent WITHIN 1 
WHERE TargetInstance ISA 'Win32_Service'
AND TargetInstance.Name='TlntSvr'
This query says to retrieve all events from 
InstanceOperationEvent
with a polling 
interval of one second (this is an experiment so you’ll use a small value) where the 
object generating the event is an instance of the 
Win32_Service
class and the 
Name 
property on the instance is 
TlntSvr
. In other words, you want to generate an event 
anytime something happens to the Telnet service. 
NOTE
This example assumes that you have the Telnet service installed 
on the target computer. Because the Telnet service is an optional install, 
you  may have  to  install  it. To do so,  from  an elevated PowerShell 
instance, run 
appwiz.cpl
to launch the Programs And Features control 
panel applet. In this applet, select “Turn Windows Features on or off,” 
locate Telnet service in the list, and click the check box beside it. (This 
process might vary slightly depending on which version of Windows 
you’re running.) Click 
OK
and the Telnet service will be installed.
Generated when WMI instance is created,
deleted, or modified
WMI instance event class hierarchy
__InstanceOperationEvent
__InstanceCreationEvent
__InstanceDeletionEvent
__InstanceModificationEvent
Generated when WMI
object is created
Generated when WMI
object is deleted 
Generated when WMI
object is modified
Figure 20.5 The class hierarchy for the WMI instance operation event class. These 
events are generated when a WMI is object is created, deleted, or modified. The base 
event class is triggered for all three. 
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
how to move pages around in pdf; how to move pdf pages around
VB.NET PDF: Create PDF Document Viewer in C#.NET for Document
Support navigating to the previous or next page of the PDF document; Able to insert, delete or reorder PDF document page in VB.NET document viewer;
reverse pdf page order online; pdf reverse page order online
W
ORKING
WITH
WMI 
EVENTS
873
Let’s try this out. Assign the query to a variable:
PS (1) > $svcQuery = @" 
>> Select * From __InstanceOperationEvent Within 1 
>> Where TargetInstance Isa 'Win32_Service' 
>>   and 
>>    TargetInstance.Name='TlntSvr' 
>> "@ 
>>
Now use the 
Register-WmiEvent
to subscribe to this event. In the action field, dis-
play a message indicating the source of the event and then print out the contents of 
the 
$event
variable:
PS (2) > Register-WmiEvent -Query $svcQuery -Action { 
>>    Write-Host "Got instance operation event on Win32_Service" 
>>    $Event | Format-List * | Out-Host 
>> } 
>>
Id              Name            State      HasMoreData     Location 
--              ----            -----      -----------     -----
              ecd3a80c-a70... NotStarted False 
PS (3) >
With the event subscription set up, trigger the event by starting the Telnet service:
PS (4) > Start-Service TlntSvr
Got specific instance operation event on Win32_Service 
ComputerName     : 
RunspaceId       : e4ac72a7-0868-488b-af17-4aeb9a1b04d1 
EventIdentifier  : 5 
Sender           : System.Management.ManagementEventWatcher 
SourceEventArgs  : System.Management.EventArrivedEventArgs 
SourceArgs       : {System.Management.ManagementEventWatcher, Sy
stem.Management.EventArrivedEventArgs} 
SourceIdentifier : ecd3a80c-a70c-4e21-a420-3038be93aade 
TimeGenerated    : 9/12/2010 9:36:31 PM 
MessageData      :
And, after a second or so, you see the message printed out by the action scriptblock. 
Stop the service:
PS (6) > Stop-Service TlntSvr
PS (7) > Got specific instance operation event on Win32_Service
ComputerName     :
RunspaceId       : e4ac72a7-0868-488b-af17-4aeb9a1b04d1 
EventIdentifier  : 6 
Sender           : System.Management.ManagementEventWatcher 
SourceEventArgs  : System.Management.EventArrivedEventArgs 
SourceArgs       : {System.Management.ManagementEventWatcher, Sy
stem.Management.EventArrivedEventArgs} 
SourceIdentifier : ecd3a80c-a70c-4e21-a420-3038be93aade 
TimeGenerated    : 9/12/2010 9:36:36 PM 
MessageData      :
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Enable batch changing PDF page orientation without other PDF reader control. PDF page, delete certain PDF page, reorder existing PDF pages and split
how to move pages in pdf files; reorder pdf pages 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; how to reorder pages in pdf file
874
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
And you get a second message because the event you’ve subscribed to fires for any change.
In the next section, we’ll look at additional features for improving the network 
behavior of the system by grouping events instead of sending them one at a time.
Aggregating events with GROUP
The next keyword we’ll cover is 
GROUP
. The 
GROUP
clause is used to aggregate the 
events based on certain criteria. This means that instead of generating one notifica-
tion per event, the 
WMI
service will group them together with a count and a repre-
sentative  instance.  This  is another way to reduce  the  load on the client and the 
network:
SELECT * FROM EventClass [WHERE property = value] 
GROUP WITHIN interval [BY property_list]
[HAVING NumberOfEvents operator integer]
You create a query-based 
WMI
event registration using the 
-Query
parameter set on 
Register-WmiEvent
:
Select * From __InstanceOperationEvent Within .5
Where TargetInstance Isa 'Win32_Service' 
and TargetInstance.Name='TlntSvr'
Group Within 20
Let’s set up this new event subscription. First save your query in a string and set up a 
counter that will record the total number of events:
PS (1) > $GroupQuery = @" 
>> Select * From __InstanceOperationEvent Within .5 
>> Where TargetInstance Isa 'Win32_Service' 
>> and TargetInstance.Name='TlntSvr' 
>> Group Within 20 
>> "@ 
>>
PS (2) > $global:TotalEvents = 0
Now register this event subscription:
PS (3) > Register-WmiEvent -Query $GroupQuery -Action { 
>>    Write-Host "Got grouped event" 
>>    $ne = $Event.SourceEventArgs.NewEvent 
>>    $ti = $ne.Representative.TargetInstance 
>>    $global:TotalEvents += $ne.NumberOfEvents 
>>    $msg = "Type: " + $ne.__CLASS + 
>>      " Num Evnts: " + $ne.NumberOfEvents + 
>>        " Name: " + $ti.Name + 
>>          " (" + $ti.DisplayName + ')' | 
>>            Out-Host 
>> } 
>>
Id              Name            State      HasMoreData     Location 
--              ----            -----      -----------     --------
              d251cd26-2e2... NotStarted False
VB.NET PDF: VB.NET Guide to Process PDF Document in .NET Project
It can be used to add or delete PDF document page(s), sort the order of PDF pages, add image to PDF document page and extract page(s) from PDF document in VB
change page order in pdf file; how to rearrange pdf pages online
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 move pages in pdf; change pdf page order preview
E
NGINE
EVENTS
875
In the body of the event action scriptblock, you’ll format a string containing some of 
the more interesting fields (at least for the purpose of this experiment). You’ll show 
the type of the event class, the number of events that have been aggregated, and then 
the 
Name
and 
DisplayName
for the matched service. You’ll generate a series of events 
using a 
foreach
loop to cause the event aggregation to fire:
PS (4) > foreach ($i in 1..3) 
>> { 
>>   Start-Service TlntSvr 
>>   Start-Sleep 2 
>>   Stop-Service TlntSvr 
>>   Start-Sleep 2 
>> } 
>>
These events will all be accumulated in the event group and, when the group interval 
expires, you should get an event notification. Use the 
Start-Sleep
command to 
wait for the timeout to expire:
PS (5) > Start-Sleep 10
Got grouped event 
Type: __AggregateEvent Num Evnts: 6 Name: TlntSvr (Telnet)
The event count shows your total:
PS (6) > "Total events: $TotalEvents"
Total events: 6 
PS (7) >
Now that you have your event, let’s clean up the event subscription:
PS (8) > Get-EventSubscriber | Unregister-Event
In this example, you’ve seen how you can use the 
GROUP
keyword to further reduce 
the number of events that need to be sent to the monitoring script.
This completes our look at 
WMI
eventing so let’s move on to something a bit dif-
ferent. Up until now, we’ve only been talking about how to respond to events. In the 
next section, you’ll see how to generate some events of your own.
20.8
E
NGINE
EVENTS
The last category of events we’re going to look at is called engine events. With engine 
events, the notifications are generated by the PowerShell engine itself, either through 
one of the predefined engine events or by explicitly generating an event in a script.
20.8.1
Predefined engine events
In the released version of PowerShell v2, there’s currently only one predefined engine 
event  identified  by  the  string 
"PowerShell.Exiting"
 This  string  can  also  be 
retrieved using a static method as follows:
PS (1) > ` 
>> [System.Management.Automation.PsEngineEvent]::Exiting
876
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
>>
PowerShell.Exiting
This event is triggered when the PowerShell engine is shutting down and allows you 
to perform actions before the session exits. Here’s an example event registration:
Register-EngineEvent `
-SourceIdentifier PowerShell.Exiting `
-Action {
"@{Directory='$PWD'}" > ~/pshState.ps1
}
This command registers an action to take when the PowerShell session ends. This 
action writes a hashtable to the file pshState.ps1 in the user’s directory. The hashtable 
captures the user’s current directory at the time the session was exited. Let’s use this in 
an example. You’ll create a child 
PowerShell.exe
process to run your script so you 
don’t have to exit the current process. PowerShell recognizes when a scriptblock is 
passed to the 
PowerShell.exe
command and makes sure that everything gets passed 
to the command correctly. Let’s run the command:
PS (1) > powershell { 
>>     Register-EngineEvent ` 
>>       -SourceIdentifier PowerShell.Exiting ` 
>>       -Action { 
>>         "@{Directory='$PWD'}" > ~/pshState.ps1 
>>         } | Format-List Id,Name 
>>      cd ~/desktop 
>>      exit 
>>   } 
>>
Id   : 1
Name : PowerShell.Exiting
Now look at the content of the file:
PS (2) > Get-Content ~/pshState.ps1 
@{Directory=‘C:\Users\brucepay.REDMOND\desktop’}
And you see that the file contains a hashtable with the current directory recorded in 
it. This example can easily be expanded to include things like the user’s history or the 
contents of the function: drive, but adding those extensions is left as an exercise for 
the reader.
The other class of engine events is script-generated events. We’ll look at those next.
20.8.2
Generating events in functions and scripts
The last of the core eventing cmdlets to look at is the 
New-Event
cmdlet. This cmd-
let allows a script to generate its own events. Let’s use this cmdlet in an example to see 
how it works. First you create the timer object:
PS (1) > $timer = New-Object System.Timers.Timer -Property @{ 
>>   Interval = 5000; Enabled = $true; AutoReset = $false } 
>>
R
EMOTING
AND
EVENT
FORWARDING
877
And register the event subscription:
PS (2) > Register-ObjectEvent $timer Elapsed -Action { 
>>   Write-Host '<TIMER>' 
>>     New-Event -SourceIdentifier generatedEvent -Sender 3.14 
>> } > $null 
>>
In the handler scriptblock, as well as writing out a message, you’re also calling 
New-
Event
to generate a new event in the event queue. Finally, start the timer
PS (3) > $timer.Start() > $null
PS (4) >
and wait for the event. Pipe the object returned from 
Wait-Event
into the 
foreach 
cmdlet for processing:
PS (5) > Wait-Event -SourceIdentifier generatedEvent | 
>>   foreach { 
>>     "Received generated event" 
>>     $_ | 
>>       Format-Table -AutoSize SourceIdentifier, EventIdentifier 
, Sender 
>>     $_ | Remove-Event 
>>   } 
>> 
<TIMER>
Received generated event
SourceIdentifier EventIdentifier Sender 
---------------- --------------- ------
generatedEvent                12   3.14
In the output, you first see the 
<TIMER>
message indicating that the timer event has 
triggered. Then you see the output from 
Wait-Event
. In the 
foreach
block, you 
display the source identifier of the event generated by 
New-Event
, and the 
Sender 
field shows the number you passed to the cmdlet. When you’re done with this exam-
ple, you’ll remove the event subscription:
PS (6) > Get-EventSubscriber | Unregister-Event
This pretty much completes the local event handling story. But with PowerShell v2 
adding remoting capabilities, obviously our eventing infrastructure needs to work in a 
distributed environment as well. In the next section you’ll see how to work with 
events in remote scenario.
20.9
R
EMOTING
AND
EVENT
FORWARDING
Being able to set up local event handlers is useful, but you also need to be able to pro-
cess events generated on remote computers to manage distributed datacenters. The 
PowerShell eventing subsystem, by building on top of PowerShell remoting, makes 
this surprisingly easy. In figures 20.1 and 20.2 you saw the 
-Forward
parameter. This
878
CHAPTER 20
R
ESPONDING
IN
REAL
TIME
WITH
EVENTING
parameter does exactly what you might expect: it forwards the subscribed event to a 
remote session. This is where the 
-SourceIdentifier
parameter becomes critical. 
The source identifier name that’s specified at the event source end becomes the name 
of the event to process on the receiving end. This process is illustrated in figure 20.6.
Here’s where the engine events come into play. The forwarded events are handled 
using engine event processing. The cmdlet for subscribing to this type of event is 
shown in figure 20.7. (The events generated by 
New-Event
in the previous section 
are also engine events.)
Remote listener connects to event and sends command:
Invoke-Command $server1 { 
Register-ObjectEvent  -SubscriberID Interesting .Event.1 -Forward …
}
client1
This cmdlet lets you register subscriptions that trigger the event handler based on 
the subscription identifier sent from the remote end. In the next section, we’ll look 
at a detailed example where you forward an event from one machine for processing 
on another.
Handling remote EventLog events
In this section, you’re going to apply what you’ve learned. Your goal is to be notified 
locally every time an event is written into the event log on a remote computer. The 
.
NET
EventLog
class exposes just such an event: 
EntryWritten
. To set this up, you 
must establish event forwarding on the remote machine and then register a load event 
handler. You’ll also need to maintain a connection to the remote end using the duration 
of time you want to get events because the events are being forwarded over this channel.
The first thing you need to do is to establish a connection to the target computer. 
You do so with the 
New-PSSession
cmdlet, passing credentials if needed (see section
12.3.2 for more information on 
New-PSSession
):
PS (1) > $s = New-PSSession -ComputerName brucepayquad
This is the session you’ll use to set up the event forwarding and then to transfer the 
forwarded events. Next you’ll use 
Invoke-Command
to set up the event forwarding 
Documents you may be interested
Documents you may be interested