/\/\o\/\/ PowerShelled

---

WMI help Part 3 (Methods)

---

---

w.b

After getting all the WMI-classes in Wmi-Help Part 1
and getting the properties and Methods of a Single Class in WMI help Part 2

we are now ready to look a bit deeper into the Methods,

Again I made this into a function, , I did go a bit into Part 4 the execution already by generating a Template Script, but the plan for part 4 is to Bind the Method Execution to a WMI-instance. (using TypeData) as for the non-Static WMI Methods you need an Instance. (also explained later).

the Function can be Used like this :

MSH> gwm win32_share Create

First It shows you the In-parameters of the Method, and then a Sample script.
the sample script will be different depending upon the type of Method Static or non-Static.

I won't show all the output, but to show the difference between a Static and a not Static Method I will Show 2 Generated Scripts in the output after the Descriptions.

First a Static Method (gwm win32_share Create ), You need to fill in the Inparams into the Template :

# win32_share Create-Method Sample Script
# Created by Get-WmiMethodHelp
# /\/\o\/\/ 2005
# Fill InParams values before Executing
# InParams that are Remarked (#) are Optional

$Class = "win32_share"
$Method = "Create"
$MP = new-object system.management.ManagementPath
$MP.Server = "."
$MP.NamespacePath = "root\cimv2"
$MP.ClassName = $Class

$MC = new-object system.management.ManagementClass($MP)
$InParams = $mc.GetMethodParameters($Method)

# $InParams["Access"] = [object:Win32_SecurityDescriptor]
# $InParams["Description"] = [string]
# $InParams["MaximumAllowed"] = [uint32]
$InParams["Name"] = [string]
# $InParams["Password"] = [string]
$InParams["Path"] = [string]
$InParams["Type"] = [uint32]

"Calling win32_share : Create "

$R = $mc.InvokeMethod($Method,$Inparams,$Null)
"Result : "
$R

and Now the Delete Function, a Method that needs an instance (gwm win32_share Delete ),
as you can see This makes an Extra Variable $Name, this is the Key Property of the win32_share Class (automagicly the right property), that must be filled in before running the script, to build the Filter.
as the Delete Method takes no Parameters, the $inparms are not used (the line $inparms line is not needed in this Case but I wrote it to early in the Script.

# win32_share delete-Method Sample Script
# Created by Get-WmiMethodHelp
# /\/\o\/\/ 2005
# Fill InParams values before Executing
# InParams that are Remarked (#) are Optional

$Class = "win32_share"
$Method = "delete"
$Name = [string]

$filter = "Name = '$Name'"
$MC = get-WMIObject $class -filter $filter

$InParams = $mc.GetMethodParameters($Method)

"Calling win32_share : delete "

$R = $mc.InvokeMethod($Method,$Null)
"Result : "
$R

Now that we have seen wat it does, let's walk trough the code :

first you may notice the "if ($True){}"-blocks (as they resolve alway's TRUE, this may seem a bit useless), I use them to provide a different Trap for different blocks of Code, I did not find a way to do that outside of an IF-block.

next we get a # set options block that must look familiar if you did read the former posts.
Yes, we want Descriptions again, And this time we need some more Qualifiers, as we see later.

Next we make a ManagementScope ($MS) we don't realy need this as we are connecting to the Local Computer, but I use this later to Create a MangementPath used to generate a part of the Sample script to make it easy to change Computer.

And make a ManagementClass with the Options we created.(in the IF($true)-block to trap the error, if the Class does not exists)

In the Next block, we create a StringBuilder for creating a Template script, as we append to this template-script alot during the script, this is more efficient as a String as a string get's copied to a new string in .NET every time you change it.

Next the is an interesting check in the script, the check if the Method has a Static qualifier,
If the Method does not have one, it Needs an Instance to act upon.
Again I user a Trap here because if a Method is not Static the porperty is not FALSE but just not there.

As our Template script should be different depending on if the Method is Static (If not we need to get an Instance), I generate a different piece of code to put in the Stringbuilder($SB), depending on the type of the Method.If the Script is not Static I get the Key properties of the WMI-class to build the $Filter-String used in the Template Script to select the Instance.

Next interesting line in the script is this :

$inParam = $mc.Get_Methods()[$WMIMethod].get_InParameters()

This will get us the In Parameters of the Method. so we have an easy way to provide them to the Method.

in the next forEach-loop we wil check the Inparameters for the Following interesting Qualifiers next to the Description Qualifier :

$Optional = $_.get_Qualifiers()["Optional"].Value
$CIMType = $_.get_Qualifiers()["Cimtype"].Value

As the Optional qualifier, same as the Static Qualifier is not there if the property is not Optional, we will Trap the getting of the $Optional Qualifier.

Also Interesting here is the Following 2 Lines :

if ($Optional -eq $TRUE) {[void]$SB.Append('# ')}
[void]$SB.Append('$InParams["');[void]$SB.Append("$($_.Name)`"] = ");[void]$SB.AppendLine("[$CIMType]")

this Will write a Line in the SampleScript for Every Parameter in the Inparams of the Method, But Will Remark it when the Property is Optional, also it Will put the CIMType in the Line, so when filling in the Template we see what to fill in.


Next we have Another If Block:

If ($HasParams -eq $False)

this is because we need a different overload in the script if we have no Inparms.
(I leave the GetInparams function in the script as I did write it already more early in the script, but it is not needed in the Sample-Script if the Method has no parameters.)

At the End of the Script We use the $SB.ToString Method to write the Generated Script.

that was it, the error catching on the Qualifiers and the generating of the Sample Script, does make this script a bit more difficult to read then the former scripts, but i think is a nice start to build scripts for executing Methods.

gr /\/\o\/\/

*Edit* As I edited this Post the Pipeline Signs will be gone, but I posted an Update of the script here : MSH get-WmiMethodHelp (GWM) Update + format tips.

And the Complete Script :

---