_Classe de processus Win32

La classe WMI de _ processus Win32 représente un processus sur un système d’exploitation.

La syntaxe suivante est simplifiée par rapport au code MOF (Managed Object Format) et inclut toutes les propriétés héritées.

Notes

pour une présentation générale des processus et des threads dans Windows, consultez la rubrique processus et threads.

Syntaxe

[Dynamic, Provider("CIMWin32"), SupportsCreate, CreateBy("Create"), SupportsDelete, DeleteBy("DeleteInstance"), UUID("{8502C4DC-5FBB-11D2-AAC1-006008C78BC7}"), DisplayName("Processes"), AMENDMENT]
class Win32_Process : CIM_Process
{
  string   CreationClassName;
  string   Caption;
  string   CommandLine;
  datetime CreationDate;
  string   CSCreationClassName;
  string   CSName;
  string   Description;
  string   ExecutablePath;
  uint16   ExecutionState;
  string   Handle;
  uint32   HandleCount;
  datetime InstallDate;
  uint64   KernelModeTime;
  uint32   MaximumWorkingSetSize;
  uint32   MinimumWorkingSetSize;
  string   Name;
  string   OSCreationClassName;
  string   OSName;
  uint64   OtherOperationCount;
  uint64   OtherTransferCount;
  uint32   PageFaults;
  uint32   PageFileUsage;
  uint32   ParentProcessId;
  uint32   PeakPageFileUsage;
  uint64   PeakVirtualSize;
  uint32   PeakWorkingSetSize;
  uint32   Priority = NULL;
  uint64   PrivatePageCount;
  uint32   ProcessId;
  uint32   QuotaNonPagedPoolUsage;
  uint32   QuotaPagedPoolUsage;
  uint32   QuotaPeakNonPagedPoolUsage;
  uint32   QuotaPeakPagedPoolUsage;
  uint64   ReadOperationCount;
  uint64   ReadTransferCount;
  uint32   SessionId;
  string   Status;
  datetime TerminationDate;
  uint32   ThreadCount;
  uint64   UserModeTime;
  uint64   VirtualSize;
  string   WindowsVersion;
  uint64   WorkingSetSize;
  uint64   WriteOperationCount;
  uint64   WriteTransferCount;
};

Membres

La classe de _ processus Win32 possède les types de membres suivants :

Méthodes

La classe de _ processus Win32 possède ces méthodes.

Méthode Description
AttachDebugger Lance le débogueur actuellement inscrit pour un processus.
Créer Crée un nouveau processus.
GetAvailableVirtualSize Récupère la taille actuelle, en octets, de l’espace d’adressage virtuel libre disponible pour le processus.
Windows Server 2012, Windows 8, Windows 7, Windows Server 2008 et Windows Vista : cette méthode n’est pas prise en charge avant Windows 8.1 et Windows Server 2012 R2.
GetOwner Récupère le nom d’utilisateur et le nom de domaine sous lesquels le processus s’exécute.
GetOwnerSid Récupère l’identificateur de sécurité (SID) pour le propriétaire d’un processus.
SetPriority Modifie la priorité d’exécution d’un processus.
Terminate Met fin à un processus et à tous ses threads.

Propriétés

La classe de _ processus Win32 a ces propriétés.

Caption

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : MaxLen (64), DisplayName (« Caption »)

Description succincte d’un objet : chaîne d’une ligne.

Cette propriété est héritée de CIM _ ManagedSystemElement.

CommandLine

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : DisplayName (« ligne de commande pour démarrer le processus »)

Ligne de commande utilisée pour démarrer un processus spécifique, le cas échéant.

CreationClassName

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : _ clé CIM, MaxLen (256), DisplayName ("nom de la classe")

Nom de la classe ou de la sous-classe utilisée dans la création d’une instance. Lorsqu’elle est utilisée avec d’autres propriétés de clé de la classe, cette propriété autorise l’identification unique de toutes les instances de la classe et de ses sous-classes.

Cette propriété est héritée du _ processus CIM.

CreationDate

Type de données : DateTime

Type d'accès : Lecture seule

Qualificateurs : fixed, DisplayName ("CreationDate")

Date à laquelle le processus commence à s’exécuter.

Cette propriété est héritée du _ processus CIM.

CSCreationClassName

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : propagé ("CIM _ OperatingSystem.CSCreationClassName"), _ clé CIM, MaxLen (256), DisplayName (" Computer System Class Name ")

Nom de la classe de création du système d’étendue de l’ordinateur.

Cette propriété est héritée du _ processus CIM.

CSName

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : propagé ("CIM _ OperatingSystem.CSName"), _ clé CIM, MaxLen (256), DisplayName (" nom du système de l’ordinateur ")

Nom du système informatique d’étendue.

Cette propriété est héritée du _ processus CIM.

Description

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : DisplayName ("Description")

Description d’un objet.

Cette propriété est héritée de CIM _ ManagedSystemElement.

ExecutablePath

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : Privileges ("SeDebugPrivilege"), MappingStrings ("win32api | Tool Help structures | MODULEENTRY32 | szExePath"), DisplayName ("exécutable path")

Chemin d’accès au fichier exécutable du processus.

exemple : « C : \ Windows \ système \Explorer.Exe »

ExecutionState

Type de données : UInt16

Type d'accès : Lecture seule

Qualificateurs : DisplayName (« état d’exécution »)

État de fonctionnement actuel du processus.

Cette propriété est héritée du _ processus CIM.

Inconnu (0)

Unknown

Autre (1)

Autres

Prêt (2)

En cours d’exécution (3)

Bloqué (4)

Bloqué

Suspendu bloqué (5)

Suspendu prêt (6)

Terminé (7)

Arrêté (8)

Développement (9)

Handle

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : clé, MaxLen (256), DisplayName (« handle »)

Identificateur de processus.

Cette propriété est héritée du _ processus CIM.

HandleCount

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | HandleCount"), DisplayName ("handle Count")

Nombre total de handles ouverts détenus par le processus. HandleCount est la somme des handles actuellement ouverts par chaque thread dans ce processus. Un descripteur est utilisé pour examiner ou modifier les ressources système. Chaque descripteur a une entrée dans une table qui est gérée en interne. Les entrées contiennent les adresses des ressources et des données pour identifier le type de ressource.

InstallDate

Type de données : DateTime

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("MIF. DMTF | ComponentID | 001,5 "), DisplayName (" date d’installation ")

Date d’installation d’un objet. L’objet peut être installé sans qu’une valeur ne soit écrite dans cette propriété.

Cette propriété est héritée de CIM _ ManagedSystemElement.

KernelModeTime

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : override ("KernelModeTime"), Units ("100 nanoseconds")

Temps en mode noyau, en millisecondes. Si ces informations ne sont pas disponibles, utilisez la valeur 0 (zéro).

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

MaximumWorkingSetSize

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : Privileges ("SeDebugPrivilege"), MappingStrings ("Win32 | winnt. H | limites de quota _ | MaximumWorkingSetSize "), DisplayName (" taille maximale de la plage de travail "), unités (" kilo-octets ")

Taille maximale du jeu de travail du processus. La plage de travail d’un processus correspond à l’ensemble des pages mémoire visibles par le processus dans la mémoire RAM physique. Ces pages sont résidentes et peuvent être utilisées par une application sans déclencher une erreur de page.

Exemple : 1413120

MinimumWorkingSetSize

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : Privileges ("SeDebugPrivilege"), MappingStrings ("Win32 | winnt. H | limites de quota _ | MinimumWorkingSetSize "), DisplayName (" taille minimale du jeu de travail "), unités (" kilo-octets ")

Taille minimale du jeu de travail du processus. La plage de travail d’un processus correspond à l’ensemble des pages mémoire visibles par le processus dans la mémoire RAM physique. Ces pages résident et peuvent être utilisées par une application sans déclencher de défaillance de page.

Exemple : 20480

Nom

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : DisplayName ("Name")

Nom du fichier exécutable responsable du processus, équivalent à la propriété nom de l’image dans le gestionnaire des tâches.

Lorsqu’elle est héritée par une sous-classe, la propriété peut être substituée pour être une propriété de clé. Le nom est codé en dur dans l’application elle-même et n’est pas affecté par la modification du nom de fichier. Par exemple, même si vous renommez Calc.exe, le nom Calc.exe apparaîtra toujours dans le gestionnaire des tâches et dans tous les scripts WMI qui récupèrent le nom du processus.

Cette propriété est héritée de CIM _ ManagedSystemElement.

OSCreationClassName

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : propagé ("CIM _ OperatingSystem.CreationClassName"), _ clé CIM, MaxLen (256), DisplayName (" nom de la classe du système d’exploitation ")

Nom de la classe de création du système d’exploitation d’étendue.

Cette propriété est héritée du _ processus CIM.

OSName

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : propagé ("CIM _ OperatingSystem.Name"), _ clé CIM, MaxLen (256), DisplayName (" nom du système d’exploitation ")

Nom du système d’exploitation de portée.

Cette propriété est héritée du _ processus CIM.

OtherOperationCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | System _ process _ information | OtherOperationCount"), DisplayName ("Other Operation Count")

Nombre d’opérations d’e/s effectuées qui ne sont pas des opérations de lecture ou d’écriture.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

OtherTransferCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | System _ process _ information | OtherTransferCount"), DisplayName ("Other Transfer Count"), Units ("bytes")

Quantité de données transférées pendant les opérations qui ne sont pas des opérations de lecture ou d’écriture.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

PageFaults

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | PageFaultCount"), DisplayName ("nombre de défauts de page")

Nombre de défauts de page générés par un processus.

Exemple : 10

PageFileUsage

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | PagefileUsage"), DisplayName ("page file usage"), Units ("kilo-octets")

Quantité d’espace de fichier d’échange actuellement utilisée par un processus. Cette valeur est cohérente avec la valeur VMSize dans TaskMgr.exe.

Exemple : 102435

ParentProcessId

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api process | Status | System _ process _ information | InheritedFromUniqueProcessId"), DisplayName ("parent Process ID")

Identificateur unique du processus qui crée un processus. Les numéros d’identificateur de processus sont réutilisés, donc ils identifient uniquement un processus pendant la durée de vie de ce processus. Il est possible que le processus identifié par ParentProcessId soit terminé, de sorte que ParentProcessId ne peut pas faire référence à un processus en cours d’exécution. Il est également possible que ParentProcessId fasse incorrectement référence à un processus qui réutilise un identificateur de processus. Vous pouvez utiliser la propriété CreationDate pour déterminer si le parent spécifié a été créé après la création du processus représenté par cette instance de _ processus Win32 .

PeakPageFileUsage

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | PeakPagefileUsage"), DisplayName ("PIC utilisation du fichier d’échange"), Units ("kilo-octets")

Quantité maximale d’espace de fichier d’échange utilisée pendant la durée de vie d’un processus.

Exemple : 102367

PeakVirtualSize

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | PeakVirtualSize"), DisplayName ("PIC utilisation de l’espace d’adressage virtuelle"), Units ("bytes")

Espace d’adressage virtuel maximal qu’un processus utilise à un moment donné. L’utilisation de l’espace d’adressage virtuel n’implique pas nécessairement l’utilisation correspondante du disque ou des pages de mémoire principales. Toutefois, l’espace virtuel est fini, et en utilisant trop de temps, le processus peut ne pas être en mesure de charger des bibliothèques.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

PeakWorkingSetSize

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings (« win32api | Process status | System _ process _ information | PeakWorkingSetSize »), DisplayName (« Peak Working Set Size »), Units (« kilo-octets »)

Taille maximale de la plage de travail d’un processus.

Exemple : 1413120

Priorité

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : override (« Priority »), MappingStrings (« win32api | Process status | System _ process _ information | BasePriority »), DisplayName (« Priority »)

Priorité de planification d’un processus dans un système d’exploitation. Plus la valeur est élevée, plus le processus reçoit la priorité la plus élevée. Les valeurs de priorité peuvent être comprises entre 0 (zéro), qui est la priorité la plus faible à 31, qui est la priorité la plus élevée.

Exemple : 7

PrivatePageCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | PrivatePageCount"), DisplayName ("Private page Count")

Nombre actuel de pages allouées qui sont uniquement accessibles au processus représenté par cette instance de _ processus Win32 .

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

ProcessId

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | process _ information | DwProcessId"), DisplayName ("Process ID")

Identificateur numérique utilisé pour distinguer un processus d’un autre. Les ProcessIDs sont valides à partir de l’heure de création du processus pour traiter l’arrêt. Lors de l’arrêt, ce même identificateur numérique peut être appliqué à un nouveau processus.

Cela signifie que vous ne pouvez pas utiliser ProcessID seul pour surveiller un processus particulier. Par exemple, une application peut avoir un ProcessID de 7, puis échouer. Lors du démarrage d’un nouveau processus, ProcessID 7 peut être affecté au nouveau processus. Un script qui vérifie uniquement un ProcessID spécifié peut donc être « trompeur » pour penser que l’application d’origine était toujours en cours d’exécution.

QuotaNonPagedPoolUsage

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | QuotaNonPagedPoolUsage"), DisplayName ("quota d’utilisation de réserve non paginée")

Quota d’utilisation de la réserve non paginée pour un processus.

Exemple : 15

QuotaPagedPoolUsage

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | QuotaPagedPoolUsage"), DisplayName ("quota d’utilisation de la réserve paginée")

Quota d’utilisation de la réserve paginée pour un processus.

Exemple : 22

QuotaPeakNonPagedPoolUsage

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings (« win32api | Process status | System _ process _ information | QuotaPeakNonPagedPoolUsage »), DisplayName (« quota de pic d’utilisation du pool non paginé »)

Quota de pic d’utilisation de la réserve non paginée pour un processus.

Exemple : 31

QuotaPeakPagedPoolUsage

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings (« win32api | Process status | System _ process _ information | QuotaPeakPagedPoolUsage »), DisplayName (« quota d’utilisation maximale de la réserve paginée »)

Quota de pic d’utilisation de la réserve paginée pour un processus.

Exemple : 31

ReadOperationCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | System _ process _ information | ReadOperationCount"), DisplayName ("Read Operation Count")

Nombre d’opérations de lecture effectuées.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

ReadTransferCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | System _ process _ information | ReadTransferCount"), DisplayName ("Read Transfer Count"), Units ("bytes")

Quantité de données lues.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

SessionId

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings (« win32api | Process status | System _ process _ information | SessionID »), DisplayName (« ID de session »)

Identificateur unique généré par un système d’exploitation lors de la création d’une session. Une session s’étend sur un laps de temps à partir d’une ouverture de session jusqu’à la fermeture d’un système spécifique.

État

Type de données : chaîne

Type d'accès : Lecture seule

Qualificateurs : MaxLen (10), DisplayName ("Status")

Cette propriété n’est pas implémentée et n’est pas remplie pour une instance de cette classe. La valeur est toujours null.

Cette propriété est héritée de CIM _ ManagedSystemElement.

Les valeurs sont notamment les suivantes :

OK (« OK »)

Erreur (« erreur »)

Détérioré (« détérioré »)

Inconnu ("inconnu")

Échec prévu (« échec prédit »)

Démarrage en cours (« démarrage »)

Arrêt en cours (« arrêt »)

Service (« service »)

Stressed (« stressed »)

Non récupéré (« non récupéré »)

Aucun contact (« aucun contact »)

Communication perdue (« inversée comm »)

TerminationDate

Type de données : DateTime

Type d'accès : Lecture seule

Qualificateurs : DisplayName ("date d’arrêt")

Le processus a été arrêté ou arrêté. Pour obtenir l’heure de fin, un descripteur du processus doit être maintenu ouvert. Sinon, cette propriété retourne la valeur null.

Cette propriété est héritée du _ processus CIM.

ThreadCount

Type de données : UInt32

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | NumberOfThreads"), DisplayName ("nombre de threads")

Nombre de threads actifs dans un processus. Une instruction est l’unité d’exécution de base dans un processeur, et un thread est l’objet qui exécute une instruction. Chaque processus en cours d’exécution possède au moins un thread.

UserModeTime

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : override ("UserModeTime"), Units ("100 nanoseconds")

Heure en mode utilisateur, en unités de nanosecondes 100. Si ces informations ne sont pas disponibles, utilisez la valeur 0 (zéro).

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

VirtualSize

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process status | System _ process _ information | VirtualSize"), DisplayName ("utilisation de l’espace d’adressage virtuel"), Units ("bytes")

Taille actuelle de l’espace d’adressage virtuel utilisé par un processus, et non de la mémoire physique ou virtuelle réellement utilisée par le processus. L’utilisation de l’espace d’adressage virtuel n’implique pas nécessairement l’utilisation correspondante du disque ou des pages de mémoire principales. L’espace virtuel est fini, et en utilisant trop, le processus peut ne pas être en mesure de charger des bibliothèques. Cette valeur est cohérente avec ce que vous voyez dans Perfmon.exe.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

WindowsVersion

Type de données : chaîne

Type d'accès : Lecture seule

qualificateurs : MappingStrings ("Win32API | Process and Thread functions | GetProcessVersion"), DisplayName ("Windows Version")

Version de Windows dans laquelle le processus est en cours d’exécution.

Exemple : 4,0

WorkingSetSize

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : DisplayName (« taille de la plage de travail »), unités (« octets »)

Quantité de mémoire en octets qu’un processus doit exécuter efficacement : pour un système d’exploitation qui utilise la gestion de la mémoire basée sur les pages. Si le système ne dispose pas de suffisamment de mémoire (inférieure à la taille de la plage de travail), une surcharge se produit. Si la taille de la plage de travail n’est pas connue, utilisez la valeur null ou 0 (zéro). Si vous fournissez des données de jeu de travail, vous pouvez surveiller les informations pour comprendre les besoins en mémoire en constante évolution d’un processus.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

Cette propriété est héritée du _ processus CIM.

WriteOperationCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | System _ process _ information | WriteOperationCount"), DisplayName ("Write opération Count")

Nombre d’opérations d’écriture effectuées.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

WriteTransferCount

Type de données : UInt64

Type d'accès : Lecture seule

Qualificateurs : MappingStrings ("win32api | Process and thread structures | System _ process _ information | WriteTransferCount"), DisplayName ("Write Transfer Count"), Units ("bytes")

Quantité de données écrites.

Pour plus d’informations sur l’utilisation des valeurs UInt64 dans les scripts, consultez scripts dans WMI.

Notes

La classe de _ processus Win32 est dérivée du _ processus CIM. le processus appelant qui utilise cette classe doit avoir le privilège SE _ restore _ NAME sur l’ordinateur où se trouve le registre. Pour plus d’informations, consultez exécution d’opérations privilégiées.

Vue d’ensemble

Les processus sous-tendent presque tout ce qui se produit sur un ordinateur. En fait, la cause racine de la plupart des problèmes informatiques peut être tracée sur les processus. par exemple, un trop grand nombre de processus peuvent s’exécuter sur un ordinateur (et être en conflit avec un ensemble fini de ressources), ou un processus unique peut utiliser plus que son partage de ressources. Ces facteurs compliquent le suivi des processus en cours d’exécution sur un ordinateur. La surveillance des processus, l’activité principale de la gestion des processus, vous permet de déterminer ce qu’est réellement un ordinateur, les applications que l’ordinateur exécute et la manière dont ces applications sont affectées par les modifications dans l’environnement informatique.

Surveillance d’un processus

La surveillance régulière des processus vous permet de vous assurer qu’un ordinateur fonctionne aux pics d’activité et qu’il exécute ses tâches nommées comme prévu. Par exemple, en surveillant les processus, vous pouvez être averti immédiatement de toute application qui ne répond plus, puis prendre les mesures nécessaires pour terminer ce processus. En outre, le processus d’analyse vous permet d’identifier les problèmes avant qu’ils ne se produisent. Par exemple, en vérifiant de manière répétée la quantité de mémoire utilisée par un processus, vous pouvez identifier une fuite de mémoire. Vous pouvez ensuite arrêter le processus avant que l’application errante n’utilise toute la mémoire disponible et met l’ordinateur en arrêt.

La surveillance des processus permet également de réduire les perturbations causées par des interruptions planifiées des mises à niveau et de la maintenance. Par exemple, en vérifiant l’état d’une application de base de données qui s’exécute sur les ordinateurs clients, vous pouvez déterminer l’impact de la mise hors connexion de la base de données afin de mettre à niveau le logiciel.

Surveillance de la disponibilité du processus. Mesure le pourcentage de temps pendant lequel un processus est disponible. La disponibilité est généralement surveillée à l’aide d’une sonde simple, qui indique si le processus est toujours en cours d’exécution. En effectuant le suivi des résultats de chaque sonde, vous pouvez calculer la disponibilité du processus. Par exemple, un processus qui est interrogé 100 fois et qui répond sur 95 de ces occasions a une disponibilité de 95%. Ce type de surveillance est généralement réservé aux bases de données, aux programmes de messagerie et aux autres applications censées s’exécuter à tout moment. Il n’est pas approprié pour les programmes de traitement de texte, les feuilles de calcul ou d’autres applications qui sont régulièrement démarrés et arrêtés plusieurs fois par jour.

Vous pouvez créer une instance de la classe Win32 _ ProcessStartup pour configurer le processus.

Vous pouvez surveiller les performances des processus avec la classe de _ _ _ processus perfproc Win32 PerfFormattedData et un objet d’actualisation WMI, tel que SWbemRefresher. Pour plus d’informations, consultez analyse des données de performances.

Exemples

la liste des propriétés de l’exemple de code PowerShell des Classes WMI dans la galerie TechNet décrit la classe de _ processus Win32 et renvoie les résultats au format Excel.

Le processus de fin d’exécution sur plusieurs serveurs met fin à un processus s’exécutant sur un ou plusieurs ordinateurs.

Dans l' exemple : appel d’une rubrique de méthode de fournisseur, le code utilise C++ pour appeler le _ processus Win32 afin de créer un processus.

La disponibilité est la forme la plus simple d’analyse de processus : avec cette approche, vous vous assurez simplement que le processus est en cours d’exécution. Lorsque vous surveillez la disponibilité du processus, vous récupérez généralement une liste des processus en cours d’exécution sur un ordinateur, puis vous vérifiez qu’un processus particulier est toujours actif. Si le processus est actif, il est considéré comme disponible. Si le processus n’est pas actif, il n’est pas disponible. L’exemple VBScript suivant surveille la disponibilité des processus en vérifiant la liste des processus en cours d’exécution sur un ordinateur et en émettant une notification si le processus de Database.exe est introuvable.

strComputer = "."
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colProcesses = objWMIService.ExecQuery("SELECT * FROM Win32_Process WHERE Name = 'Database.exe'")
If colProcesses.Count = 0 Then
 Wscript.Echo "Database.exe is not running."
Else
 Wscript.Echo "Database.exe is running."
End If

L’exemple VBScript suivant surveille la création de processus à l’aide d’un consommateur d’événements temporaire.

strComputer = "."
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colMonitoredProcesses = objWMIService.ExecNotificationQuery("SELECT * FROM __InstanceCreationEvent " _
                                                     & "WITHIN 10 WHERE TargetInstance ISA 'Win32_Process'")
i = 0
Do While i = 0
 Set objLatestProcess = colMonitoredProcesses.NextEvent
 Wscript.Echo objLatestProcess.TargetInstance.Name, Now
Loop

Le VBScript suivant surveille les informations sur les performances du processus.

strComputer = "."
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colProcessList = objWMIService.ExecQuery("SELECT * FROM Win32_Process")
For Each objProcess in colProcessList
 Wscript.Echo "Process: " & objProcess.Name
 Wscript.Echo "Process ID: " & objProcess.ProcessID
 Wscript.Echo "Thread Count: " & objProcess.ThreadCount
 Wscript.Echo "Page File Size: " & objProcess.PageFileUsage
 Wscript.Echo "Page Faults: " & objProcess.PageFaults
 Wscript.Echo "Working Set Size: " & objProcess.WorkingSetSize
Next

L’exemple de code VBScript suivant montre comment obtenir le propriétaire de chaque processus sur un ordinateur local. Vous pouvez utiliser ce script pour obtenir des données à partir d’un ordinateur distant, par exemple, pour déterminer quels utilisateurs ont des processus exécutant Terminal Server, remplacez le nom de l’ordinateur distant par « . » sur la première ligne. Vous devez également être administrateur sur l’ordinateur distant.

strComputer = "." 
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")

Set colProcesses = objWMIService.ExecQuery("select * from win32_process" )
For Each objProcess in colProcesses

  If objProcess.GetOwner ( User, Domain ) = 0 Then
    Wscript.Echo "Process " & objProcess.Caption & " belongs to " & Domain & "\" & User
  Else
    Wscript.Echo "Problem " & Rtn & " getting the owner for process " & objProcess.Caption
  End If
Next

L’exemple de code VBScript suivant montre comment obtenir la session d’ouverture de session associée à un processus en cours d’exécution. Un processus doit être en cours d’exécution Notepad.exe avant le démarrage du script. L’exemple localise les instances de _ LogonSession Win32 associées au _ processus Win32 qui représente Notepad.exe. Win32 _ SessionProcess est spécifié en tant que classe d’association. Pour plus d’informations, consultez ASSOCIATORS OF Statement.

On error resume next
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\.\root\cimv2")
Set colProcesses = objWMIService.ExecQuery("Select * from Win32_Process Where Name = 'Notepad.exe'")
For Each objProcess in colProcesses
  ProcessId = objProcess.ProcessId
  Set colLogonSessions = objWMIService.ExecQuery("Associators of {Win32_Process='" & ProcessId & "'} " _
                                               & "Where Resultclass = Win32_LogonSession Assocclass = Win32_SessionProcess", "WQL", 48)
  If Err <> 0 Then
    WScript.Echo "Error on associators query= " & Err.number & " " & Err.Description
    WScript.Quit
  End If
  For Each LogonSession in colLogonSessions
    Wscript.Echo " Logon id is " & LogonSession.LogonId
  Next
Next

Spécifications

Condition requise Valeur
Client minimal pris en charge
Windows Vista
Serveur minimal pris en charge
Windows Server 2008
Espace de noms
\Cimv2 racine
MOF
CIMWin32. mof
DLL
CIMWin32.dll

Voir aussi

_Processus CIM

Classes du système d’exploitation

Tâches WMI : processus