c# pdf viewer itextsharp : Reorder pages in pdf online software control project winforms web page html UWP Windows%20Powershell%20in%20Action%202nd%20Edition84-part1543

810
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
information received for a specific class. The classes we’ve looked at so far returned 
only a small amount of data. There are, however, many classes that return potentially 
very large datasets. You could filter  them using the 
Select-Object
and 
Where-
Object
cmdlets as you’ve been doing all along, but remember, you may be executing 
the operation on a remote computer. For remote operations, retrieving a lot of data 
can have serious performance implications. To mitigate this, 
WMI
has a built-in way 
to filter the data being returned at the source instead of at the receiver’s end. This 
mechanism is available to the PowerShell user through the 
-Filter
and 
-Query 
parameter sets. In the next section, you’ll see how to use these parameters to manage 
the amount of data you have to deal with.
Selecting WMI object instances using filters and queries
The syntax for 
Get-WmiObject
in figure 19.2 mentioned two parameters that we 
haven’t talked about yet: 
-Filter
and 
-Query
. These parameters allow you to lever-
age the intrinsic filtering capabilities built into 
WMI
, allowing you to control how 
much data is returned from the target.
As part of the overall 
CIM
infrastructure, the environment includes a native query 
language called 
WQL
(
WMI
Q
uery 
L
anguage). This is a 
SQL
-like language (remem-
ber that database hint earlier?) that’s used to select data from a 
WMI
class or enumer-
ation. The 
-Filter
and 
-Query
parameters both make use of this query language, 
although in slightly different ways. Let’s look at the 
-Filter
parameter first.
The -Filter parameter
The 
-Filter
parameter takes a string as an argument that contains a predicate expres-
sion defined using a subset of the overall 
WQL
language. By predicate expression, we 
mean an expression that has things like comparisons and logical operators (
AND
s, 
OR
s). Whether or not a value is returned from the collection is predicated on this 
expression returning 
TRUE
(hence, predicate expression). The 
WQL
operators that can 
be used in these expressions are shown in table 19.3.
Table 19.3 The WQL operators that can be used in the -Filter parameter
WQL operator
PowerShell 
operator
Operator description
=
-eq
Equal to.
<
-lt
Less than.
>
-gt
Greater than.
<=
-le
Less than or equal to.
>=
-ge
Greater than or equal to.
!=  or <>
-ne
Not equal to.
AND
-and
“ANDs” two Boolean expressions and returns TRUE when both 
expressions are true, equivalent to -and in PowerShell.
Reorder pages in pdf online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
move pdf pages online; move pages in pdf document
Reorder pages in pdf 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 pdf page; move pages in a pdf
T
HE
WMI 
CMDLETS
811
Let’s look at an example of filter expressions. You’ll rework the 
Win32_Network-
AdapterConfiguration
but this time use the 
-Filter
parameter instead of the 
Where-Object
cmdlet to do the filtering:
PS (1) > Get-WmiObject Win32_NetworkAdapterConfiguration ` 
>>   -Filter  'DHCPEnabled = TRUE' | 
>>     Format-List Description, IPAddress 
>>
Description : Realtek RTL8168C(P)/8111C(P) Family PCI-E GBE NIC 
IPAddress   : {192.168.0.101, fe80::ec97:2ed7:3203:b22d}
Description : 802.11n Wireless PCI Express Card LAN Adapter 
IPAddress   : {192.168.0.105, fe80::c128:dbf3:3b1:76e0}
In the next example, you’ll use the 
LIKE
operator to match against the 
Description 
string:
PS (2) > Get-WmiObject Win32_NetworkAdapterConfiguration ` 
>>   -Filter 'DHCPEnabled = TRUE AND Description LIKE "%wire%"' | 
>>     Format-List Description, IPAddress 
>>
Description : 802.11n Wireless PCI Express Card LAN Adapter 
IPAddress   : {192.168.0.105, fe80::c128:dbf3:3b1:76e0}
OR
-or
“ORs” two Boolean expressions and returns TRUE if either 
expression is true, equivalent to -or in PowerShell. When more 
than one logical operator is used in a statement, the OR opera-
tors are evaluated after the AND operators.
TRUE
$true
Boolean operator that evaluates to –1.
FALSE
$false
Boolean operator that evaluates to 0.
NULL
$null
Indicates an object doesn’t have an explicitly assigned value. 
NULL isn’t equivalent to 0 or blank.
ISA
-as
Operator that applies a query to the subclasses of a specified 
class.
IS
n/a
Comparison operator used with NOT and NULL. The syntax for 
this statement is the following: IS [NOT] NULL (where NOT is 
optional).
LIKE
-like
Similar to the PowerShell-like operator that does wildcard 
matches except that the wildcard characters are different: % (any 
string), _ (any single character), [ab=z] (match character range, 
^ (don’t match range).
NOT
not
Comparison operator that use in a WQL SELECT query.
__CLASS
n/a
References the class of the object in a query.
Table 19.3 The WQL operators that can be used in the -Filter parameter (continued)
WQL operator
PowerShell 
operator
Operator description
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.
reverse pdf page order online; how to reorder pages in pdf reader
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 reorder pages in pdf online; rearrange pdf pages
812
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
Add the 
NOT
operator to select the nonwireless adapters:
PS (3) > Get-WmiObject Win32_NetworkAdapterConfiguration ` 
>>   -Filter 'DHCPEnabled = TRUE AND NOT (Description LIKE "%wire%")' | 
>>     Format-List Description, IPAddress 
>>
Description : Realtek RTL8168C(P)/8111C(P) Family PCI-E GBE NIC 
IPAddress   : {192.168.0.101, fe80::ec97:2ed7:3203:b22d}
At this point, compare the last 
LIKE
WQL
example to the PowerShell equivalent:
PS (4) > Get-WmiObject Win32_NetworkAdapterConfiguration | 
>>  where {$_.DHCPEnabled -eq $true -and -not 
>>    ($_.Description -like "*wire*")} | 
>>      Format-List Description, IPAddress 
>>
Description : Realtek RTL8168C(P)/8111C(P) Family PCI-E GBE NIC 
IPAddress   : {192.168.0.101, fe80::ec97:2ed7:3203:b22d}
This last example showed you the corresponding PowerShell predicate. This predicate 
can be created from the 
WQL
expression, working element by element to get the 
PowerShell predicate. The resulting PowerShell predicate expression is slightly longer 
than the 
WQL
filter, but if you take advantage of some of the PowerShell features to 
shorten the expression, it turns into
PS (5) > Get-WmiObject Win32_NetworkAdapterConfiguration | 
>>  where {$_.DHCPEnabled -and ($_.Description -notlike "*wire*")} | 
>>      Format-List Description, IPAddress 
>>
Description : Realtek RTL8168C(P)/8111C(P) Family PCI-E GBE NIC 
IPAddress   : {192.168.0.101, fe80::ec97:2ed7:3203:b22d}}
Now for a direct comparison of the predicate expressions:
WQL:           DHCPEnabled = TRUE AND NOT (Description LIKE "%wire%") 
PowerShell: $_.DHCPEnabled -and ($_.Description -notlike "*wire*")
This makes the correspondence very clear. Next, you’ll see how 
-Query
works and 
build on top of this.
Selecting WMI objects using -Query
The 
-Query
parameter takes a complete 
WQL
query instead of just the predicate 
expression. The basic syntax for the 
WQL
SELECT
statement is
SELECT <propertyList> FROM <class> WHERE <predicateExpression>
which is patterned after 
SQL
’s select operation. In this query, the predicate expression 
is what you were passing through the 
-Filter
parameter. Using the predicate from 
the previous example, you can write the equivalent 
WQL
query as follows:
SELECT Description,IPAddress
FROM Win32_NetworkAdapterConfiguration
WHERE DHCPEnabled = TRUE AND NOT (Description LIKE "%wire%")
Read PDF in Web Image Viewer| Online Tutorials
"This online guide content is Out Dated! Extract images from PDF documents; Add, reorder pages in PDF files; Save and print PDF as you wish;
reorder pages of pdf; how to move pages in a pdf document
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize or re-arrange PDF document files using C#.NET code.
move pages in pdf file; change page order pdf
T
HE
WMI 
CMDLETS
813
Now execute this query with 
Get-WmiObject
:
PS {5) > Get-WmiObject -ComputerName brucepaydev01 -Query @' 
>>   SELECT Description,IPAddress 
>>   FROM Win32_NetworkAdapterConfiguration 
>>   WHERE DHCPEnabled = TRUE AND NOT (Description LIKE "%wire%") 
>> '@ 
>>
__GENUS          : 2 
__CLASS          : Win32_NetworkAdapterConfiguration 
__SUPERCLASS     : 
__DYNASTY        : 
__RELPATH        : 
__PROPERTY_COUNT : 2 
__DERIVATION     : {} 
__SERVER         : 
__NAMESPACE      : 
__PATH           : 
Description      : Intel(R) 82566DM-2 Gigabit Network
Connection 
IPAddress        : {157.59.86.40,
fe80::653f:2770:d4e:4ac8,
2001:4898:2b:3:8901:6b57:2cf8:5cb,
2001:4898:2b:3:653f:2770:d4e:4ac8}
This command sends the 
WQL
query to the 
CIMOM
on the remote server, where it’s 
executed and the results returned. The resulting object contains the properties you 
requested along with all of the 
WMI
metaproperties. The fact that the query is exe-
cuted on the remote server is significant. Rather than transferring a large amount of 
data and then filtering it locally, by filtering on the target you can greatly reduce the 
amount of data that must be transmitted.
By now, you should be reasonably comfortable using 
Get-WmiObject
to discover 
WMI
classes and retrieve 
WMI
objects, both locally and remotely. You know how to 
filter the set of objects returned using the 
-Filter
and 
-Query
parameters. These 
parameters allow you to efficiently retrieve a lot of information about the target sys-
tem. This is great for monitoring but not much good for maintenance. To manage 
and maintain a system, you need a way to effect changes on the target system. In the 
next section, you’ll see how to do so using the 
Set-WmiInstance
cmdlet.
19.2.3
The Set-WmiInstance cmdlet
In this section you’ll learn how to update the properties on a 
WMI
object using the 
Set-WmiInstance
cmdlet, shown in figure 19.5.
This cmdlet has the parameters common to all of the 
WMI
cmdlets, such as the 
-Class
and 
-Namespace
parameters you saw on 
Get-WmiObject
. The purpose of 
the  remaining  properties should  be fairly easy  to  intuit.  As  you’d expect from a 
PowerShell cmdlet, the 
-InputObject
parameter allows you to update objects com-
ing from the input pipe. This technique allows the output of 
Get-WmiObject
to be 
piped to 
Set-WmiInstance
. The 
-Arguments
parameter is a hashtable containing
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
reordering pages in pdf; move pages in pdf
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Online C# class source codes enable the ability to rotate single NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
pdf reorder pages; change pdf page order online
814
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
the names of the properties to update and the new values to use. The 
-PutType 
parameter allows you to specify that you only want to create a new object, only want 
to update an existing object, or want to create a new object if there isn’t one and oth-
erwise update the existing instance.
The 
-Path 
parameter is a bit more interesting. It allows you to identify not just the 
class but the actual object you want to update. Earlier in the chapter, we talked about 
how 
WMI
classes are arranged in a hierarchy, like files and directories in the file system, 
and  like files  in  the  file system, classes  in the 
WMI
namespace hierarchy can be 
addressed through a path specification. The interesting thing about 
WMI
paths is that 
you can also target instances of a class. In the next section you’ll see how to do this.
Using WMI paths to target instances
When you retrieve objects from 
WMI
, you expect to get one or more objects depend-
ing on the way you wrote your query. But for updating an object, you need to know 
exactly which  instance to update.  When you work with singleton  objects,  where 
there’s only a single instance, the class name and namespace are enough to uniquely 
identify the target. But for collections (or enumerations) of objects, to do a set opera-
tion you have to identify a specific instance in the collection as the target.
CIM/WMI
solves this problem in an interesting way: each object instance in the 
collection has a unique path. These paths look like
\\<computer>\<namespace>:<class>.<keyproperty>="<value>"
where 
<keyproperty>
is a property that uniquely identifies the instance. In the data-
base world, this would be called the primary key. 
WMI
allows you to see the “instance 
path” for any object returned using 
Get-WmiObject
through the 
__PATH
property on 
that object. Let’s try this with the 
Win32_Service
class. The following command 
will give you the path for the Remote Desktop service instance:
PS (1) > Get-WmiObject -Class Win32_Service ` 
>>  -Filter 'Name = "TermService"' |
Set-WmiInstance 
[-Namespace <string>] 
[-Class] <string> 
[-Path <string>]
[-InputObject <targetObject>]
[[-Arguments] <hashtable>] 
[-PutType <updateonly|createonly|updatecreate>]
Specify target object
by class, by path, or by 
reading from pipeline
Select target object using
its class name 
Get InputObject to
update from pipeline
Select target using path
including keyproperty 
Update/create mode used when
putting object into repository
Property/value pairs to
set on target object
Figure 19.5 The 
Set-WmiInstance
cmdlet allows the user to change the properties on 
an instance of a WMI class.
C# Word: How to Create Word Document Viewer in C#.NET Imaging
Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; (Directly see online document viewer demo here.).
rearrange pdf pages in reader; reorder pages in pdf
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 rearrange pdf pages online; how to rearrange pages in a pdf document
T
HE
WMI 
CMDLETS
815
>>    foreach { $_.__PATH } 
>> 
\\BRUCEPAYX61\root\cimv2:Win32_TerminalService.Name="TermService"
The path string shown in the output from this command includes the computer 
name, namespace, and class. The portion of the path following the dot (.) is the key 
property for this object. For services, this is the 
Name
property. For processes, it’s the 
process 
ID
(or 
Handle
) property.
The key properties for an object are identified by qualifiers on those properties. 
To find the key properties for a class, you use the 
Get-WmiObject
cmdlet to get the 
metadata for a class:
PS (1) > $class = Get-WmiObject -list Win32_Process
Then, from the metadata, you can look at the 
Handle
property on the object:
PS (2) > $p = $class.Properties | where { $_.Name -eq "Handle" } 
PS (3) > $p 
Name       : Handle 
Value      : 
Type       : String 
IsLocal    : False 
IsArray    : False 
Origin     : CIM_Process 
Qualifiers : {CIMTYPE, key, MaxLen, read}
In this output, you see that the property has a 
Qualifiers
attribute. This attribute is 
a dictionary of key-value pairs. Let’s look at the 
key
qualifier for this property:
PS (5) > $p.Qualifiers["key"] | Format-List Name,Value 
Name                 : key 
Value                : True
From this, you can see that the key properties on an object have the 
key
qualifier set to 
TRUE
. This allows you to identify the key properties for a class by running the follow-
ing command:
PS (6) > $class.Properties | 
>>   where { $_.Qualifiers["key"]} | 
>>     Format-Table -AutoSize name, type 
>>
Name     Type 
----     ----
Handle String
It’s also possible for a class to require more than a single property to identify a specific 
instance.  For  example,  the 
Win32_Environment
class has two key properties, as 
shown in the following:
PS (7) > (Get-WmiObject -List Win32_Environment).Properties | 
>>   where { $_.Qualifiers["key"]} | 
>>     Format-Table -AutoSize name, type 
>>
816
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
Name       Type 
----       ----
Name     String 
UserName String
In the next section, you’ll see how to work with objects that have multiple key prop-
erties when you look at setting environment variables using the 
Win32_Environment 
class.
Setting the instance properties
In this section, you’ll apply what you’ve learned about 
WMI
paths to start setting 
object properties. For your experiments, you’ll use the 
Win32_Environment
class 
that allows you to get and set the values in the Registry used to initialize a process’s 
environment table. These settings are stored in the Registry as properties of the key at 
the following path:
PS (1) > $path = 'HKLM:\System\CurrentControlSet\Control\Session 
Manager\Environment'
Before we jump into the 
WMI
examples, you’ll use 
Set-ItemProperty
to create a 
new environment variable property that you can experiment with safely:
PS (2) > Set-ItemProperty -Path $path ` 
>>   -Name 'TestProperty' -Value '3.14' 
>>
Validate that the property was set by calling 
Get-ItemProperty
to retrieve the value:
PS (3) > Get-ItemProperty -Path $path -Name 
TestProperty
PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MA
CHINE\System\CurrentControlSet\Control\Session Ma
nager\Environment 
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MA
CHINE\System\CurrentControlSet\Control\Session Ma
nager 
PSChildName  : Environment 
PSDrive      : HKLM 
PSProvider   : Microsoft.PowerShell.Core\Registry 
TestProperty : 3.14
The output confirms that you’ve created the property with the name 
TestProperty 
and value 3.14. You’re ready to begin your 
WMI
experiments.
The first thing you’re going to do is use the 
Win32_Environment
WMI
class to 
retrieve this property. You’ll use a filter expression to restrict what’s returned to the 
single property you’re interested in:
PS (4) > Get-WmiObject -Class Win32_Environment ` 
>>   -Filter 'Name = "TestProperty"' | 
>>     Format-List Name,VariableValue,__PATH 
>>
T
HE
WMI 
CMDLETS
817
Name          : TestProperty 
VariableValue : 3.14 
__PATH        : \\BRUCEPAYX61\root\cimv2:Win32_Environment.Name=
"TestProperty",UserName="<SYSTEM>"
By doing this, you can discover the 
WMI
path needed to access this object. Notice 
that, in this particular case, the path includes two key fields. Because each user can 
have his or her own instance of a variable 
foo
, you need two keys: the variable name 
and the username, to uniquely identify an environment variable. In the previous out-
put, you can see that you’re targeting a systemwide environment variable.
Save this path in 
$vPath
so you can use it later but with one small modification. 
Instead of having the actual computer name at the top level, use . instead. This indi-
cates that the path applies to the current computer (i.e., localhost):
PS (5) > $vPath = 
>> '\\.\root\cimv2:Win32_Environment.Name="TestProperty",UserName 
="<SYSTEM>"' 
>>
You can use this instance path to update the object. The following command will set 
the 
VariableValue
property of the targeted environment variable to a new value:
PS (6) > Set-WmiInstance -Path $vPath ` 
>>   -Arguments @{VariableValue = "Hello"} 
>>
VariableValue         Name                  UserName 
-------------         ----                  --------
Hello                 TestProperty          <SYSTEM>
The output returned by the command shows the result of the operation. Just to be 
extra careful, also confirm that the operation succeeded by using 
Get-WmiObject
, fil-
tering by name: 
PS (7) > Get-WmiObject -Class Win32_Environment ` 
>>   -Filter 'Name = "TestProperty"' | 
>>     Format-List Name,VariableValue,__PATH 
>>
Name          : TestProperty 
VariableValue : Hello 
__PATH        : \\BRUCEPAYX61\root\cimv2:Win32_Environment.Name=
"TestProperty",UserName="<SYSTEM>"
And you see that the change was, indeed, made.
You can also use 
Set-WmiInstance
to create a new environment variable by 
including the 
Name
and 
UserName
properties in the arguments hashtable. You’ll try 
this  initially by  targeting the 
TestProperty
variable you’ve been working with. 
Because you’re attempting to create a new instance, you only need to specify the 
machine, namespace, and the class. To shorten the example command a bit, use the
818
CHAPTER 19
M
ANAGEMENT
OBJECTS
: WMI 
AND
WS-MAN
-Class
parameter and allow the target machine and namespace to default to 
local-
host
and 
cimv2
, respectively. Give it a try:
PS (8) > Set-WmiInstance -Class win32_environment ` 
>>   -Arguments @{ 
>>     Name="TestProperty" 
>>     VariableValue="Bye!" 
>>     UserName="<SYSTEM>" 
>>   } 
>>
Set-WmiInstance : Object or property already exists 
At line:1 char:16 
+ Set-WmiInstance <<<<  -Class win32_environment `
+ CategoryInfo          : InvalidOperation: (:) [Set-WmiIns
tance], ManagementException
+ FullyQualifiedErrorId : SetWMIManagementException,Microso
ft.PowerShell.Commands.SetWmiInstance
This command failed because the target object already existed. Change the name of 
the instance to create to 
TestProperty2
and try it again:
PS (9) > Set-WmiInstance -Class win32_environment ` 
>>   -Arguments @{ 
>>     Name="TestProperty2" 
>>     VariableValue="Bye!" 
>>     UserName="<SYSTEM>" 
>>   } | Format-List Name,VariableValue,__PATH 
>>
Name          : TestProperty2 
VariableValue : Bye! 
__PATH        : \\BRUCEPAYX61\root\cimv2:Win32_Environment.Name=
"TestProperty2",UserName="<SYSTEM>"
This time the command succeeded in creating the new object. 
Because of the predictable nature of environment variable names, you can easily 
figure out what the 
WMI
instance path for any environment variable will be. Given 
that you can specify the path for a variable even if it doesn’t exist yet, you might think 
that you could use this path with 
Set-WmiInstance
to create the target instance. 
Let’s try it. The following would be the path to an environment variable named 
tp2
PS (10) > $v2Path = 
>> '\\.\root\cimv2:Win32_Environment.Name="tp2",UserName="<SYSTEM>"' 
>>
Pass this path to 
Set-WmiInstance
and see what happens:
PS (11) > Set-WmiInstance -Path $v2Path ` 
>>   -Arguments @{VariableValue = "Hello"} 
>>
Set-WmiInstance : Invalid parameter 
At line:1 char:16 
+ Set-WmiInstance <<<<  -Path $v2Path `
+ CategoryInfo          : InvalidOperation: (:) [Set-WmiIns
tance], ManagementException
T
HE
WMI 
CMDLETS
819
+ FullyQualifiedErrorId : SetWMIManagementException,Microso
ft.PowerShell.Commands.SetWmiInstance
The command failed: clearly you can’t use this mechanism to create instances even 
though you have all the information you need. In practice, this makes sense when you 
look at 
WMI
as a whole. For most object types (such as processes), you aren’t able to 
figure out what the instance path will be ahead of time. This means that the set of 
classes where it could work is quite limited.
With 
Get-WmiObject
you’ve seen how to discover classes and retrieve instance. 
With 
Set-WmiInstance
, you know how to update existing objects and create new 
instances. Our next topic is method invocation. Like .
NET
and 
COM
objects, 
WMI 
objects have methods. You’ll see how to invoke these methods in the next section.
19.2.4
The Invoke-WmiMethod cmdlet
In this section you’ll learn how to invoke methods on 
WMI
classes and instances by 
using the 
Invoke-WmiMethod
cmdlet. In addition to the common 
WMI
cmdlet 
parameters, the parameters specific to this command are shown in figure 19.6.
Like .
NET
classes (see section 5.5), 
WMI
classes can have both static or class mem-
bers and object or instance members. Static methods are the easier of the two types to 
call because you just need the class name, method name, and arguments to call. 
Instance methods are more complex because you need to specify additional informa-
tion to identify which instance of the target class to invoke the method on. (This is 
the same issue you had when using 
Set-WmiInstance
.)
Calling a static method
As  our test case  for static  methods, let’s use the static 
Create()
method on the 
Win32_Process
class to create an instance of (i.e., start) a process—in this case, 
calc.exe
. The command to do this looks like this:
PS (1) > $result = Invoke-WmiMethod Win32_Process ` 
>>   -Name Create -ArgumentList calc 
>>
Invoke-WmiMethod 
[-Namespace <string>] 
[-Class] <string>
[-InputObject] <managementObject>
[-Path] <string> 
[-Name] <string>
[-ArgumentList] <object[]>]
Specify target object by class, by
path, or by reading from pipeline
Select target object
using its class name 
Get target object
from pipeline
Select target object using
path that includes key 
property specification
Method to call
Arguments to method call
Figure 19.6 The 
Invoke-WmiMethod
cmdlet allows the user to invoke a method on 
WMI objects.
Documents you may be interested
Documents you may be interested