c# pdf viewer itextsharp : Reorder pages in pdf reader control software platform web page windows html web browser Windows%20Powershell%20in%20Action%202nd%20Edition86-part1545

830
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
It’s  a 
[System.Management.ManagementPath]
object, which you can then cast 
back into the corresponding drive instance object, per the earlier discussion of the 
WMI
type accelerators:
PS (18) > $d = [wmi] "$result" 
PS (19) > $d
DeviceID     : C:
DriveType    : 3 
ProviderName : 
FreeSpace    : 95328575488 
Size         : 241447768064 
VolumeName   : PowerShellRocks
Now you have a new instance of the logical disk object.
This example illustrates the basic approach for using PowerShell to modify system 
settings through the 
WMI
object adapter. First, you retrieve the object, then make the 
necessary updates, and finally use 
Put()
to put it back. Because this is an unfortunate 
but necessary departure from the behavior of the other types of objects, it’s important 
to be aware of it. It’s also important to note that 
Set-WmiInstance
doesn’t suffer 
from this limitation. A set of properties is specified at once using the hashtable, so 
there’s no need for a separate 
Put()
operation.
This completes our coverage of using 
WMI
from PowerShell. With this founda-
tion, it should be possible for you to adapt existing 
WMI
samples and resources in 
your work with PowerShell. That said, 
WMI
is rich and deep and there’s no way to 
cover all the details in a single chapter, so additional exploration is recommended to 
truly master the technology. You can find a great deal of information about 
WMI 
available online at http://technet.microsoft.com ; it’s a good place to start growing 
your knowledge.
In the next section, we’ll investigate a related technology, 
WS-M
an, that builds on 
what you know about 
CIM
and 
WMI
objects. 
WS-M
an allows you to perform the 
same types of operations that you did through 
WMI
using standard internet and web 
protocols instead of 
DCOM
. The use of more broadly supported protocols greatly 
expands the reach of the 
CIM
model.
19.4
E
XPLORING
WS-M
AN
In chapter 13 we introduced 
WS-M
an (Web Services for Management) in the context 
of PowerShell remoting, where  it’s used  as a  transport  layer for  PowerShell com-
mands. What it also does (among other things) is provide an alternative transport 
layer for 
CIM/WMI
. A major limiting factor for 
WMI
as far as interoperability goes is 
that, whereas the object model is platform agnostic, the communications layer used 
to talk to the object manager is not because 
WMI
uses the Microsoft-proprietary 
DCOM
protocol.
Reorder pages in pdf reader - 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 rearrange pages in pdf using reader; pdf reverse page order
Reorder pages in pdf 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 pdf document; how to move pages in pdf
E
XPLORING
WS-M
AN
831
NOTE
In practice, there are a number of non-Microsoft implementa-
tions of 
DCOM
. For example, the Open Group (the merger of 
X/O
pen 
and 
OSF
) has an open source implementation of 
DCOM
called 
COM-
S
ource. These implementations haven’t seen significant uptake in the 
industry, though.
Obviously, a single-vendor protocol isn’t very useful if the goal is to foster interopera-
bility between different systems. To address this, in 2004 the 
DMTF
released a new 
standard, “Document 
DSP
0226: Web Services for Management (
WS-M
anagement) 
Specification,” which was created  through the  joint  efforts of 
AMD
 Dell, Intel, 
Microsoft, and Sun Microsystems. (Since then, many additional companies, includ-
ing Oracle, Symantec, 
BEA
, and Hitachi, have joined this effort.) This protocol was 
based on widely adopted standards like web services and 
HTTP
, giving it a much 
higher chance for success. Although it’s still early in the adoption cycle, it does seem 
to be getting the necessary traction to succeed.
Staring with Windows Vista and Windows Server 2008, Microsoft began including 
an implementation of 
WS-M
an with the operating system. In the Windows 7/Server 
2008 R2 operating system releases, the implementation was substantially updated and 
support for 
WS-M
an was added to PowerShell to allow access to 
CIM
over 
WS-M
an. In 
the next section, we’ll examine the cmdlets that were added to enable this access.
NOTE
Given  the  limitations  of  the 
WS-M
an  implementation  as 
released with PowerShell v2, it should probably not be your default 
choice when trying to solve a problem. In almost all cases, 
WMI
is still 
the better (i.e., faster and easier) choice. The key scenarios where you’d 
need 
WS-M
an are either when the target doesn’t support 
WMI
(most 
non-Windows systems) or when network/firewall issues exist that you 
need to deal with. This is because 
WS-M
an builds on top of 
HTTP
, and 
it’s more “firewall friendly” than 
WMI/DCOM
.
19.4.1
The WS-Man cmdlets
The cmdlets included with PowerShell for managing a system through 
WS-M
an are 
shown in table 19.4. Although the names of these cmdlets parallel the names of the 
WMI
cmdlets quite closely, as shown in the table, there are some annoying differences 
in their behavior. These differences will be pointed out as we encounter them. 
Table 19.4 The WS-Man cmdlets
WS-Man cmdlet
Description
WMI equivalent
Get-WSManInstance
Retrieves an instance of an object through 
the WS-Man service on the target machine.
Get-WmiObject
Set-WSManInstance
Creates an object using the specified WS-
Man resource.
Set-WmiInstance
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.
reorder pdf pages; how to move pages in pdf files
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
change pdf page order; reorder pages of pdf
832
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
In the following sections we’ll go over each of these cmdlets, introducing 
WS-M
an con-
cepts as we go as well as contrasting how these cmdlets work with the 
WMI
cmdlets.
19.4.2
Using Get-WSManInstance to retrieve management data 
The first cmdlet we’ll work with is 
Get-WSManInstance
. The signature for this cmd-
let is shown in figure 19.8.
In figure 19.8, you see that there are a large number of parameters related to con-
nections. These are basically the same parameters that you saw on the PowerShell 
remoting commands in section 13.1.5. This should be no surprise because remoting 
is built on top of 
WS-M
an. 
Let’s look at using 
Get-WSManInstance
to retrieve a 
WMI
class. We’ll do the par-
allel operation using the 
WMI
cmdlets to highlight the similarities (and differences) 
between the two. We’ll start with a 
WMI
example and then see what the equivalent 
WS-M
an cmdlet looks like. Our example query will be to retrieve information about 
the  target  machine’s  operating  system  using  the 
Win32_OperatingSystem
class. 
We’ll limit the amount of information displayed by passing a list of properties to dis-
play to the 
Format-List
cmdlet. 
Start by putting these property names into a variable so you can reuse them later:
PS (1) > $properties = "Caption", "OSArchitecture","Version", 
>>   "WindowsDirectory" 
>>
Now, call the 
Get-WmiObject
cmdlet and the specified properties as a list:
PS (2) > Get-WmiObject Win32_OperatingSystem | 
>>       Format-List $properties 
>>
Caption          : Microsoftr Windows VistaT Home Premium 
OSArchitecture   : 64-bit
Invoke-WSManAction
Invokes a method on the object on the target 
machine.
Invoke-WmiMethod
Remove-WSManInstance
Removes an object using the specified WS-
Man resource.
Remove-WmiObject
New-WSManInstance
Creates a new WS-Man resource. Note: 
Although the client side of the protocol is 
complete, the Windows 7 release of the WS-
Man server component doesn’t support 
instance creation except for managing some 
aspects of the WS-Man service itself. This 
cmdlet will, however, allow instances to be 
created in non-Windows WS-Man implemen-
tations if the operation is supported.
None
Table 19.4 The WS-Man cmdlets (continued)
WS-Man cmdlet
Description
WMI equivalent
Read PDF in Web Image Viewer| Online Tutorials
Extract images from PDF documents; Add, reorder pages in PDF files; Save and print Document Viewer, make sure that you have install RasterEdge PDF Reader Add-on
reorder pages in pdf; how to reorder pdf pages in
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
move pdf pages online; how to move pages in a pdf file
E
XPLORING
WS-M
AN
833
Version          : 6.0.6002
WindowsDirectory : C:\Windows
This output shows that the target computer is running Windows Vista 64-bit version
6.0.6002, installed in 
C:\W
indows. In this command, you relied on positional param-
eters and the default namespace to shorten the command. Write it with the parameter 
names included and the namespace explicitly spelled out:
PS (3) > Get-WmiObject -Namespace root\cimv2 ` 
>>   -Class Win32_OperatingSystem | 
>>     Format-List $properties 
>>
Caption          : Microsoftr Windows VistaT Home Premium 
OSArchitecture   : 64-bit 
Version          : 6.0.6002 
WindowsDirectory : C:\Windows
It’s a bit longer to write, but the results are the same. In the next section, you’ll con-
vert the 
WMI
command to a 
WS-M
an command. The first change you need to make 
is that, instead of specifying the namespace and class name separately, you using a sin-
gle resource 
URI
that includes both parts.
Get-WSManInstance 
[-ResourceURI] <Uri>
[-SelectorSet <Hashtable>]
[-Fragment <String>]
-Enumerate
[-ReturnType <String>]
[-Filter <String>]
[-Shallow]
[-ConnectionURI <Uri>] 
[-ApplicationName <String>]
[-ComputerName <String>]
[-Authentication <AuthenticationMechanism>]
[-SessionOption <SessionOption>]
[-CertificateThumbprint <String>] 
[-Credential <PSCredential>] 
[-OptionSet <Hashtable>] 
[-Dialect <Uri>] 
[-Port <Int32>] 
[-UseSSL]
Select target object
using its URI 
WebService application
name to use
Auth mechanism
to use
Target computer
Hashtable of key property
values to select object on
XML fragment for
specific property
Get collection of
instances of this class
Query used to filter
objects that are returned
Return type to use
Do shallow enumeration
Arguments to
method call
Transmit encrypted using
secure sockets layer
Port on target computer
to connect to
Hashtable of
option/value pairs 
Credentials to
connect with
Session options
Used to identify
certificate
Query language
dialect to use 
(WQL, CQL, etc.)
Instance
parameter set
Enumerate
parameter set
Figure 19.8 The 
Get-WSManInstance
cmdlet is used to retrieve management 
object instances from the target computer. It can either retrieve a specific instance 
of a class or enumerate all instances of that class with optional filtering.
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
reorder pdf pages reader; reorder pages in pdf reader
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.
pdf reverse page order online; pdf change page order online
834
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
Targeting WS-Man resources using URIs
In 
WS-M
an, resources (classes) are accessed using a 
URI
(Uniform Resource Identi-
fier) that corresponds to the 
WMI
path for the equivalent resource. If the path for a 
class in 
WMI
is of the form
\\root\
<
namespace
>
\
<
class
>
then the corresponding 
URI
for a resource in 
WS-M
an is
http://schemas.microsoft.com/wbem/wsman/1/wmi/root/
<
namespace
>
/
<
class
>
As a concession to usability, the 
WS-M
an cmdlets allow you to use 
URI
aliases instead 
of returning the full resource 
URI
every time. The supported 
WS-M
an aliases and cor-
responding resource 
URI
s they substitute for are shown in table 19.5.
Another point to be aware of is that 
WS-M
an 
URIs
require that forward slashes be used. 
Using a backslash will result in an error. With an understanding of how to address a 
resource, let’s return to our original task of retrieving the 
Win32_OperatingSystem 
resource.
Getting the Win32_OperatingSystem resource
The 
WMI
path  for  the  class  you’re  targeting  is  \\root\cimv2\Win32_Operating-
System,  so  the 
WS-M
an 
URI
you’ll  use  is  wmicimv2/Win32_OperatingSystem, 
which is equivalent to
http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2
Now you’re ready to run the command, which produces the following results:
PS (4) > Get-WSManInstance ` 
>>   -ResourceURI wmicimv2/Win32_OperatingSystem | 
>>     Format-List $properties 
>>
Caption          : Microsoftr Windows VistaT Home Premium 
OSArchitecture   : 64-bit 
Version          : 6.0.6002 
WindowsDirectory : C:\Windows
From the output, it appears the results are identical to what you got from the 
WMI 
command. When you dig in a bit further, you’ll see that that isn’t exactly true.
Table 19.5 The WS-Man URI aliases
WS-Man alias
Resource URI
Wmi
http://schemas.microsoft.com/wbem/wsman/1/wmi
wmicimv2
http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2
cmv2
http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2
Winrm
http://schemas.microsoft.com/wbem/wsman/1
Wsman
http://schemas.microsoft.com/wbem/wsman/1
Shell
http://schemas.microsoft.com/wbem/wsman/1/windows/shell
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 within a pdf; how to change page order in pdf document
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
rearrange pdf pages; how to reorder pages in pdf file
E
XPLORING
WS-M
AN
835
Let’s see the object types returned by the cmdlets as well as the methods defined 
on those objects. Rerun the two commands, piping the output into 
Get-Member
First, the 
WMI
command:
PS (5) > Get-WmiObject -Namespace root\cimv2 ` 
>>   -Class Win32_OperatingSystem | 
>>     Get-Member -MemberType method 
>>
TypeName: System.Management.ManagementObject#root\cimv2\Win32_Oper 
atingSystem
Name                 MemberType Definition 
----                 ---------- ----------
Reboot               Method     System.Management.ManagementBaseOb... 
SetDateTime          Method     System.Management.ManagementBaseOb... 
Shutdown             Method     System.Management.ManagementBaseOb... 
Win32Shutdown        Method     System.Management.ManagementBaseOb... 
Win32ShutdownTracker Method     System.Management.ManagementBaseOb...
And then the 
WS-M
an command:
PS (6) > Get-WSManInstance ` 
>>   -ResourceURI wmicimv2/Win32_OperatingSystem | 
>>     Get-Member -MemberType method 
>>
TypeName: System.Xml.XmlElement#http://schemas.microsoft.com/wbem/ 
wsman/1/wmi/root/cimv2/Win32_OperatingSystem#Win32_OperatingSystem
Name                 MemberType Definition 
----                 ---------- ----------
AppendChild          Method     System.Xml.XmlNode AppendChild(Sys... 
Clone                Method     System.Xml.XmlNode Clone()
CloneNode            Method     System.Xml.XmlNode CloneNode(bool ... 
CreateNavigator      Method     System.Xml.XPath.XPathNavigator Cr... 
Equals               Method     bool Equals(System.Object obj) 
:
In the 
WMI
case, you get back a “live” 
ManagementObject
, which has methods that 
can be used to manipulate that object. In the 
WS-M
an case, what you get back is a 
“dead” 
XML
document that contains a representation of that data. This is conceptu-
ally similar to the way PowerShell remoting returns “dead” 
PSObjects
; however, the 
actual 
XML
representations are completely different. The first part of the returned 
XML
(which is in the 
OuterXML
property) looks like this:
<p:Win32_OperatingSystem xmlns:xsi = "http://www.w3.org/2001/XMLSchem 
a-instance" xmlns:p = "http://schemas.microsoft.com/wbem/wsman/1/wmi/ 
root/cimv2/Win32_OperatingSystem" xmlns:cim = "http://schemas.dmtf.or 
g/wbem/wscim/1/common" xsi:type = "p:Win32_OperatingSystem_Type" xml: 
lang = "en-US" >
<p:BootDevice>
\Device\HarddiskVolume1
</p:BootDevice>
836
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
<p:BuildNumber>
6002
</p:BuildNumber>
<p:BuildType>
Multiprocessor Free
</p:BuildType>
<p:Caption>
Microsoftr Windows VistaT Home Premium
</p:Caption>
<p:CodeSet>
1252
</p:CodeSet>
<p:CountryCode>
1
</p:CountryCode> 
:
Given that you only get back data, you’ll have to use the 
Invoke-WSManAction
to 
call methods on the object. We’ll get to that in a minute. First, let’s talk about getting 
enumeration compared to getting an instance.
Singleton resources vs. enumerations
For classes like 
Win32_OperatingSystem
that are singletons (i.e., there’s only ever a 
single instance), enumeration versus instance doesn’t matter. There’s only a single 
object to retrieve; hence, it’s called a singleton. There are, however, many classes that 
have a collection of instances like 
Win32_Process
. If you try to access this class the 
way you did 
Win32_OperatingSystem
, you’ll get an error:
PS (7) > Get-WSManInstance -ResourceURI wmicimv2/Win32_Process 
Get-WSManInstance : <f:WSManFault xmlns:f="http://schemas.microsoft.com/
wbem/wsman/1/wsmanfault" Code="2150859002" 
Machine="localhost"><f:Message><f:ProviderFault provider="WMI 
Provider" 
path="%systemroot%\system32\WsmWmiPl.dll"><f:WSManFault 
xmlns:f="http://schemas.microsoft.com/wbem/wsman/1/wsmanfault" 
Code="2150859002" Machine="brucepayquad"><f:Message>The WinRM 
client cannot process the request. The resource URI is not 
valid: it does not contain keys, but the class selected is not 
a singleton. To access an instance which is not a singleton, 
keys must be provided. Use the following command to get more 
information in how to construct a resource URI: "winrm help 
uris". </f:Message></f:WSManFault></f:ProviderFault></ 
f:Message></f:WSManFault>
At line:1 char:18 
+ Get-WSManInstance <<<<  -ResourceURI wmicimv2/Win32_Process
+ CategoryInfo          : InvalidOperation: (wmicimv2/
Win32_Process:Uri) [Get-WSManInstance], 
InvalidOperationException
+ FullyQualifiedErrorId : WsManError,Microsoft.WSMan.Management.
GetWSManInstanceCommand
E
XPLORING
WS-M
AN
837
This (rather long) error message is an 
XML
document that has a number of signifi-
cant pieces of information. Let’s use the 
Format-XmlDocument
function from section
16.4.3 to make it a bit more readable:
PS (8) > Format-XmlDocument -string ($error[0].Exception.Message) 
<f:WSManFault xmlns:f = "http://schemas.microsoft.com/wbem/wsman/1/ws 
manfault" Code = "2150859002" Machine = "localhost" >
<f:Message>
<f:ProviderFault provider = "WMI Provider" path = "%systemroot%\s 
ystem32\WsmWmiPl.dll" >
<f:WSManFault xmlns:f = "http://schemas.microsoft.com/wbem/wsma 
n/1/wsmanfault" Code = "2150859002" Machine = "brucepayquad" >
<f:Message>
The WinRM client cannot process the request. The resource U 
RI is not valid: it does not contain keys, but the class selected is 
not a singleton. To access an instance which is not a singleton, keys
must be provided. Use the following command to get more information 
in how to construct a resource URI: "winrm help uris".
</f:Message>
</f:WSManFault>
</f:ProviderFault>
</f:Message> 
</f:WSManFault>
First, it lets you know that the class isn’t a singleton. It then mentions using keys to get 
a singleton instance. It also mentions using the command 
winrm help uris
to get 
help on specifying 
URI
s. It doesn’t, however, mention using the 
-Enumerate
parame-
ter, but you’ll cleverly intuit that this is what you need to do. Add that parameter to 
the command and try again, filtering the output for brevity’s sake:
PS (8) > Get-WSManInstance -Enumerate ` 
>>   -ResourceURI wmicimv2/Win32_Process | 
>>     select -First 5  | 
>>       Format-Table -AutoSize ProcessID,ParentProcessId,Name 
>>
ProcessId ParentProcessId Name 
--------- --------------- ----
        0               System Idle Process 
        0               System 
496       4               smss.exe 
572       560             csrss.exe 
632       624             csrss.exe
Note that this more closely matches our experience with the 
WMI
commands, which 
enumerate by default.
Filtering enumeration results
As was the case with collections in 
WMI
, you can filter 
WS-M
an enumerations with 
the 
-Filter
parameter. This parameter allows you to specify a 
WQL
predicate to
838
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
subset  the data  that’s  returned.  Let’s  add a  filter  to  the  command  that  retrieves 
Win32_Process
instances. The command using 
WMI
looks like this:
Get-WmiObject -Class Win32_Process -Filter "Name = 'powershell.exe'"
The corresponding command with 
Get-WSmanInstance
is
PS (9) > Get-WSManInstance -Enumerate -ResourceURI wmicimv2/* -Filter @" 
>>   select Name,Handle, ParentProcessId from win32_process 
>>     where name = 'powershell.exe' 
>> "@  | Format-Table -AutoSize Name, Handle, ParentProcessId 
>>
Name           Handle ParentProcessId 
----           ------ ---------------
powershell.exe 6452   2148 
powershell.exe 7632   2148 
powershell.exe 6768   2148
There are a number of differences between the two commands. First, 
-Filter
on the 
Get-WSManInstance
is more closely equivalent to the 
-Query
parameter on 
Get-
WmiObject
:
PS (10) > Get-WmiObject -Query @" 
>>   select Name,Handle, ParentProcessId from win32_process 
>>     where name = 'powershell.exe' 
>> "@ | Format-Table -AutoSize Name, Handle, ParentProcessId 
>>
Name           Handle ParentProcessId 
----           ------ ---------------
powershell.exe 6452              2148 
powershell.exe 7632              2148 
powershell.exe 6768              2148
But unlike the 
Get-WmiObject
case, the 
-ResourceURI
is mandatory. But just to 
make things difficult, you can’t have the class name in the resource 
URI
; it has to be * 
instead.  Unfortunately,  this  means you  can’t  just  add  a  filter  to  an  enumeration 
request. The resource 
URI
also has to be changed. Now let’s switch our focus back to 
getting singleton instances.
Selecting instances
To select a singleton instance from an enumeration, you use the 
-SelectorSet
param-
eter  to  specify  the  key properties for  the target  instance.  This  parameter  takes a 
hashtable containing the keys and values needed to identify the object you want to get.
NOTE
The properties  in  the  selector  set are equivalent  to  the  key 
properties you saw in 
WMI
object paths. There’s one significant differ-
ence: in 
WMI
paths, the case of the key property names doesn’t matter, 
whereas the selector names in 
WS-M
an are case sensitive.
E
XPLORING
WS-M
AN
839
In the case of processes, as you saw with 
Invoke-WmiMethod
, this key is the 
Handle 
property. Let’s try this. First, launch 
calc.exe
, and then use a filter to get its process 
handle:
PS (1) > calc
PS (2) > $o = Get-WSManInstance -Enumerate ` 
>>   -ResourceURI wmicimv2/* -Filter @" 
>>      select Name,Handle from win32_process 
>>      where name = 'calc.exe' 
>> "@ 
>>
PS (3) > $o | Format-Table -AutoSize Name, Handle
Name     Handle 
----     ------
calc.exe 10640
Now you know that the handle you want is available in 
$o.Handle
. Next, get the 
corresponding instance using the selector set:
PS (4) > $target = @{ 
>>   ResourceURI = "wmicimv2/Win32_Process"; 
>>   SelectorSet = @{ Handle = $o.Handle } 
>>  } 
>>
PS (5) > Get-WSManInstance @target | Format-Table -AutoSize Name, 
Handle
Name     Handle 
----     ------
calc.exe 10640
This is a rather awkward way to target a specific object. You can make it easier by tak-
ing advantage of splatting (see section 5.8.4). You’ll construct a hashtable of properties 
that will target the specific instance:
PS (4) > $target = @{ 
>>   ResourceURI = "wmicimv2/Win32_Process"; 
>>   SelectorSet = @{ Handle = $o.Handle } 
>>  } 
>>
You can use this hashtable to target the instance you want:
PS (5) > Get-WSManInstance @target | 
>> Format-Table -AutoSize Name, Handle
Name     Handle 
----     ------
calc.exe 10640
With the ability to identify an instance, you can move on to the next section, where 
you’ll see how to update an object’s properties through 
WS-M
an.
Documents you may be interested
Documents you may be interested