{"id":2071,"date":"2013-08-19T15:40:00","date_gmt":"2013-08-19T15:40:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/powershell\/2013\/08\/19\/cim-cmdlets-some-tips-tricks\/"},"modified":"2019-02-18T13:05:31","modified_gmt":"2019-02-18T20:05:31","slug":"cim-cmdlets-some-tips-tricks","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/powershell\/cim-cmdlets-some-tips-tricks\/","title":{"rendered":"CIM Cmdlets \u2013 Some Tips & Tricks"},"content":{"rendered":"

Common Information Model (CIM) cmdlets have been around for a while, and come in handy when you are performing any CIM operation in PowerShell. They are easy to use, and provide a good user experience. In this blog post, I cover a few tips and tricks that can be useful for users of <\/span>CIM cmdlets<\/span><\/a>. <\/span><\/p>\n

To get started, let’s get the complete list of cmdlets. The PowerShell module name for these cmdlets is CimCmdlets<\/strong>,<\/strong> and we can use the Get-Command cmdlet to see the cmdlets exposed by this module.<\/span><\/p>\n\n\n\n
\n

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

PS :> # Get all CIM Cmdlets<\/span><\/span><\/p>\n

PS :> Get-Command –module CimCmdlets<\/span><\/span><\/p>\n

CommandType         Name                                           ModuleName<\/span><\/span><\/p>\n

——————–     <\/span>————————————-        ———————-                                                  <\/span><\/span><\/span><\/p>\n

Cmdlet                   <\/span>Get-CimAssociatedInstance           <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Get-CimClass                                    <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Get-CimInstance                              <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Get-CimSession                                <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Invoke-CimMethod                         <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>New-CimInstance                            <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>New-CimSession                              <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                  <\/span> <\/span>New-CimSessionOption                  <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Register-CimIndicationEvent         <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Remove-CimInstance                      <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Remove-CimSession                <\/span>        <\/span>CimCmdlets<\/span><\/span><\/p>\n

Cmdlet                   <\/span>Set-CimInstance                                <\/span>CimCmdlets<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/span><\/h2>\n

Tip#1: Working with CIM sessions<\/strong><\/span><\/span><\/span><\/h2>\n

A CIM session is a client-side object representing a connection to a local or remote computer. The CIM session contains information about the connection, such as <\/span>ComputerName<\/span><\/strong>, the protocol used for the connection, session ID, and instance ID. <\/span><\/p>\n

a.<\/span>       <\/span><\/span><\/span>When you are trying to connect to a remote machine, you might have to pass credentials. The New-CimSession cmdlet consumes a PSCredential object when credentials are used to create a CIM session. The constructor of PSCredential object accepts only a secure password string.<\/span><\/p>\n\n\n\n
\n

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

PS:> <\/span># Type in the password when you are prompted<\/span><\/span><\/a><\/p>\n

PS:> .$creds = Get-Credential -Credential username<\/span><\/span><\/span><\/p>\n

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

PS:> # Save credentials for future use<\/span><\/span><\/p>\n

PS:> $creds | Export-Clixml -Path c:\\a.clixml<\/span><\/span><\/p>\n

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

PS:> # Use the saved credentials when needed<\/span><\/span><\/p>\n

PS:> $savedCreds = Import-Clixml -Path C:\\a.clixml<\/span><\/span><\/p>\n

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

PS:> # Create CimSession with Credentials<\/span><\/span><\/p>\n

PS:> $session = New-CimSession –ComputerName “machineName”  <\/span>-Credential $savedCreds<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

b.<\/span>      <\/span><\/span><\/span>If the ComputerName parameter is added, the protocol used is WS-Management (WS-Man).<\/span><\/p>\n\n\n\n
\n

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

PS:> # If the ComputerName parameter is not added, the cmdlet uses DCOM\/COM<\/span><\/span><\/p>\n

PS:> # Creates DCOM session<\/span><\/span><\/p>\n

PS:> $session = New-CimSession<\/span><\/span><\/p>\n

PS:>  <\/span># Performs enumerate over DCOM<\/span><\/span><\/p>\n

PS:> $inst = Get-CimInstance Win32_OperatingSystem                  <\/span><\/span><\/span><\/p>\n

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

PS:> # If ComputerName is added, the cmdlets go over WS-Man <\/span><\/span><\/p>\n

PS:>  <\/span>$session = New-CimSession –ComputerName localhost<\/span><\/span><\/p>\n

PS :> $inst = Get-CimInstance Win32_OperatingSystem –ComputerName localhost<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

c.<\/span>       <\/span><\/span><\/span>If you use any parameter except “–Protocol DCOM”<\/strong> with New-CimSessionOption, the session option helps generate the WS-Man session.<\/span><\/p>\n\n\n\n
\n

PS:> # DCOM Session<\/span><\/span><\/p>\n

PS:> $sessionOp = New-CimSessionOption –Protocol DCOM<\/span><\/span><\/p>\n

PS:> $sessionDcom = New-CimSession –SessionOption $sessionOp –ComputerName localhost<\/span><\/span><\/p>\n

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

PS:> # WS-Man Session: the parameter UseSSL added to the New-CimSessionOption command specified the WS-Man protocol<\/span><\/span><\/p>\n

PS:> $sessionOp2 = New-CimSessionOption –UseSSL<\/span><\/span><\/p>\n

PS:> $sessionWSMAN = New-CimSession –SessionOption $sessionOp2 –ComputerName localhost<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

d.<\/span>      <\/span><\/span><\/span>The Default protocol in your New-CimSessionOption command corresponds to WS-Man.<\/span><\/p>\n\n\n\n
\n

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

PS:> # Create a CimSession using Default protocol<\/span><\/span><\/p>\n

PS:> New-CimSession –ComputerName localhost –SessionOption (New-CimSessionOption –Protocol Default)<\/span>  <\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/span>e.<\/span>      <\/span><\/span><\/span>If you are performing a large number of remote operations,, I recommend that you reuse sessions. This can provide a significant performance gain.<\/span><\/span><\/p>\n\n\n\n
\n

PS:> # Perform Get-CimInstance using computerName<\/span><\/span><\/p>\n

PS:>$time 1 = Measure-Command { 1..100 | %{ Get-CimInstance –ClassName CIM_ComputerSystem –ComputerName remoteMachine } }<\/span><\/span><\/p>\n

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

PS:> # Create a CimSession<\/span><\/span><\/p>\n

PS:> $session = New-CimSession –ComputerName remoteComputer<\/span><\/span><\/p>\n

PS:> $time2 = Measure-Command { 1..100 | %{ Get-CimInstance –ClassName CIM_ComputerSystem –CimSession $session } }<\/span><\/span><\/p>\n

 <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

In the above example, $time1 > $time2, because the Get-CimInstance cmdlet calls that use ComputerName parameter create a CIM session under the hood every time. In the second scenario, where we use an explicitly created CIM session, the cost of creating a CIM session in each call is not there.<\/span><\/p>\n

  <\/p>\n

Tip#2: Fan-out<\/span><\/h2>\n

 a.<\/span>       <\/span><\/span><\/span>Working with multiple servers<\/span><\/p>\n

All CIM cmdlets accept an array of CIM sessions or computer names. These can be used to perform operations on multiple servers in one line.<\/span><\/p>\n\n\n\n
\n

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

PS :> # Create multiple sessions <\/span><\/span><\/p>\n

PS :> $allSessions = New-CimSession -ComputerName “machine1”, “machine2”, “machine3” –Credential $credentials<\/span><\/span><\/p>\n

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

PS :> # Fan-out with CIM session Array<\/span><\/span><\/p>\n

PS :> Get-CimInstance –ClassName Win32_OperatingSystem –CimSession $allSessions<\/span><\/span><\/p>\n

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

PS :> # Reboot all machines in one line<\/span><\/span><\/p>\n

PS :> Invoke-CimMethod –ClassName Win32_OperatingSystem –MethodName Reboot –CimSession $allSessions<\/span><\/span><\/p>\n

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

PS:> # OR<\/span><\/span><\/p>\n

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

PS:> Invoke-CimMethod –ClassName Win32_OperatingSystem –MethodName Reboot –ComputerName “Machine1”, Machine2”,”Machine3”<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

b.<\/span>      <\/span><\/span><\/span>Don’t have to pass session if you use pipes. Instances are machine-aware<\/span><\/p>\n

If an instance received from one cmdlet is piped to another cmdlet, the cmdlet on the right side of the pipe is not required to specify computer names or CIM sessions, because the instances are machine-aware. The cmdlet on the right-side of the pipe can extract machine-related information from the instances.<\/span><\/p>\n\n\n\n
\n

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

PS:> # Get instance from a class<\/span><\/span><\/p>\n

PS:> $session = New-CimInstance -ComputerName machine1<\/span><\/span><\/p>\n

PS:> $inst = Get-CimInstance –Query “Select * from TestClass where v_key = 2” –Namespace root\/test –CimSession $session<\/span><\/span><\/p>\n

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

PS:> # Pass CIM instance <\/span><\/span><\/p>\n

PS:> $props = @{ boolVal = $true }<\/span><\/span><\/p>\n

PS:> $inst | Set-CimInstance –CimInstance $inst –Property $props<\/span><\/span><\/p>\n

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

# OR<\/span><\/span><\/p>\n

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

PS:> # Pipe result of get into set<\/span><\/span><\/p>\n

PS:> Get-CimInstance –Query “Select * from TestClass where v_key = 2” –Namespace root\/test –CimSession $session | Set-CimInstance –CimInstance $inst –Property $props<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/p>\n

Tip#3: Working with non-Windows CIMOMs<\/span><\/h2>\n

a.<\/span>       <\/span><\/span><\/span>Connecting to devices that need resource URIs<\/span><\/p>\n

Some vendors support non-DMTF <\/span>resource URIs<\/span><\/a>, (here DMTF stands for Distributed Management Task Force<\/span>)<\/span><\/strong> but the parameter set of CIM cmdlets that uses ClassName might not work in that scenario. CIM cmdlets offer a parameter set that accepts non-DMTF resource URIs, and lets you manage those devices. The following example demonstrates this:<\/span><\/p>\n\n\n\n
\n

PS:> # Non DMTF resource URI <\/span><\/span><\/p>\n

PS:> $resourceuri = “http:\/\/intel.com\/wbem\/wscim\/1\/amt-schema\/1\/AMT_PETFilterSetting”<\/span><\/span><\/p>\n

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

PS :> # Get instances<\/span><\/span><\/p>\n

PS:> $inst = Get-CimInstance -Namespace $namespace -ResourceUri $resourceuri -CimSession $session<\/span><\/span><\/p>\n

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

PS :> # Query instances<\/span><\/span><\/p>\n

PS:> $inst = Get-CimInstance -Query $query -Namespace $namespace -ResourceUri $resourceuri -CimSession $session<\/span><\/span><\/p>\n

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

PS:> # Modify instance<\/span><\/span><\/p>\n

PS:> $propsToModify = @{LogOnEvent=$false}<\/span><\/span><\/p>\n

PS:> Set-CimInstance -InputObject $inst -Property $ propsToModify -ResourceUri $resourceuri -CimSession $session<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

b.<\/span>      <\/span><\/span><\/span>If the <\/span>Common Information Model Object Manager <\/span>(CIMOM) does not support TestConnection, the New-CimSession command will fail. How to make sure a session can be created with such a CIMOM?<\/span><\/p>\n\n\n\n
\n

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

PS:> # Creating CIM session when the server\/CIMOM does not support TestConnection <\/span><\/span><\/p>\n

PS:> $session = New-CimSession –CN “machineName”  <\/span>-Credential $creds<\/span> –SkipTestConnection<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

c.<\/span>       <\/span><\/span><\/span>If the CIMOM is listening on a port other than the default port, you can make sure New-CimSession calls the particular port.<\/span><\/p>\n\n\n\n
\n

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

PS:> # Default HTTP port for WS-Man on Windows<\/span><\/span><\/p>\n

PS:> $httpPort = 5985                        <\/span><\/span><\/span><\/p>\n

PS:> # Default HTTPS port for WS-Man on Windows<\/span><\/span><\/p>\n

PS:< $httpsPort = 5986        <\/span><\/span><\/span><\/p>\n

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

PS:> # Port parameter is exposed by New-CimSession and not New-CimSessionOption<\/span><\/span><\/p>\n

PS:> $session = New-CimSession –CN “machineName”  <\/span>-Credential $creds –Port $httpPort<\/span><\/span><\/p>\n

PS:> # If using HTTPS. <\/span><\/span><\/p>\n

PS:> $sop = New-CimSessionOption –UseSSL<\/span><\/span><\/p>\n

PS:> $session = New-CimSession –CN “machineName”  <\/span>-Credential $creds –Port $httpsPort<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/p>\n

Tip#4: Get associated instances<\/strong><\/span><\/span><\/span><\/h2>\n

Associations are important in the CIM world, as they define the relationship between two classes. Get-CimAssociatedInstance provides a way of figuring out these relationships.<\/span><\/p>\n\n\n\n
\n

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

PS :> # Get instance of Win32_LogicalDisk class with DriveType =3 (hard drives)<\/span><\/span><\/p>\n

PS :> $disks = Get-CimInstance -class Win32_LogicalDisk -Filter ‘DriveType = 3’<\/span><\/span><\/p>\n

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

PS :> # Get the all instances associated with this disk<\/span><\/span><\/p>\n

PS :> Get-CimAssociatedInstance -CimInstance $disks[0]<\/span><\/span><\/p>\n

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

PS :> # Get instances of a specific type<\/span><\/span><\/p>\n

PS :> Get-CimAssociatedInstance -CimInstance $disks[0] -ResultClassName Win32_DiskPartition<\/span><\/span><\/p>\n

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

PS :> # Finding associated instances through a specific CIM relationship <\/span><\/span><\/p>\n

PS :> Get-CimAssociatedInstance -CimInstance $disks[0] -Association Win32_LogicalDiskRootDirectory<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

Tip#5: Passing ref and embedded instances<\/span><\/span><\/span><\/h2>\n

Did you know?<\/span> If you pass an instance as REF<\/strong>, only key values get passed on to the provider by the infrastructure; for example, even if all the properties are populated inside the instance, the provider only gets to see the key values.<\/span><\/p>\n

There are some edge-case scenarios that come up with REF arrays. <\/span><\/p>\n

a.<\/span>       <\/span><\/span><\/span>If the instances are created with the ClientOnly<\/strong> parameter in a New-CimInstance command, while passing it into a method that expects a REF array, we should typecast it as ref[].<\/span><\/p>\n\n\n\n
\n

PS:> # Create an instance with New-CimInstance -ClientOnly : Type cast it to [ref[]]<\/span><\/span><\/p>\n

PS:> $inst1 = New-CimInstance –className foo –Namespace root\/test –Property @{A= 1; B= 2} –ClientOnly<\/span><\/span><\/p>\n

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

PS:> $inst2 = New-CimInstance –ClassName foo –Namespace root\/test –Property @{A= 3; B= 4} –ClientOnly<\/span><\/span><\/p>\n

PS:> $instArray = @($inst1, $inst2)<\/span><\/span><\/p>\n

PS:> Invoke-CimMethod –ClassName Class1 –Namespace root\/test –Method MethodRefArray –Property @{vals = [ref[]] $instArray}<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

b.<\/span>      <\/span><\/span><\/span>If the instances come from Get-CimInstance, and are the same as a server object, then method invocation should be done by typecasting that instance array as Ciminstance[].<\/span><\/p>\n\n\n\n
\n

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

PS :> # Get an instance from Get-CimInstance : Typecast it to [Ciminstance[]]<\/span><\/span><\/p>\n

PS :> $inst = Get-CimInstance –ClassName foo –Namespace root\/test<\/span><\/span><\/p>\n

PS :> Invoke-CimMethod –ClassName Class1 –Namespace root\/test –Method MethodRefArray –Property @{vals = [Ciminstance[]] $inst}<\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

c.<\/span>       <\/span><\/span><\/span>The next example shows invoking methods with embedded instances.<\/span><\/p>\n\n\n\n
\n

PS :> $nums = New-CimInstance –ClassName numbers -Namespace root\/test -Property @{numbers = @([int64]5 , [int64]6); count = [uint32]2} –Local<\/span><\/span><\/p>\n

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

PS :> Invoke-CimMethod  <\/span>-ClassName TestCalculator -MethodName AddNumbers  <\/span>-Arguments @{numbers = $nums} –Namespace root\/test<\/span><\/span><\/p>\n

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

PS :> $nums2 = Get-CimInstance –ClassName numbers -Namespace root\/test<\/span><\/span><\/p>\n

PS :> Invoke-CimMethod <\/span>-ClassName TestCalculator -MethodName AddNumbers  <\/span>-Arguments @{numbers = [CimInstance] $nums} -NS root\/test<\/span><\/span><\/p>\n

 <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/p>\n

Tip#6: Using indications<\/span><\/span><\/span><\/h2>\n

Receiving indications allows the developer to notify the consuming application that certain system configuration data has changed, without the application having to poll Windows Management Instrumentation (WMI) continuously for this data. From the CIM cmdlet layer, registering for indications is easy. The following script block describes how to register, get, and unsubscribe from indications.<\/span><\/span><\/span><\/p>\n\n\n\n
\n

PS :> # Register for an event\/indications<\/span><\/span><\/p>\n

PS :> Register-CimIndicationEvent -ClassName Test_IndicationClass -Namespace root\\test<\/span><\/span><\/p>\n

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

PS :> # Get all events generated so far<\/span><\/span><\/p>\n

PS :> $x = Get-Event<\/span><\/span><\/p>\n

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

PS :> # Unregister a particular event.<\/span><\/span><\/p>\n

PS :> $sourceID = $x[0].SourceIdentifier<\/span><\/span><\/p>\n

PS :> Unregister-Event -SourceIdentifier $sourceID<\/span><\/span><\/p>\n

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

PS :> # Clean up all the events received so far<\/span><\/span><\/p>\n

PS :> Remove-Event * <\/span><\/span><\/p>\n

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

# OR<\/span><\/span><\/p>\n

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

PS :> # Define your own SID<\/span><\/span><\/p>\n

PS:> $sid = “TestSID”<\/span><\/span><\/p>\n

PS:> Register-CimIndicationEvent -ClassName Test_IndicationClass -Namespace root\\test –SourceIdentifier $sid<\/span><\/span><\/p>\n

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

PS:> $x = Get-Event –SourceIdentifier $sid<\/span><\/span><\/p>\n

PS:> Unregister-Event -SourceIdentifier $sid<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/h2>\n

Tip#7: Typecasting\/Using DateTime\/Using UInt8<\/span><\/span><\/span><\/h2>\n

While using a hash table as input to the parameters of CIM cmdlets, you might have to typecast data that is being passed. The simple rules here are:<\/span><\/p>\n

·         <\/span><\/span><\/span>If the class schema is passed while running the cmdlet, the data type is discovered at run time, so you don’t have to explicitly cast the values.<\/span><\/p>\n

·         <\/span><\/span><\/span>If the class schema is not passed, the default data types are used, which can cause failures while running the cmdlets. Typecasting is needed in this scenario.<\/span><\/p>\n

The following sample code clarifies this:<\/span><\/p>\n\n\n\n
\n

PS:> Invoke-CimMethod -ClassName TestCalculator -Namespace root\/test -MethodName Add –Arguments @{Left = 4; right=5}<\/span><\/span><\/p>\n

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

Invoke-CimMethod : Type mismatch for parameter “Left“  <\/span><\/span> <\/span>=> If Left and Right are SInt64 values<\/span><\/span><\/p>\n

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

PS:> # The above failure happened because by default all values are treated as UInt32.<\/span><\/span><\/p>\n

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

PS:> Invoke-CimMethod -ClassName TestCalculator -Namespace root\/test -MethodName Add –Arguments @{Left = [int64]4; right=[int64]5}<\/span><\/span><\/p>\n

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

PS:> # If the CimClass parameter is used, no typecasting is needed.<\/span><\/span><\/p>\n

PS:> $c = Get-CimClass -Namespace root\/test -ClassName TestCalculator<\/span><\/span><\/p>\n

PS:> Invoke-CimMethod -CimClass $c -MethodName Add -Arguments @{Left = 4; right=5}<\/span><\/span><\/p>\n

 <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

While using any DateTime type parameter, we must typecast the string representation of DateTime. Similarly, while passing in a value that is UInt8, we must typecast it to Byte. <\/span><\/p>\n\n\n\n
\n

PS:> $inst = New-CimInstance -ClassName TestClass -Namespace root\\test -Key v_uint8 -Property @{ v_uint8 = [byte] 3; v_dateTime = [DateTime] “12\/31\/1899 3:59:59 PM” }<\/span> <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/p>\n

Tip#8 Passing operationOptions<\/strong><\/span><\/span><\/span><\/h2>\n

There is no way of passing operation Options values to the WMI provider from CIM cmdlets. To pass operationOptions values to your provider, you might have to take the following route:<\/span><\/p>\n\n\n\n
\n

PS :> $s = New-CimSession<\/span><\/span><\/p>\n

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

PS :> # Create MethodParameterCollection<\/span><\/span><\/p>\n

PS :> $x = New-Object Microsoft.Management.Infrastructure.CimMethodParametersCollection<\/span><\/span><\/p>\n

PS :> $param = [Microsoft.Management.Infrastructure.CimMethodParameter]::Create(“number”,  <\/span>40, [Microsoft.Management.Infrastructure.cimtype]::UInt64, [Microsoft.Management.Infrastructure.CimFlags]::None)<\/span><\/span><\/p>\n

PS :> $x.Add($param)<\/span><\/span><\/p>\n

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

PS :> Create a OperationOption object<\/span><\/span><\/p>\n

Ps :> $operationOption = new-object                         <\/span>Microsoft.Management.Infrastructure.Options.CimOperationOptions<\/span><\/span><\/p>\n

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

PS :> $operationOption.SetCustomOption(“TEST_SET_NAMESPACE”, $true, $false)<\/span><\/span><\/p>\n

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

PS :> # Invoke the method <\/span><\/span><\/p>\n

PS :> $s.InvokeMethod(“root\/test”, “TestalCalculator”, “PrimeFactors”, $x, $operationOption)<\/span><\/span><\/p>\n

PS :> $returnVal.OutParameters[“factors”].Value.CimSystemProperties<\/span>         <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/p>\n

Tip#9 Instances of an AssociationClass only have references to the two ends of the association, and not actual instances<\/strong><\/span><\/span><\/span><\/h2>\n

When instances of an association class are enumerated, the properties returned contain the references to the two end points of that association. As these properties are reference-only, only key values are populated.<\/span><\/p>\n\n\n\n
\n

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

PS :> Get-CimInstance win32_DiskDriveToDiskPartition<\/span><\/span><\/p>\n

Antecedent :   <\/span>Win32_DiskDrive (DeviceID = <\/span>\\\\.\\PHYSICALDRIVE0<\/span>)                     <\/span><\/span><\/span><\/p>\n

Dependent :    <\/span>Win32_DiskPartition (DeviceID = “Disk #0, Partition #0”)             <\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

  <\/p>\n

Tip#10 Making Get\/Enumerate efficient<\/strong><\/span><\/span><\/span><\/h2>\n

a.<\/span>       <\/span><\/span><\/span>Save a round trip by using -ClientOnly to create instances<\/span><\/p>\n

If the key values of an instance are known, and the intended operation is to get an instance from the server, then the user can create a ClientOnly instance of a class, and then run Get-CimInstance on it. This saves one round trip to the server.<\/span><\/span><\/p>\n\n\n\n
\n

PS:> $instLocal = New-CimInstance –className foo –Namespace root\/test –Property @{A= 1; B= 2} –ClientOnly<\/span><\/span><\/p>\n

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

PS:> $instFromServer = Get-CimInstance –InputObject $instLocal –CimSession $session<\/span><\/span><\/p>\n

 <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

b.<\/span>      <\/span><\/span><\/span>Only get the key properties.<\/span><\/p>\n

If the whole instance is not needed, and the intent is only to check the key properties of an instance, the user can get key properties of an instance only, if desired.<\/span><\/p>\n\n\n\n
\n

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

PS:> $inst = Get-CimInstance -Class Win32_Process –KeyOnly<\/span><\/span><\/p>\n

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

PS:> # This can be used to invoke a method<\/span><\/span><\/p>\n

PS:> Invoke-CimMethod -InputObject $inst -MethodName “Terminate”<\/span><\/span><\/p>\n

 <\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

c.<\/span>       <\/span><\/span><\/span>How to refresh instance data in PowerShell without grabbing the WMI object again.<\/span><\/p>\n

The original object remains untouched, but the data refreshes.<\/span><\/span><\/p>\n\n\n\n
\n

PS:> # Get instance of a class<\/span><\/span><\/p>\n

PS:> $p = Get-CimInstance -ClassName Win32_PerfFormattedData_PerfOS_Processor

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

PS:> # Perform get again by passing the instance received earlier, and get the updated properties. The value of $p remains unchanged.<\/span><\/span><\/p>\n

PS:> $p | Get-CimInstance | select PercentProcessorTime
<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

I hope these tips and tricks will make your experience with CIM cmdlets even better. If you have any questions regarding these cmdlets, please feel free to let us know.<\/span><\/p>\n

 <\/p>\n

Thanks<\/span><\/p>\n

Vaibhav Chugh [MSFT]<\/span><\/p>\n

Standards Based Management<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

Common Information Model (CIM) cmdlets have been around for a while, and come in handy when you are performing any CIM operation in PowerShell. They are easy to use, and provide a good user experience. In this blog post, I cover a few tips and tricks that can be useful for users of CIM cmdlets. […]<\/p>\n","protected":false},"author":600,"featured_media":13641,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-2071","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-powershell"],"acf":[],"blog_post_summary":"

Common Information Model (CIM) cmdlets have been around for a while, and come in handy when you are performing any CIM operation in PowerShell. They are easy to use, and provide a good user experience. In this blog post, I cover a few tips and tricks that can be useful for users of CIM cmdlets. […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts\/2071","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/users\/600"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/comments?post=2071"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts\/2071\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/media\/13641"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/media?parent=2071"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/categories?post=2071"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/tags?post=2071"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}