c# pdf viewer itextsharp : Change pdf page order preview software control dll winforms web page windows web forms Windows%20Powershell%20in%20Action%202nd%20Edition82-part1541

790
CHAPTER 18
W
ORKING
WITH
COM
task is created. You’ll use the 
Get-Credential
cmdlet to get the user credentials in 
the 
PSCredential
object:
PS (25) > $cred = Get-Credential
cmdlet Get-Credential at command pipeline position 1 
Supply values for the following parameters: 
Credential
At this point, you’ve run into a bit of a problem. The 
RegisterTaskDefinition() 
method doesn’t understand 
PSCredential
objects. It requires a name and a password, 
which means that you’ll have to extract these fields from the credential object. Getting 
the user name is trivial: 
UserName
is a string-valued property on the credential object. 
Getting the password, however, is less obvious. The 
Password
field on the credential 
object is a 
SecureString
(see section 21.5.4),
which the task registration 
API
also 
doesn’t understand. It requires the password to be a simple clear-text string. Fortu-
nately  this  scenario  is  covered  and  you  can  use  the 
GetNetworkCredential() 
method on the 
PSCredential
object to get the necessary clear-text password. 
Finally, you can put all of the pieces together and register your task with the Task 
Scheduler. When you register the task, give it the name 
PowerShellTimeTrigger-
Test
to make it easy to find later. Here’s the command to register the task:
PS (26) > $tsFolder.RegisterTaskDefinition( 
>>   "PowerShellTimeTriggerTest", $nt, 6, 
>>     $cred.UserName, 
>>       $cred.GetNetworkCredential().Password, 3) 
>>
Name               : PowerShellTimeTriggerTest 
Path               : PowerShellTimeTriggerTest 
State              : 3 
Enabled            : True 
LastRunTime        : 12/30/1899 12:00:00 AM 
LastTaskResult     : 1 
NumberOfMissedRuns : 0 
NextRunTime        : 8/19/2010 11:23:40 PM 
Definition         : System.__ComObject 
Xml                : ...
This call returns a task registration object that includes all the task information you 
passed. Of particular interest is the 
Xml
property. This property contains the task reg-
istration information registered as an 
XML
document. The content of this document 
is shown in listing 18.8. In this listing, you can see elements corresponding to each of 
the object you created: 
RegistrationInfo
Triggers
Actions
, and 
Principal
There’s also a section for the 
Settings
element that contains additional information 
about how the task is to be run.
Change pdf page order preview - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to move pages around in pdf file; how to move pages around in pdf
Change pdf page order preview - 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; change pdf page order reader
W
ORKING
WITH
THE
W
INDOWS
T
ASK
S
CHEDULER
791
<?xml version="1.0" encoding="UTF-16"?> 
<Task version="1.2" xmlns=
"http://schemas.microsoft.com/windows/2004/02/mit/task">
<RegistrationInfo>
<Author>Bruce Payette</Author>
<Description>Count to 10</Description>
</RegistrationInfo>
<Triggers>
<TimeTrigger id="Trigger in 30 seconds">
<StartBoundary>2010-08-20T06:23:40Z</StartBoundary>
<EndBoundary>2010-08-20T06:28:10Z</EndBoundary>
<ExecutionTimeLimit>PT1M</ExecutionTimeLimit>
<Enabled>true</Enabled>
</TimeTrigger>
</Triggers>
<Settings>
<IdleSettings>
<Duration>PT10M</Duration>
<WaitTimeout>PT1H</WaitTimeout>
<StopOnIdleEnd>true</StopOnIdleEnd>
<RestartOnIdle>false</RestartOnIdle>
</IdleSettings>
<MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
<DisallowStartIfOnBatteries>true</DisallowStartIfOnBatteries>
<StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
<AllowHardTerminate>true</AllowHardTerminate>
<StartWhenAvailable>false</StartWhenAvailable>
<RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
<AllowStartOnDemand>true</AllowStartOnDemand>
<Enabled>true</Enabled>
<Hidden>false</Hidden>
<RunOnlyIfIdle>false</RunOnlyIfIdle>
<WakeToRun>false</WakeToRun>
<ExecutionTimeLimit>PT72H</ExecutionTimeLimit>
<Priority>7</Priority>
</Settings>
<Actions Context="Author">
<Exec>
<Command>
C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
</Command>
<Arguments>
foreach ($i in 1..10) { $i; sleep 1 }; sleep 1000
</Arguments>
</Exec>
</Actions>
<Principals>
<Principal id="Author">
<UserId>\brucepay</UserId>
<LogonType>InteractiveToken</LogonType>
</Principal>
</Principals> 
</Task>
Listing 18.8    The XML representation of the new task
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 pdf pages in preview; reorder pages in a pdf
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
reorder pdf pages; how to move pages in pdf
792
CHAPTER 18
W
ORKING
WITH
COM
Once this 
RegisterTaskDefinition()
method has been run, your task is active 
and scheduled. So 30 seconds after calling the method, you’ll see a window pop up on 
your desktop displaying the numbers from 1 to 10, as shown in figure 18.10.
This window will continue to be displayed until the task duration timeout occurs, 
at which point the Task Scheduler service terminates the triggered process.
18.6.5
Viewing the life cycle of a task 
To see all of the events in the task life cycle, you can use the Task Scheduler tool to see 
the task’s history. To start this tool, run 
taskschd.msc
at the command line. Figure
18.11 shows the Task Scheduler window displaying the events in the task’s History tab. 
Figure 18.10 This is the window you’ll 
see when the scheduled task you created 
is triggered and executes. The window 
shows the output of the PowerShell 
commands that were passed as 
arguments to the task executable.
Figure 18.11 This figure 
shows the event history 
for the task you created 
using PowerShell. It 
shows the task triggering, 
starting execution and 
finally being terminated 
because it exceeded the 
maximum execution 
time for the task.
C# Word - Process Word Document in C#
various Word document processing implementations using C# demo codes, such as add or delete Word document page, change Word document pages order, merge or
rearrange pages in pdf file; how to move pages in pdf acrobat
C# Image: View & Operate Web Page Using .NET Doc Image Web Viewer
Support multiple document and image formats, like PDF and TIFF; Change Web Document Page Order. document image viewer, you can easily achieve page re-arranging
how to move pages in pdf reader; how to reverse pages in pdf
I
SSUES
WITH
COM
793
In this history, you see each step in the execution of the task: the trigger, starting the 
task action execution, launching the task process, and finally stopping and terminat-
ing the task.
Using 
COM
in PowerShell lets you do amazing things—automating applications, 
mixing and matching languages, and so on. But there are also issues with 
COM
sup-
port, which we’ll cover in the next section.
18.7
I
SSUES
WITH
COM
Support for 
COM
in PowerShell is very good but not perfect. In part, this is due to 
the fact that PowerShell depends on .
NET,
and .
NET
’s support for 
COM
is also not 
perfect. In this section, we’ll explore a few problems that you may run into when 
using 
COM
from PowerShell, including more information on the 
Interop
assembly 
issue mentioned in section 18.1.1.
18.7.1
64-bit vs. 32-bit issues
One problem that arises is that some 
COM
objects are only available to 32-bit appli-
cations. On 64-bit systems, the 64-bit PowerShell binaries are run by default, so if you 
need to use a 32 bit–only 
COM
object, you’ll have to explicitly start the 32-bit version 
of PowerShell. This can also be an issue when using remoting because the default remot-
ing configuration on 64-bit systems is 64 bit as well. To remotely run a script that 
requires a 32-bit 
COM
object, you’ll have to connect to the 32-bit configuration on the 
remote machine, regardless of whether the local system is 32 or 64 bit. (Section 12.6.6 
in chapter 12 covers the details on how to target a specific remoting configuration.)
18.7.2
Threading model problems
By default 
PowerShell.exe
runs in multithreaded apartment 
(MTA)
mode. A signif-
icant number of 
COM
objects require the caller to be in single-threaded apartment 
(STA)
mode. Most of the time this will be transparent to you because the PowerShell 
COM
type adapter does a bunch of magic under the covers, and most of the time it 
works fine. Occasionally, though, you’ll encounter something that doesn’t work. The 
solution is to restart 
PowerShell.exe
with the 
-sta
switch and try it again. The 
-sta
switch starts PowerShell in 
STA
mode instead of the default 
MTA
mode, and 
this is usually sufficient to get things working.
NOTE
Remember  that,  although  the  default  mode  for 
Power-
Shell.exe
is 
MTA
, the default (and only) mode for the PowerShell 
ISE
is 
STA
. This difference can occasionally cause the same script to 
behave differently in the two environments.
18.7.3
Interop assemblies, wrappers, and typelibs
As mentioned in 18.1.1, another thing that can potentially cause problems has to do 
with the way the 
COM
object has been wrapped or adapted. There are three possible
C# Excel - Sort Excel Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Excel document pages, or just change the position of certain one Excel page in an
moving pages in pdf; reorder pages in pdf preview
C# PDF: How to Create PDF Document Viewer in C#.NET with
image and outline preview for quick PDF document page navigation; requirement of this C#.NET PDF document viewer that should be installed in order to implement
how to move pages in pdf converter professional; change page order pdf reader
794
CHAPTER 18
W
ORKING
WITH
COM
categories  of 
COM
object  you  may  encounter:  a 
COM
object  that  has  a  .
NET 
Interop
library, a 
COM
object that has a type library (commonly called a typelib) 
but no 
Interop
assembly, and a 
COM
object that has neither.
In the first category, you get a 
COM
object that has been wrapped in a .
NET 
interop wrapper. This wrapper may introduce changes in the object’s interface or 
behavior that affects how you work with that object compared to the raw 
COM 
object. For this reason, the 
New-Object
cmdlet’s 
ComObject
parameter set has an 
additional parameter, 
-Strict
, that causes a nonterminating error to be written if an 
Interop
assembly is loaded. Let’s look at some examples. Start by creating an 
instance of the 
Word.Application
object you used earlier:
PS (23) > $word = New-Object -Com word.application
Now try it again but with the 
-Strict
parameter:
PS (24) > $word = New-Object -Com word.application -Strict 
New-Object : The object written to the pipeline is an instance of the type 
"Microsoft.Office.Interop.Word.ApplicationClass" from the 
component's primary interop assembly. If this type exposes 
different members than the IDispatch members, scripts written 
to work with this object might not work if the primary interop 
assembly is not installed.
At line:1 char:19 
+ $word = New-Object  <<<< -Com word.application –Strict
You  get  a detailed error message  explaining  that  the  object  that  was loaded is a 
wrapped object. Note that this is a nonterminating error message, so the object is still 
returned and execution proceeds. Here’s how to use this feature to write a script that 
can adapt its behavior appropriately.
First, you don’t want the error message to appear in the output of your script, so 
redirect it to 
$null
. But even when you do this, the 
$?
variable, which indicates 
whether the last command executed was successful, is still set to 
$false
so you know 
that an error occurred:
PS (26) > $word = New-Object -com Word.Application ` 
>>  -strict 2> $null 
>>
PS (27) > $?
False
A script should check this variable and take an alternate action for the wrapped and 
nonwrapped cases. Investigating further, let’s take a look at what was returned by the 
call to 
New-Object
:
PS (28) > $word.gettype().fullname
Microsoft.Office.Interop.Word.ApplicationClass
The output shows that the object is an instance of the 
Interop
assembly mentioned 
earlier.
C# PowerPoint - How to Process PowerPoint
For developers who want to delete unnecessary page from PowerPoint document, this C#.NET PowerPoint processing control is quite C# Codes to Sort Slides Order.
change pdf page order preview; reorder pdf pages in preview
C# PDF insert text Library: insert text into PDF content in C#.net
Ability to change text font, color, size and location and string to a certain position of PDF document page. C#.NET Project DLLs: Insert Text Content to PDF.
move pages in pdf online; reverse page order pdf
S
UMMARY
795
Next, take a look at an object for which there’s no 
Interop
assembly and see how 
that behaves differently. Create an instance of the 
Shell.Application
class you 
worked with earlier:
PS (43) > $shell = New-Object -ComObject Shell.Application 
PS (44) > $shell | Get-Member
TypeName: System.__ComObject#{efd84b2d-4bcf-4298-be25-eb 
542a59fbda}
Name                 MemberType Definition 
----                 ---------- ----------
AddToRecent          Method     void AddToRecent (Varian... 
BrowseForFolder      Method     Folder BrowseForFolder (... 
:
In this situation, you see that the type of the object is 
System.__ComObject
fol-
lowed by the 
GUID
of the registered type library. This type library is what allows you 
to see the members on the object but doesn’t affect the object’s behavior.
18.8
S
UMMARY
This chapter introduced Windows’ native object model, the 
COM
framework, and 
we showed you how to use it with PowerShell. 
COM
objects and automation inter-
faces are the core mechanism used by older, unmanaged scripting languages such as 
VBScript and JScript. And, although the .
NET F
ramework and managed code con-
tinues to grow in functionality, having direct access to these unmanaged scripting 
interfaces still offers substantial value.
In this chapter, we covered the following points:
• We introduced the basic elements of 
COM
, how to identify a 
COM
object using 
P
rog
ID
s, and how to get a list of these 
P
rog
ID
s.
• You saw that the 
Get-Member
cmdlet is a powerful tool for learning about and 
examining 
COM
objects.
This chapter included many examples of how to use 
COM
:
• Writing  scripts  that  manipulate  browser  and  shell  windows  using  the 
Shell.Application
class
• Using the 
WScript.Shell
object to pop up message boxes or send keystroke 
sequences to automate a Windows application
• Using the browser to look up a word in an online resource with the 
Internet-
Explorer.Application
class
• Using 
COM
automation to control applications like Microsoft Word to per-
form scripted tasks via the 
Word.Application
class
796
CHAPTER 18
W
ORKING
WITH
COM
• Using the 
ScriptControl
to allow a PowerShell script to call functions written 
in 
VBS
cript or 
JS
cript
• Creating scheduled tasks for the Windows Task Scheduler using the 
Sched-
uler.Service
class
We also covered some of the issues you might run into using 
COM
from PowerShell 
such as 
STA
versus 
MTA
threading issues and 32-bit versus 64-bit controls.
You are now comfortable with .
NET
and 
COM
objects, but these are general-
purpose technologies. In the next chapter we’ll look at an object framework and set of 
technologies (
CIM
WMI
, and 
WSM
an) that are specifically targeted at management 
tasks. These technologies are based on industry standards with the goal of providing 
broad cross-platform support for datacenter management. 
797
C
H
A
P T E R   1 9
Management objects: 
WMI 
and 
WS-MAN
19.1  Working with WMI in 
PowerShell  798
19.2  The WMI cmdlets  801
19.3  The WMI object adapter  824
19.4  Exploring WS-Man  830
19.5  Summary  845
A horse is a horse, of course, of course. And no one can talk to a horse, of 
course. That is, of course, unless the horse is the famous Mister Ed!
—Theme song from the Mister Ed television show
In the previous chapter, we explored the kinds of things you can do with 
COM
, the 
Windows “native” object  framework.  Although 
COM
and  .
NET
can  be used for 
many management tasks, management isn’t their primary purpose. In this chapter 
we’ll look at an object system that’s specifically designed to address the needs of sys-
tems management: Windows Management Instrumentation 
(WMI)
WMI
is Micro-
soft’s implementation of the industry-standard Common Information Model 
(CIM)
.
In this chapter, you’ll learn what 
WMI
is, how to access it from PowerShell, and 
what you can do with 
WMI
once you have this access. You’ll work through a number 
of examples to see how things work, exploring the sorts of tasks that can be accom-
plished. The second part of the chapter looks at Web Services for Management (
WS-
M
an). 
WS-M
an  is  another  standard  related  to 
CIM
 We  introduced 
WS-M
an  in
798
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
chapter 13 in the context of PowerShell remoting, but in this chapter, you’ll see how 
to use it to access the 
CIM
objects and why that matters. 
19.1
W
ORKING
WITH
WMI 
IN
P
OWER
S
HELL
WMI
is Microsoft’s implementation of the Common Information Model. 
CIM
is an 
industry standard (a set of related standards) created by Microsoft, 
HP
IBM
, and 
many other computer companies with the goal of defining a common set of manage-
ment abstractions. By creating interoperable common models for managed elements 
like services, processes, or 
CPU
s, we can start to build management tools and pro-
cesses that can be applied universally. 
In  addition,  as  environments  become  increasingly  more  interconnected  and 
devices like power supplies and air conditioners are networked right alongside desktop 
PC
s, servers, and cell phones, the need for a common way to transmit management 
data becomes critical. This requirement is driving work on new management-oriented 
protocols like 
WS-M
an that build on top of established, standard Internet protocols.
Collectively, these common models and protocols lay the groundwork for creating 
effective cross-platform management solutions for the modern, heterogeneous, dis-
tributed IT infrastructure.
NOTE
At one point in the early 2000s, it looked like there was a 
movement away from standard management technologies like 
WMI
People were going around saying things like “
WMI
is dead.” In fact, 
this turns out not to be the case at all, and we’re seeing increasing inter-
est in 
CIM
and related standards. 
WS-M
an is a major factor in this 
because it provides a tractable, nonproprietary transport mechanism 
for the 
CIM
API
s.
For  example,  the  vPro  technologies  available  in  some  Intel  motherboards  allow 
remote management of computer features, independent of the installed 
OS
.
Now that you have an understanding of why standard management technologies 
like 
WMI
and 
WS-M
an are important, let’s see how all this works.
19.1.1
Exploring WMI
If you’re a Windows system administrator or Windows Server applications developer, 
WMI
should  already be  familiar to you. If you’re  not  a Windows  administrator, 
chances are good (at least until recently) that you’ve never heard of it, which is too 
bad. 
WMI
is one of the best not-so-secret technologies that the industry has to offer, 
both for users and for developers. But if it’s so wonderful, why don’t you hear more 
about it? Well, in part, because it has historically suffered from the “one-telephone” 
syndrome: there’s no point in owning a telephone if there’s no one to call. For exam-
ple, prior to PowerShell, the only way you could use 
WMI
was to write a program in
W
ORKING
WITH
WMI 
IN
P
OWER
S
HELL
799
C++, write a script in 
VBS
cript, or use the 
WMI
command-line tool (
WMIC
, a sort of 
limited precursor to PowerShell). Unfortunately, all of these solutions made even the 
simplest use of 
WMI
fairly complex for a nonprogrammer. With the advent of things 
like PowerShell, 
WMI
becomes a convenient command-line tool for everyday users, 
as you’ll see.
Let’s talk about what 
WMI
actually is. To quickly refresh your acronym knowl-
edge, 
WMI
stands for Windows Management Instrumentation, which is Microsoft’s 
implementation of the Distributed Management Task Force 
(DMTF)
CIM
CIM
is, 
in turn, an industry standard for an object model used to encapsulate the managed 
elements in a system. The 
DMTF
website (www.dmtf.org) describes 
CIM
in the fol-
lowing way:
CIM provides a  common definition of management  information  for 
systems,  networks,  applications,  and  services,  and  allows  for  vendor 
extensions. 
CIM
’s  common  definitions  enable  vendors  to  exchange 
semantically rich management information between systems throughout 
the network.
That’s a very erudite if somewhat abstract definition. What it really means is that 
there are “standard” ways of wrapping up bits of management data in a well-defined 
standard package so you can work with this data across different vendors and envi-
ronments in a consistent, standard way. For example, 
CIM
defines a “class” called 
CIM_Process
that abstracts out the details of what a process looks like on any given 
system. This means that, when encapsulated using this 
CIM_Process
class or model, 
a process object on Windows, Solaris, Linux, or even a smartphone 
OS
has the same 
basic set of properties and methods. Thus if you need to find out the 
ID
of a process, 
CIM_Process
defines a standard property 
ProcessID
for accessing this information. 
Similarly, if you need to stop this process, you can call the 
CIM_Process.Termi-
nate()
method, and the underlying 
CIM
implementation will map (or adapt) this 
call into the necessary system-specific 
API
call. 
To support environment-specific extensions, 
CIM
also allows vendors to create 
derived classes of the 
CIM
base classes that can surface nonstandard features as a set of 
extensions while still preserving the common base characteristics of the model. The 
goal of all of this is to make it easier to create system administration tools (and, by 
corollary, system administrators) that can work effectively in heterogeneous environ-
ments. In the next section, we’ll look at how the 
CIM/WMI
infrastructure facilitates 
these goals.
19.1.2
The WMI infrastructure
The core of 
WMI
is a Windows service that hosts the components of the 
WMI
infra-
structure.  These  components  include  the 
WMI/CIM
Object Manager, commonly 
called a 
CIMOM
, a repository for 
CIM/WMI
object instances, and a set of providers 
that provide the adaptation layer between  concrete system resources the standard
Documents you may be interested
Documents you may be interested