{"id":51823,"date":"2009-12-10T00:01:00","date_gmt":"2009-12-10T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/12\/10\/hey-scripting-guy-can-i-call-wmi-methods-more-easily-with-windows-powershell-2-0\/"},"modified":"2009-12-10T00:01:00","modified_gmt":"2009-12-10T00:01:00","slug":"hey-scripting-guy-can-i-call-wmi-methods-more-easily-with-windows-powershell-2-0","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-can-i-call-wmi-methods-more-easily-with-windows-powershell-2-0\/","title":{"rendered":"Hey, Scripting Guy! Can I Call WMI Methods More Easily with Windows PowerShell 2.0?"},"content":{"rendered":"

 \"Bookmark<\/a> <\/p>\n

 <\/p>\n

\"Hey,<\/font><\/p>\n

Hey, Scripting Guy! I enjoy working with WMI, but it can be a bit complicated to make it do anything. It is great at retrieving information, and in conjunction with the Windows PowerShell Get-WMIObject<\/b> cmdlet, it is really easy to obtain lots of information about our servers. In fact, WMI is one of the reasons we are deploying Windows PowerShell 2.0 to all of our 1,000 servers in our server farm. We feel that we will be able to get the ROI from the deployment project in a few months. I just wish it was easier to call the methods. <\/p>\n

— JB<\/p>\n

 <\/p>\n

\"Hey,Hello JB, <\/p>\n

Microsoft Scripting Guy Ed Wilson here. There was frost<\/font><\/a> on my front lawn this morning! Frost is about as close as we get to snow in sunny Charlotte, North Carolina<\/font><\/a>, in the United States. In honor of nearly having a “snow day<\/font><\/a>,” I decided to make one of my favorite morning beverages. I brewed a small pot of espresso<\/font><\/a> using coffee beans from Chanchamayo<\/font><\/a> that I brought back from Peru. The coffee from high up in the Andes Mountains is especially rich and makes a fine espresso. I then heat milk in my double boiler, and as the temperature begins to rise, I take a bar of 85 percent cocoa chocolate and grate it into the milk. As I continue to stir the chocolate milk in the double boiler, I add two tablespoons of pure vanilla extract that I brought back with me from Cozumel, Mexico. While I am doing this, I fill a heavy stone coffee mug with water, and place it in the microwave and heat the water to warm my cup. I then pour the espresso into the heated stone coffee mug, and pour in my hot chocolate. I then grate a quarter of a stick of cinnamon and a little nutmeg to dust the top. It is a great way to start the morning. If you happen to have a slice of fresh baked banana nut bread<\/font><\/a> to go with it, it is even better. <\/span><\/p>\n

JB, with a frosty crisp December morning, a cup of my special mocha<\/font><\/a>, a slice of banana nut bread, and a question about WMI, what more could I ask for? It is going to be a festive day. I will play some Elvis<\/font><\/a> music on my Zune HD. Maybe I will even take the evening off and watch Blue Hawaii<\/font><\/a> tonight. And…maybe not. <\/p>\n

The great thing about using Windows PowerShell 2.0 to work with WMI methods is that it includes the Invoke-WMIMethod<\/b> cmdlet. The Invoke-WMIMethod<\/b> cmdlet makes it easier to call WMI methods, but it still requires an understanding of how WMI works. WMI has two types of methods: static methods, and instance methods. A static method is one that is always available, and an instance method is one that only works when an instance of the class is available—and it works on that instance. To illustrate the advantage of using the Invoke-WMIMethod<\/b> cmdlet over the previous methods of working with WMI in Windows PowerShell 1.0, let us look at the old way and the new way of doing things. Keep in mind that both methodologies exist in Windows PowerShell 2.0, and it is perfectly legitimate to use the old style syntax. In certain cases, the old style syntax is actually easier to use and easier to understand. But we will get to that in a minute. <\/p>\n

To create a new instance of a Win32_Process<\/b> WMI class, you use the create<\/b> method. The problem is that the create<\/b> method is a static method. This fact is not mentioned on MSDN and is only discoverable by examining the qualifiers of the method in WbemTest<\/b> as seen here:<\/p>\n

\"Image<\/font><\/a><\/span><\/p>\n


It should not come as a surprise that the create<\/i> method is static—if you think about it for a minute—to create a new process, you are not working with an individual process—you are working with the Win32_Process class. To delete a process however, you are working with an individual process—and the terminate<\/i> method is an instance method. Understanding this difference helps to explain the two ways of working with WMI methods. Instance methods can be discovered by piping the results of the Get-WmiObject cmdlet to the Get-Member cmdlet. This is shown here:<\/p>\n

PS C:> Get-WmiObject -Class win32_process | Get-Member -MemberType method<\/p>\n


   <\/span>TypeName: System.Management.ManagementObject#rootcimv2Win32_Process<\/p>\n

Name           <\/span>MemberType Definition
—-           <\/span>———- ———-
AttachDebugger Method     <\/span>System.Management.ManagementBaseObject AttachDebugger()
GetOwner       <\/span>Method     <\/span>System.Management.ManagementBaseObject GetOwner()
GetOwnerSid    <\/span>Method     <\/span>System.Management.ManagementBaseObject GetOwnerSid()
SetPriority    <\/span>Method     <\/span>System.Management.ManagementBaseObject SetPriority(System.Int32 Priority)
Terminate      <\/span>Method     <\/span>System.Management.ManagementBaseObject Terminate(System.UInt32 Reason)<\/p>\n


PS C:><\/p>\n

<\/font><\/span><\/p>\n


The static methods are found by using the [wmiclass]<\/b> type accelerator. This is seen here:<\/p>\n

PS C:> [wmiclass]”Win32_Process” | Get-Member -MemberType method<\/p>\n


   <\/span>TypeName: System.Management.ManagementClass#ROOTcimv2Win32_Process<\/p>\n

Name   <\/span>MemberType Definition
—-   <\/span>———- ———-
Create Method     <\/span>System.Management.ManagementBaseObject Create(System.String CommandLine, System.String CurrentDire…<\/p>\n


PS C:><\/p>\n

<\/font><\/span><\/p>\n


The difference between the Get-WMIObject<\/b> cmdlet and the [wmiclass]<\/b> type accelerator is that the Get-WMIObject<\/b> cmdlet returns instances of the class, and the [wmiclass]<\/b> type accelerator returns the class itself. <\/p>\n

JB, let us put this together. To create a new process in Windows PowerShell 1.0, you use the the [wmiclass]<\/b> type accelerator as seen here:<\/p>\n

PS C:> ([wmiclass]”Win32_Process”).Create(“notepad”)<\/p>\n


__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 2
__DERIVATION     <\/span>: {}
__SERVER   <\/span>      <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ProcessId        <\/span>: 4924
ReturnValue      <\/span>: 0<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

The syntax is rather terse, but is a bit confusing. In Windows PowerShell 2.0, if you want to create a new process, you can use the Invoke-WMIMethod<\/b> cmdlet, which though a bit wordy is much easier to understand:
<\/p>\n

PS C:> Invoke-WmiMethod -Class win32_process -Name create -ArgumentList “notepad”<\/p>\n


__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 2
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ProcessId        <\/span>: 4592
ReturnValue      <\/span>: 0<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

In Windows PowerShell 1.0, if you want to terminate a process, you could use the Win32_Process<\/b> WMI class and the Get-WMIObject<\/b> cmdlet. Because Terminate<\/b> is not a static method, it is available only on an instance of the class. To retrieve specific instances of the Win32_Process<\/b> WMI class, you query for it by using the Get-WmiObject <\/b>and a filter. The –filter<\/b> parameter is used to limit the results to only processes named notepad.exe<\/b>. Because multiple instances of the Win32_Process<\/b> class were returned and an instance method only works on one instance, it is necessary to pipe the results to the ForEach-Object<\/b> cmdlet. The $_<\/b> automatic variable is used to refer to a single instance of the class at a time as it comes across the Windows PowerShell pipeline, and therefore the Terminate<\/b> method can be called. This is shown here:<\/p>\n

PS C:> Get-WmiObject -Class win32_Process -Filter “name = ‘notepad.exe'” | ForEach-Object { $_.Terminate() }<\/p>\n


__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER        <\/span> <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

Using the Invoke-WMIMethod<\/b> cmdlet to call instance methods is a bit more work. This is because the –path<\/b> parameter must point to a specific instance of the class. Luckily, the path property is always available because it is a system property. In WMI all system properties are preceded by a double underscore, so they will filter to the top of a list of properties and can be easily discarded in search results. Note that the __RELPATH<\/b> property refers to the WMI class name and a key property value on the local machine. The key property is always used to uniquely refer to instances of a WMI class. For the Win32_Process<\/b> WMI class, the key property is Handle<\/b>.<\/i> The __PATH<\/b> property refers to a specific instance of the WMI class on a specific computer. The full path uses machine name, WMI namespace, WMI class, and the key. The system properties for one instance of the Win32_Process<\/b> are shown here:<\/p>\n

__GENUS                    <\/span>: 2
__CLASS                    <\/span>: Win32_Process
__SUPERCLASS               <\/span>: CIM_Process
__DYNASTY                  <\/span>: CIM_ManagedSystemElement
__RELPATH                  <\/span>: Win32_Process.Handle=”2208″
__PROPERTY_COUNT           <\/span>: 45
__DERIVATION               <\/span>: {CIM_Process, CIM_LogicalElement, CIM_ManagedSystemElement}
__SERVER                   <\/span>: MRED1
__NAMESPACE                <\/span>: rootcimv2
__PATH                     <\/span>: \\MRED1rootcimv2:Win32_Process.Handle=”2208″<\/p>\n

<\/font><\/span><\/p>\n

Because typing the path value can be a bit cumbersome, you can pick it up from the pipeline by using the $_<\/b> automatic variable and choosing the __Path<\/b> property. This is shown here:<\/p>\n

PS C:> Get-WmiObject -Class win32_process -Filter “name = ‘notepad.exe'” |
ForEach-Object { Invoke-WmiMethod -Path $_.__Path –Name Terminate }<\/p>\n


__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

__GENUS         <\/span> <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

<\/font><\/span><\/p>\n

If you only have one instance of the WMI class you would like to delete, you can type the path to it directly. Because I am working on a local machine, I do not need to type the full __PATH<\/b> value. I can use the __RELPATH<\/b> value instead. The other thing that is significant is the –Path<\/b> parameter of the Invoke-WMIMethod<\/b> expects a WMI path for the value, and therefore quotation marks are not needed around the path. This is shown here:<\/p>\n

PS C:> Invoke-WmiMethod -Path win32_Process.Handle=”3944″ -name terminate<\/p>\n


__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

In fact, you do not need to set off the numbers of the handle with quotation marks either if you do not wish to do so. Leaving out all quotation marks is illustrated here. This is really helpful because one of the things that has always been confusing to scripters is the escaping of quotation marks inside other quotation marks. With the Invoke-WMIMethod<\/b> cmdlet, these types of issues are avoided altogether: <\/p>\n

PS C:> Invoke-WmiMethod -Path win32_Process.Handle=3252 -name terminate<\/p>\n


__GENUS          <\/span>: 2
__CLASS          <\/span>: __PARAMETERS
__SUPERCLASS     <\/span>:
__DYNASTY        <\/span>: __PARAMETERS
__RELPATH        <\/span>:
__PROPERTY_COUNT : 1
__DERIVATION     <\/span>: {}
__SERVER         <\/span>:
__NAMESPACE      <\/span>:
__PATH           <\/span>:
ReturnValue      <\/span>: 0<\/p>\n

PS C:><\/p>\n

<\/font><\/span><\/p>\n

 <\/p>\n

JB, this should get you started using WMI methods. This also concludes WMI Week. Join us tomorrow when we dig into our virtual mailbag for Quick-Hits Friday. <\/p>\n

If you want to know exactly what we will be looking at tomorrow, follow us on Twitter<\/a> or Facebook<\/a>. If you have any questions, send e-mail to us at scripter@microsoft.com<\/font><\/a> or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

\n

 <\/p>\n<\/p>\n

Ed Wilson and Craig Liebendorfer, Scripting Guys<\/span><\/b><\/p>\n

\n

 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

    Hey, Scripting Guy! I enjoy working with WMI, but it can be a bit complicated to make it do anything. It is great at retrieving information, and in conjunction with the Windows PowerShell Get-WMIObject cmdlet, it is really easy to obtain lots of information about our servers. In fact, WMI is one of […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[31,87,3,4,45,6],"class_list":["post-51823","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-operating-system","tag-processes","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell","tag-wmi"],"acf":[],"blog_post_summary":"

    Hey, Scripting Guy! I enjoy working with WMI, but it can be a bit complicated to make it do anything. It is great at retrieving information, and in conjunction with the Windows PowerShell Get-WMIObject cmdlet, it is really easy to obtain lots of information about our servers. In fact, WMI is one of […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/51823","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=51823"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/51823\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=51823"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=51823"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=51823"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}