Virtual Machines - Install Patches

Service:: Compute

API-versie:: 2025-04-01

Installeert patches op de VM.

POST https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/installPatches?api-version=2025-04-01

URI-parameters

Name	In	Vereist	Type	Description
resourceGroupName	path	True	string minLength: 1 maxLength: 90	De naam van de resourcegroep. De naam is hoofdletterongevoelig.
subscriptionId	path	True	string minLength: 1	De id van het doelabonnement.
vmName	path	True	string	De naam van de virtuele machine.
api-version	query	True	string minLength: 1	De API-versie die voor deze bewerking moet worden gebruikt.

Aanvraagbody

Name	Vereist	Type	Description
rebootSetting	True	VMGuestPatchRebootSetting	Definieert wanneer het acceptabel is om een VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.
linuxParameters		LinuxParameters	Invoer voor InstallPatches op een Linux-VM, zoals rechtstreeks ontvangen door de API
maximumDuration		string (duration)	Hiermee geeft u de maximale tijdsduur op die de bewerking wordt uitgevoerd. Het moet een iso 8601-compatibele duurtekenreeks zijn, zoals PT4H (4 uur)
windowsParameters		WindowsParameters	Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

Antwoorden

Name

Type

Description

200 OK

VirtualMachineInstallPatchesResult

Azure-bewerking is voltooid.

202 Accepted

Resourcebewerking geaccepteerd.

Kopteksten

Location: string
Retry-After: integer

Other Status Codes

Een onverwachte foutreactie.

Beveiliging

azure_auth

OAuth2-stroom voor Azure Active Directory.

Type: oauth2
Stroom: implicit
Autorisatie-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiken

Name	Description
user_impersonation	Uw gebruikersaccount imiteren

Voorbeelden

Install patch state of a virtual machine.

Voorbeeldaanvraag

POST https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroupName/providers/Microsoft.Compute/virtualMachines/myVMName/installPatches?api-version=2025-04-01

{
  "maximumDuration": "PT4H",
  "rebootSetting": "IfRequired",
  "windowsParameters": {
    "classificationsToInclude": [
      "Critical",
      "Security"
    ],
    "maxPatchPublishDate": "2020-11-19T02:36:43.0539904+00:00",
    "patchNameMasksToInclude": [
      "*SQL*"
    ],
    "patchNameMasksToExclude": [
      "*Windows*"
    ]
  }
}


import com.azure.resourcemanager.compute.models.VMGuestPatchClassificationWindows;
import com.azure.resourcemanager.compute.models.VMGuestPatchRebootSetting;
import com.azure.resourcemanager.compute.models.VirtualMachineInstallPatchesParameters;
import com.azure.resourcemanager.compute.models.WindowsParameters;
import java.time.OffsetDateTime;
import java.util.Arrays;

/**
 * Samples for VirtualMachines InstallPatches.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/
     * virtualMachineExamples/VirtualMachine_InstallPatches.json
     */
    /**
     * Sample code: Install patch state of a virtual machine.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void installPatchStateOfAVirtualMachine(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getVirtualMachines().installPatches("myResourceGroupName",
            "myVMName",
            new VirtualMachineInstallPatchesParameters().withMaximumDuration("PT4H")
                .withRebootSetting(VMGuestPatchRebootSetting.IF_REQUIRED)
                .withWindowsParameters(new WindowsParameters()
                    .withClassificationsToInclude(Arrays.asList(VMGuestPatchClassificationWindows.CRITICAL,
                        VMGuestPatchClassificationWindows.SECURITY))
                    .withMaxPatchPublishDate(OffsetDateTime.parse("2020-11-19T02:36:43.0539904+00:00"))
                    .withPatchNameMasksToInclude(Arrays.asList("*SQL*"))
                    .withPatchNameMasksToExclude(Arrays.asList("*Windows*"))),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python virtual_machine_install_patches.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.virtual_machines.begin_install_patches(
        resource_group_name="myResourceGroupName",
        vm_name="myVMName",
        install_patches_input={
            "maximumDuration": "PT4H",
            "rebootSetting": "IfRequired",
            "windowsParameters": {
                "classificationsToInclude": ["Critical", "Security"],
                "maxPatchPublishDate": "2020-11-19T02:36:43.0539904+00:00",
                "patchNameMasksToExclude": ["*Windows*"],
                "patchNameMasksToInclude": ["*SQL*"],
            },
        },
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v7"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ccea12be6cd5e64743499d46f7a9c8b60df52db1/specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
func ExampleVirtualMachinesClient_BeginInstallPatches() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVirtualMachinesClient().BeginInstallPatches(ctx, "myResourceGroupName", "myVMName", armcompute.VirtualMachineInstallPatchesParameters{
		MaximumDuration: to.Ptr("PT4H"),
		RebootSetting:   to.Ptr(armcompute.VMGuestPatchRebootSettingIfRequired),
		WindowsParameters: &armcompute.WindowsParameters{
			ClassificationsToInclude: []*armcompute.VMGuestPatchClassificationWindows{
				to.Ptr(armcompute.VMGuestPatchClassificationWindowsCritical),
				to.Ptr(armcompute.VMGuestPatchClassificationWindowsSecurity)},
			MaxPatchPublishDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-19T02:36:43.053Z"); return t }()),
			PatchNameMasksToExclude: []*string{
				to.Ptr("*Windows*")},
			PatchNameMasksToInclude: []*string{
				to.Ptr("*SQL*")},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.VirtualMachineInstallPatchesResult = armcompute.VirtualMachineInstallPatchesResult{
	// 	ExcludedPatchCount: to.Ptr[int32](0),
	// 	FailedPatchCount: to.Ptr[int32](0),
	// 	InstallationActivityID: to.Ptr("68f8b292-dfc2-4646-9781-33cc88631968"),
	// 	InstalledPatchCount: to.Ptr[int32](3),
	// 	MaintenanceWindowExceeded: to.Ptr(false),
	// 	NotSelectedPatchCount: to.Ptr[int32](0),
	// 	Patches: []*armcompute.PatchInstallationDetail{
	// 		{
	// 			Name: to.Ptr("Definition Update for Windows Defender Antivirus - KB2267602 (Definition 1.279.1373.0)"),
	// 			Classifications: []*string{
	// 				to.Ptr("Definition Updates")},
	// 				InstallationState: to.Ptr(armcompute.PatchInstallationStateInstalled),
	// 				KbID: to.Ptr("2267602"),
	// 				PatchID: to.Ptr("35428702-5784-4ba4-a6e0-5222258b5411"),
	// 				Version: to.Ptr(""),
	// 			},
	// 			{
	// 				Name: to.Ptr("Windows Malicious Software Removal Tool x64 - October 2018 (KB890830)"),
	// 				Classifications: []*string{
	// 					to.Ptr("Update Rollups")},
	// 					InstallationState: to.Ptr(armcompute.PatchInstallationStatePending),
	// 					KbID: to.Ptr("890830"),
	// 					PatchID: to.Ptr("39f9cdd1-795c-4d0e-8c0a-73ab3f31746d"),
	// 					Version: to.Ptr(""),
	// 			}},
	// 			PendingPatchCount: to.Ptr[int32](2),
	// 			RebootStatus: to.Ptr(armcompute.VMGuestPatchRebootStatusCompleted),
	// 			StartDateTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-04-24T21:02:04.255Z"); return t}()),
	// 			Status: to.Ptr(armcompute.PatchOperationStatusSucceeded),
	// 		}
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Installs patches on the VM.
 *
 * @summary Installs patches on the VM.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
 */
async function installPatchStateOfAVirtualMachine() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroupName";
  const vmName = "myVMName";
  const installPatchesInput = {
    maximumDuration: "PT4H",
    rebootSetting: "IfRequired",
    windowsParameters: {
      classificationsToInclude: ["Critical", "Security"],
      maxPatchPublishDate: new Date("2020-11-19T02:36:43.0539904+00:00"),
      patchNameMasksToExclude: ["*Windows*"],
      patchNameMasksToInclude: ["*SQL*"],
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.virtualMachines.beginInstallPatchesAndWait(
    resourceGroupName,
    vmName,
    installPatchesInput,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/2025-04-01/examples/virtualMachineExamples/VirtualMachine_InstallPatches.json
// this example is just showing the usage of "VirtualMachines_InstallPatches" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this VirtualMachineResource created on azure
// for more information of creating VirtualMachineResource, please refer to the document of VirtualMachineResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroupName";
string vmName = "myVMName";
ResourceIdentifier virtualMachineResourceId = VirtualMachineResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, vmName);
VirtualMachineResource virtualMachine = client.GetVirtualMachineResource(virtualMachineResourceId);

// invoke the operation
VirtualMachineInstallPatchesContent content = new VirtualMachineInstallPatchesContent(VmGuestPatchRebootSetting.IfRequired)
{
    MaximumDuration = XmlConvert.ToTimeSpan("PT4H"),
    WindowsParameters = new WindowsParameters
    {
        ClassificationsToInclude = { VmGuestPatchClassificationForWindows.Critical, VmGuestPatchClassificationForWindows.Security },
        MaxPatchPublishOn = DateTimeOffset.Parse("2020-11-19T02:36:43.0539904+00:00"),
        PatchNameMasksToInclude = { "*SQL*" },
        PatchNameMasksToExclude = { "*Windows*" },
    },
};
ArmOperation<VirtualMachineInstallPatchesResult> lro = await virtualMachine.InstallPatchesAsync(WaitUntil.Completed, content);
VirtualMachineInstallPatchesResult result = lro.Value;

Console.WriteLine($"Succeeded: {result}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Voorbeeldrespons

Statuscode:: 200

{
  "status": "Succeeded",
  "installationActivityId": "68f8b292-dfc2-4646-9781-33cc88631968",
  "rebootStatus": "Completed",
  "maintenanceWindowExceeded": false,
  "excludedPatchCount": 0,
  "notSelectedPatchCount": 0,
  "pendingPatchCount": 2,
  "installedPatchCount": 3,
  "failedPatchCount": 0,
  "startDateTime": "2020-04-24T21:02:04.2556154Z",
  "patches": [
    {
      "patchId": "35428702-5784-4ba4-a6e0-5222258b5411",
      "name": "Definition Update for Windows Defender Antivirus - KB2267602 (Definition 1.279.1373.0)",
      "version": "",
      "kbId": "2267602",
      "classifications": [
        "Definition Updates"
      ],
      "installationState": "Installed"
    },
    {
      "patchId": "39f9cdd1-795c-4d0e-8c0a-73ab3f31746d",
      "name": "Windows Malicious Software Removal Tool x64 - October 2018 (KB890830)",
      "version": "",
      "kbId": "890830",
      "classifications": [
        "Update Rollups"
      ],
      "installationState": "Pending"
    }
  ],
  "error": null
}

Statuscode:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/westus/operations/{operationId}&monitor=true&api-version=2025-04-01

Definities

Name	Description
ApiError	Api-fout.
ApiErrorBase	Api-foutbasis.
CloudError	Een foutreactie van de Compute-service.
InnerError	Interne foutdetails.
LinuxParameters	Invoer voor InstallPatches op een Linux-VM, zoals rechtstreeks ontvangen door de API
PatchInstallationDetail	Informatie over een specifieke patch die is aangetroffen tijdens een installatieactie.
PatchInstallationState	De status van de patch nadat de installatiebewerking is voltooid.
PatchOperationStatus	De algehele succes- of mislukkingsstatus van de operatie. Het blijft "InProgress" totdat de bewerking is voltooid. Op dat moment wordt het "Onbekend", "Mislukt", "Geslaagd" of "VoltooidMetWaarschuwingen".
VirtualMachineInstallPatchesParameters	Invoer voor InstallPatches zoals rechtstreeks ontvangen door de API
VirtualMachineInstallPatchesResult	Het resultaat samenvatting van een installatiebewerking.
VMGuestPatchClassificationLinux
VMGuestPatchClassificationWindows
VMGuestPatchRebootSetting	Definieert wanneer het acceptabel is om een VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.
VMGuestPatchRebootStatus	De herstartstatus van de VM na voltooiing van de bewerking.
WindowsParameters	Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

ApiError

Object

Api-fout.

Name	Type	Description
code	string	De foutcode.
details	ApiErrorBase[]	Details van de Api-fout
innererror	InnerError	De innerlijke fout van de Api
message	string	Het foutbericht.
target	string	Het doel van de specifieke fout.

ApiErrorBase

Object

Api-foutbasis.

Name	Type	Description
code	string	De foutcode.
message	string	Het foutbericht.
target	string	Het doel van de specifieke fout.

CloudError

Object

Een foutreactie van de Compute-service.

Name	Type	Description
error	ApiError	Api-fout.

InnerError

Object

Interne foutdetails.

Name	Type	Description
errordetail	string	De interne foutmelding of uitzonderingsdump.
exceptiontype	string	Het uitzonderingstype.

LinuxParameters

Object

Invoer voor InstallPatches op een Linux-VM, zoals rechtstreeks ontvangen door de API

Name	Type	Description
classificationsToInclude	VMGuestPatchClassificationLinux[]	De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Linux.
maintenanceRunId	string	Dit wordt gebruikt als een id voor onderhoudsuitvoering voor Auto VM Guest Patching in Linux.
packageNameMasksToExclude	string[]	pakketten die moeten worden uitgesloten in de patchbewerking. Indeling: packageName_packageVersion
packageNameMasksToInclude	string[]	pakketten die moeten worden opgenomen in de patchbewerking. Indeling: packageName_packageVersion

PatchInstallationDetail

Object

Informatie over een specifieke patch die is aangetroffen tijdens een installatieactie.

Name	Type	Description
classifications	string[]	De classificatie(s) van de patch zoals verstrekt door de uitgever van de patch.
installationState	PatchInstallationState	De status van de patch nadat de installatiebewerking is voltooid.
kbId	string	De KBID van de patch. Geldt alleen voor Windows-patches.
name	string	De vriendelijke naam van de patch.
patchId	string	Een unieke identificatiecode voor de patch.
version	string	De versiereeks van het pakket. Het kan voldoen aan semantisch versiebeheer. Geldt alleen voor Linux.

PatchInstallationState

Opsomming

De status van de patch nadat de installatiebewerking is voltooid.

Waarde	Description
Unknown
Installed
Failed
Excluded
NotSelected
Pending

PatchOperationStatus

Opsomming

De algehele succes- of mislukkingsstatus van de operatie. Het blijft "InProgress" totdat de bewerking is voltooid. Op dat moment wordt het "Onbekend", "Mislukt", "Geslaagd" of "VoltooidMetWaarschuwingen".

Waarde	Description
Unknown
InProgress
Failed
Succeeded
CompletedWithWarnings

VirtualMachineInstallPatchesParameters

Object

Invoer voor InstallPatches zoals rechtstreeks ontvangen door de API

Name	Type	Description
linuxParameters	LinuxParameters	Invoer voor InstallPatches op een Linux-VM, zoals rechtstreeks ontvangen door de API
maximumDuration	string (duration)	Hiermee geeft u de maximale tijdsduur op die de bewerking wordt uitgevoerd. Het moet een iso 8601-compatibele duurtekenreeks zijn, zoals PT4H (4 uur)
rebootSetting	VMGuestPatchRebootSetting	Definieert wanneer het acceptabel is om een VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.
windowsParameters	WindowsParameters	Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

VirtualMachineInstallPatchesResult

Object

Het resultaat samenvatting van een installatiebewerking.

Name	Type	Description
error	ApiError	De fouten die zijn opgetreden tijdens de uitvoering van de bewerking. De detailarray bevat de lijst ervan.
excludedPatchCount	integer (int32)	Het aantal patches dat niet is geïnstalleerd omdat de gebruiker de installatie ervan blokkeert.
failedPatchCount	integer (int32)	Het aantal patches dat niet kon worden geïnstalleerd vanwege een probleem. Zie fouten voor meer informatie.
installationActivityId	string	De activiteit-id van de bewerking die dit resultaat heeft opgeleverd. Het wordt gebruikt om te correleren tussen CRP- en extensielogboeken.
installedPatchCount	integer (int32)	Het aantal patches dat met succes is geïnstalleerd.
maintenanceWindowExceeded	boolean	Of de operatie te laat was voordat alle beoogde acties waren voltooid.
notSelectedPatchCount	integer (int32)	Het aantal patches waarvan is vastgesteld dat ze beschikbaar zijn voor installatie, maar niet voldoen aan de criteria van de bewerking.
patches	PatchInstallationDetail[]	De patches die tijdens de operatie zijn geïnstalleerd.
pendingPatchCount	integer (int32)	Het aantal patches waarvan is vastgesteld dat ze voldoen aan de installatiecriteria, maar niet konden worden geïnstalleerd. Dit gebeurt meestal wanneer maintenanceWindowExceeded == true.
rebootStatus	VMGuestPatchRebootStatus	De herstartstatus van de VM na voltooiing van de bewerking.
startDateTime	string (date-time)	Het UTC-tijdstempel wanneer de bewerking begon.
status	PatchOperationStatus	De algehele succes- of mislukkingsstatus van de operatie. Het blijft "InProgress" totdat de bewerking is voltooid. Op dat moment wordt het "Mislukt", "Geslaagd", "Onbekend" of "VoltooidMetWaarschuwingen".

VMGuestPatchClassificationLinux

Opsomming

Waarde	Description
Critical
Security
Other

VMGuestPatchClassificationWindows

Opsomming

Waarde	Description
Critical
Security
UpdateRollUp
FeaturePack
ServicePack
Definition
Tools
Updates

VMGuestPatchRebootSetting

Opsomming

Definieert wanneer het acceptabel is om een VIRTUELE machine opnieuw op te starten tijdens een software-updatebewerking.

Waarde	Description
IfRequired
Never
Always

VMGuestPatchRebootStatus

Opsomming

De herstartstatus van de VM na voltooiing van de bewerking.

Waarde	Description
Unknown
NotNeeded
Required
Started
Failed
Completed

WindowsParameters

Object

Invoer voor InstallPatches op een Windows-VM, zoals rechtstreeks ontvangen door de API

Name	Type	Description
classificationsToInclude	VMGuestPatchClassificationWindows[]	De updateclassificaties die moeten worden geselecteerd bij het installeren van patches voor Windows.
excludeKbsRequiringReboot	boolean	Hiermee filtert u Kbs die geen InstallationRebootBehavior van 'NeverReboots' hebben als dit is ingesteld op waar.
kbNumbersToExclude	string[]	Kbs die moeten worden uitgesloten in de patchbewerking
kbNumbersToInclude	string[]	Kbs die moeten worden opgenomen in de patchbewerking
maxPatchPublishDate	string (date-time)	Dit wordt gebruikt om patches te installeren die zijn gepubliceerd op of vóór deze maximale gepubliceerde datum.
patchNameMasksToExclude	string[]	Dit wordt gebruikt om patches uit te sluiten die overeenkomen met de gegeven patchnaammaskers. Alfanumerieke tekenreeksen en jokertekenexpressies bestaande uit * en ? worden alleen ondersteund als invoerwaarden in de lijst. Null-, lege en alleen spaties-tekenreeksen als invoerwaarden worden niet ondersteund.
patchNameMasksToInclude	string[]	Dit wordt gebruikt om patches op te nemen die overeenkomen met de gegeven patchnaammaskers. Alfanumerieke tekenreeksen en jokertekenexpressies bestaande uit * en ? worden alleen ondersteund als invoerwaarden in de lijst. Null-, lege en alleen spaties-tekenreeksen als invoerwaarden worden niet ondersteund.