ModifyPoolSettings(
            string resourceDisplayName,
            string poolId,
            string newPoolId,
            string newPoolName)
        {
            Console.WriteLine(
                "Modifying a resource pool's settings:\n" +
                "\tPool ID: " + poolId + " (change to " + newPoolId + ")\n" +
                "\tPool Name: (change to " + newPoolName + ")");

            ResourceUtilities.DisplayResourceInformation(
                resourceDisplayName);
            ManagementScope scope = ResourcePoolUtilities.GetManagementScope();

            using (ManagementObject rPConfigurationService =
                       MsvmResourcePoolConfigurationService.GetResourcePoolConfigurationService(
                           scope))
            {
                string resourcePoolSettingData =
                    MsvmResourcePoolSettingData.GetSettingsForPool(
                        scope,
                        ResourceUtilities.GetResourceType(resourceDisplayName),
                        ResourceUtilities.GetResourceSubType(resourceDisplayName),
                        newPoolId,
                        newPoolName);

                ModifyPoolSettingsHelper(
                    scope,
                    rPConfigurationService,
                    ResourceUtilities.GetResourceType(resourceDisplayName),
                    ResourceUtilities.GetResourceSubType(resourceDisplayName),
                    poolId,
                    resourcePoolSettingData);
            }
        }
        CreatePoolHelper(
            ManagementScope scope,
            ManagementObject rPConfigurationService,
            string resourceType,
            string resourceSubType,
            string childPoolId,
            string childPoolName,
            string[] parentPoolIdArray,
            string[][] parentHostResourcesArray)
        {
            if (parentPoolIdArray.Length == 0)
            {
                throw new ManagementException(string.Format(
                                                  CultureInfo.CurrentCulture,
                                                  @"At least one parent pool must be specified when creating a 
                    child resource pool (PoolId ""{0}"")", childPoolId));
            }

            if (parentPoolIdArray.Length != parentHostResourcesArray.Length)
            {
                throw new ManagementException(string.Format(
                                                  CultureInfo.CurrentCulture,
                                                  @"When creating a child resource pool, a host resource must be 
                    specified for each parent pool. Shared allocations are not 
                    supported (PoolId ""{0}"")", childPoolId));
            }

            string resourcePoolSettingData =
                MsvmResourcePoolSettingData.GetSettingsForPool(
                    scope,
                    resourceType,
                    resourceSubType,
                    childPoolId,
                    childPoolName);

            string[] parentPoolPathArray =
                ResourcePoolUtilities.GetParentPoolArrayFromPoolIds(
                    scope,
                    resourceType,
                    resourceSubType,
                    parentPoolIdArray);

            string[] resourceAllocationSettingDataArray =
                MsvmResourceAllocationSettingData.GetNewPoolAllocationSettingsArray(
                    scope,
                    resourceType,
                    resourceSubType,
                    parentPoolIdArray,
                    parentHostResourcesArray);

            using (ManagementBaseObject inParams =
                       rPConfigurationService.GetMethodParameters(
                           "CreatePool"))
            {
                inParams["PoolSettings"]       = resourcePoolSettingData;
                inParams["ParentPools"]        = parentPoolPathArray;
                inParams["AllocationSettings"] = resourceAllocationSettingDataArray;

                using (ManagementBaseObject outParams =
                           rPConfigurationService.InvokeMethod(
                               "CreatePool",
                               inParams,
                               null))
                {
                    if (WmiUtilities.ValidateOutput(outParams, scope, true, true))
                    {
                        string poolPath = outParams["Pool"].ToString();

                        return(new ManagementObject(
                                   scope,
                                   new ManagementPath(poolPath),
                                   null));
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }