Registre Microsoft Ref

Contents
Windows System Information

Handles et objets
À propos des handles et des objets
Gestionnaire d’objets
Interface d’objet
Limitations des handles
Gérer l’héritage
Catégories d’objets
Objets utilisateur
Objets GDI
Objets de noyau
Handle et référence d’objet
Handle et fonctions d’objet
CloseHandle
CompareObjectHandles
DuplicateHandle
GetHandleInformation
SetHandleInformation
Registre
À propos du Registre
Structure du Registre
espace de Stockage du registre
Clés prédéfinies
Clé de HKEY_CLASSES_ROOT
Vue fusionnée de HKEY_CLASSES_ROOT
Ruches du Registre
Catégories de données
Ouverture, création et fermeture de clés
Écriture et suppression de données de Registre
Récupération de données à partir du Registre
Fichiers du Registre
Sécurité de la clé de Registre et droits d’accès
Données d’application 32 bits et 64 bits dans le registre
Virtualisation du Registre
Utilisation du Registre
Énumération des sous-clés du Registre
Suppression d’une clé avec des sous-clés
Détermination de la taille du Registre
Référence du Registre
Fonctions du Registre
GetPrivateProfileInt
GetPrivateProfileSection
GetPrivateProfileSectionNames
GetPrivateProfileString
GetPrivateProfileStruct
GetProfileInt
GetProfileSection
GetProfileString
Échec RegCloseKey
RegConnectRegistry
RegCopyTree
RegCreateKey
RegCreateKeyEx
RegCreateKeyTransacted
RegDeleteKey
RegDeleteKeyEx
RegDeleteKeyTransacted
RegDeleteKeyValue
RegDeleteTree
RegDeleteValue
RegDisablePredefinedCache
RegDisablePredefinedCacheEx
RegDisableReflectionKey
RegEnableReflectionKey
RegEnumKey
RegEnumKeyEx
RegEnumValue
Regflushkey a
RegGetValue
RegLoadAppKey
RegLoadKey
RegLoadMUIString
RegNotifyChangeKeyValue
RegOpenCurrentUser
RegOpenKey
RegOpenKeyEx
RegOpenKeyTransacted
RegOpenUserClassesRoot
RegOverridePredefKey
RegQueryInfoKey
RegQueryMultipleValues
RegQueryReflectionKey
RegQueryValue
RegQueryValueEx
RegReplaceKey
RegRestoreKey
RegSaveKey
RegSaveKeyEx
RegSetKeyValue
RegSetValue
RegSetValueEx
RegUnLoadKey
WritePrivateProfileSection
WritePrivateProfileString
WritePrivateProfileStruct
WriteProfileSection
WriteProfileString
Structures du Registre
FRÉQUENT
Limites de taille des éléments du Registre
Types de valeur de Registre
Informations système
À propos de System Information
Hardware Configuration
Noms d'ordinateur
Version du système d'exploitation
Configuration du système d’exploitation
Utilisation de System Information
accéder aux informations SMBIOS à partir d’une application de Windows universel
accéder aux variables de microprogramme UEFI à partir d’une application
Windows universelle
Obtention de System Information
Obtention de la version du système
Vérification de la version du système
Détection d’une suite de produits
Obtention d’informations sur le matériel
Ciblage de votre application pour Windows
System Information Faire
System Information Mission
ApiSetQueryApiSetPresence
CeipIsOptedIn
DnsHostnameToComputerName
EnumSystemFirmwareTables
ExpandEnvironmentStrings
GetComputerName
GetComputerNameEx
GetComputerObjectName
GetCurrentHwProfile
GetFirmwareEnvironmentVariable
GetFirmwareEnvironmentVariableEx
GetFirmwareType
GetIntegratedDisplaySize
GetNativeSystemInfo
GetProductInfo
GetSystemDirectory
GetSystemFirmwareTable
GetSystemInfo
GetSystemRegistryQuota
GetSystemWindowsDirectory
GetSystemWow64Directory
GetSystemWow64Directory2
GetUserName
GetUserNameEx
GetVersion
Tourne
GetWindowsDirectory
IsNativeVhdBoot
IsProcessorFeaturePresent
IsWow64GuestMachineSupported
NtQuerySystemInformation
QueryPerformanceCounter
QueryPerformanceFrequency
RtlGetSuiteMask
SetComputerName
SetComputerNameEx
SetFirmwareEnvironmentVariable
SetFirmwareEnvironmentVariableEx
TranslateName
VerifyVersionInfo
VerSetConditionMask
Fonctions d’assistance de version
IsWindows10OrGreater
IsWindows7OrGreater
IsWindows7SP1OrGreater
IsWindows8OrGreater
IsWindows8Point1OrGreater
IsWindowsServer
IsWindowsVistaOrGreater
IsWindowsVistaSP1OrGreater
IsWindowsVistaSP2OrGreater
IsWindowsXPOrGreater
IsWindowsXPSP1OrGreater
IsWindowsVersionOrGreater
ZwQuerySystemInformation
System Information Celles
HW_PROFILE_INFO
OSVERSIONINFO
OSVERSIONINFOEX
SYSTEM_INFO
System Information Macros
VER_SET_CONDITION
System Information Types énumération
COMPUTER_NAME_FORMAT
EXTENDED_NAME_FORMAT
FIRMWARE_TYPE
Constantes d’ordinateur de fichier image
Temps
À propos du temps
Temps système
Heure locale
Heures du fichier
Date et heure MS-DOS
Horloge Windows
Temps d’interruption
Utilisation de l’heure
Récupération de l’heure de Last-Write
Modification de l’heure d’un fichier à l’heure actuelle
Conversion d’une valeur time_t en heure de fichier
Acquisition d’horodatages haute résolution
Référence temporelle
Fonctions d’heure
CompareFileTime
ConvertAuxiliaryCounterToPerformanceCounter
ConvertPerformanceCounterToAuxiliaryCounter
DosDateTimeToFileTime
EnumDynamicTimeZoneInformation
FileTimeToDosDateTime
FileTimeToLocalFileTime
FileTimeToSystemTime
GetDynamicTimeZoneInformation
GetDynamicTimeZoneInformationEffectiveYears
GetFileTime
GetLocalTime
GetSystemTime
GetSystemTimeAdjustment
GetSystemTimeAdjustmentPrecise
GetSystemTimeAsFileTime
GetSystemTimePreciseAsFileTime
GetSystemTimes
GetTickCount
GetTickCount64
GetTimeZoneInformation
GetTimeZoneInformationForYear
LocalFileTimeToFileTime
NtQuerySystemTime
QueryAuxiliaryCounterFrequency
QueryInterruptTime
QueryInterruptTimePrecise
QueryUnbiasedInterruptTime
QueryUnbiasedInterruptTimePrecise
RtlLocalTimeToSystemTime
RtlTimeToSecondsSince1970
SetDynamicTimeZoneInformation
SetFileTime
SetLocalTime
SetSystemTime
SetSystemTimeAdjustment
SetSystemTimeAdjustmentPrecise
SetTimeZoneInformation
SystemTimeToFileTime
SystemTimeToTzSpecificLocalTime
SystemTimeToTzSpecificLocalTimeEx
TzSpecificLocalTimeToSystemTime
TzSpecificLocalTimeToSystemTimeEx
Structures d’heure
DYNAMIC_TIME_ZONE_INFORMATION
FILETIME
SYSTEMTIME
TIME_ZONE_INFORMATION
Messages de temps
WM_TIMECHANGE
Fournisseur de temps
Création d’un fournisseur de temps
Inscription d’un fournisseur de temps
Exemple de fournisseur de temps
Référence du fournisseur de temps
Fonctions du fournisseur de temps
AlertSamplesAvailFunc
GetTimeSysInfoFunc
LogTimeProvEventFunc
SetProviderStatusFunc
SetProviderStatusInfoFreeFunc
TimeProvClose
TimeProvCommand
TimeProvOpen
Structures du fournisseur de temps
SetProviderStatusInfo
TimeProvSysCallbacks
TimeSample
TpcGetSamplesArgs
Plateforme d’évaluation WaaS
À propos de la plateforme d’évaluation WaaS
Utilisation de la plateforme d’évaluation WaaS
Référence d’évaluation de WaaS
Structures d’évaluation de WaaS
OSUpdateAssessment
UpdateAssessment
Énumérations d’évaluation de WaaS
UpdateAssessmentStatus
UpdateImpactLevel
Interfaces d’évaluation de WaaS
IWaaSAssessor
Méthode GetOSUpdateAssessment
Windows System Information
20/08/2021 • 2 minutes to read
Les vues d’ensemble suivantes décrivent les types d’informations système disponibles.
VUE D’EN SEM B L E DESC RIP T IO N
Handles et objets Un objet est une structure de données qui représente une
ressource système, telle qu’un fichier, un thread ou une
image graphique. Une application ne peut pas accéder
directement aux données d’objet ou aux ressources système
qu’un objet représente. Au lieu de cela, une application doit
obtenir un descripteur d’objet, qu’elle peut utiliser pour
examiner ou modifier la ressource système.
Registre Base de données définie par le système dans laquelle les

applications et le système stockent et récupèrent les
informations de configuration.
Informations système Récupère ou définit la configuration système, les paramètres,

la version et les métriques.
Time Récupère ou définit l’heure système.
Fournisseur de temps Récupère des horodatages précis à partir du matériel ou du

réseau, et fournit des horodateurs à d’autres clients sur le
réseau.
Plateforme d’évaluation WaaS la plateforme d’évaluation des mises à jour WaaS (Windows
as a Service) fournit des informations sur les mises à jour de
Windows d’un appareil.
Ressources supplémentaires
ÉL ÉM EN T DESC RIP T IO N
Forum sur les problèmes généraux de développement discutez Windows System Information et d’autres problèmes
Windows généraux liés au développement d’applications pour
Windows.
Handles et objets
Un objet est une structure de données qui représente une ressource système, telle qu’un fichier, un thread ou
une image graphique. Une application ne peut pas accéder directement aux données d’objet ou aux ressources
système qu’un objet représente. Au lieu de cela, une application doit obtenir un descripteur d’objet, qu’elle peut
utiliser pour examiner ou modifier la ressource système. Chaque descripteur a une entrée dans une table gérée
en interne. Ces entrées contiennent les adresses des ressources et les moyens d’identifier le type de ressource.
Le système utilise des objets et des handles pour réguler l’accès aux ressources système pour deux raisons
principales. Tout d’abord, l’utilisation des objets garantit que Microsoft peut mettre à jour les fonctionnalités du
système, tant que l’interface d’objet d’origine est conservée. Lorsque des versions ultérieures du système sont
publiées, vous pouvez utiliser l’objet mis à jour avec peu ou pas de travail supplémentaire.
deuxièmement, l’utilisation d’objets vous permet de tirer parti de la sécurité Windows. Chaque objet possède sa
propre liste de contrôle d’accès (ACL) qui spécifie les actions qu’un processus peut effectuer sur l’objet. Le
système examine l’ACL d’un objet chaque fois qu’une application crée un handle pour l’objet. Pour obtenir plus
d'informations, voir Contrôle d'accès.
Interface d’objet
Espaces de noms d’objets
Un objet se compose d’un en-tête standard et d’attributs spécifiques à l’objet. Étant donné que tous les objets
ont la même structure, il existe un seul gestionnaire d’objets dans Windows qui gère tous les objets.
L’en-tête d’objet comprend des éléments tels que le nom de l’objet, afin que d’autres processus puissent faire
référence à l’objet par son nom et un descripteur de sécurité, afin que le gestionnaire d’objets puisse contrôler
les processus qui accèdent à la ressource système.
Les tâches exécutées par le gestionnaire d’objets sont les suivantes :
Création d'objets
Vérification qu’un processus a le droit d’utiliser l’objet
Création de handles d’objet et retour à l’appelant
Gestion des quotas de ressources
Création de descripteurs dupliqués
Fermeture des handles aux objets
Interface d’objet
Windows fournit des fonctions qui effectuent les tâches suivantes :

Créer un objet
Obtient un handle d’objet
Obtenir des informations sur l’objet
Définir les informations relatives à l’objet
Fermer le descripteur d’objet
Détruire l’objet
Certaines de ces tâches ne sont pas nécessaires pour chaque objet. Certaines de ces tâches sont combinées pour
certains objets. Par exemple, une application peut créer un objet d’événement. D’autres applications peuvent
ouvrir l’événement pour obtenir un descripteur unique de cet objet d’événement. À mesure que chaque
application se termine à l’aide de l’événement, elle ferme son handle vers l’objet. Lorsqu’il n’y a aucun
descripteur ouvert restant pour l’objet d’événement, le système détruit l’objet d’événement. En revanche, une
application peut obtenir un handle vers un objet Window existant. Lorsque l’objet Window n’est plus nécessaire,
l’application doit détruire l’objet, ce qui invalide le handle de fenêtre.
Parfois, un objet reste en mémoire après la fermeture de tous les handles d’objet. Par exemple, un thread peut
créer un objet d’événement et attendre le descripteur d’événement. Pendant que le thread attend, un autre
thread peut fermer le même handle d’objet d’événement. L’objet d’événement reste en mémoire, sans aucun
handle d’objet d’événement, jusqu’à ce que l’objet d’événement soit défini sur l’état signalé et que l’opération
d’attente soit terminée. À ce stade, le système supprime l’objet de la mémoire.
Les handles et les objets consomment de la mémoire. Par conséquent, pour préserver les performances du
système, vous devez fermer les handles et supprimer les objets dès qu’ils ne sont plus nécessaires. Si vous ne le
faites pas, votre application peut nuire aux performances du système, en raison d’une utilisation excessive du
fichier d’échange.
Lorsqu’un processus se termine, le système ferme automatiquement les handles et supprime les objets créés
par le processus. Toutefois, lorsqu’un thread se termine, le système ne ferme généralement pas les handles ou
ne supprime pas les objets. Les seules exceptions sont les objets Window, Hook, position de fenêtre et
conversation DDE (Dynamic Data Exchange). ces objets sont détruits lorsque le thread de création se termine.
Certains objets ne prennent en charge qu’un seul handle à la fois. Le système fournit le descripteur lorsqu’une
application crée l’objet et invalide le descripteur lorsque l’application détruit l’objet. Les autres objets prennent
en charge plusieurs descripteurs sur un seul objet. Le système d’exploitation supprime automatiquement l’objet
de la mémoire après la fermeture du dernier handle de l’objet.
Le nombre total de handles ouverts dans le système est limité uniquement par la quantité de mémoire
disponible. Certains types d’objets prennent en charge un nombre limité de handles par session ou par
processus.
Un processus enfant peut hériter de handles de son processus parent. Un handle hérité est valide uniquement
dans le contexte du processus enfant. Pour permettre à un processus enfant d’hériter des handles ouverts de
son processus parent, procédez comme suit.
1. Créez le descripteur avec le membre bInheritHandle de la structure des _ attributs de sécurité défini sur
true .
2. Créez le processus enfant à l’aide de la fonction CreateProcess , avec le paramètre BInheritHandles défini
sur true .
La fonction DuplicateHandle duplique un handle à utiliser dans le processus en cours ou dans un autre
processus. Si une application duplique l’un de ses descripteurs pour un autre processus, le handle dupliqué est
valide uniquement dans le contexte de l’autre processus.
Un handle dupliqué ou un handle hérité est une valeur unique, mais il fait référence au même objet que le
handle d’origine. Les processus peuvent hériter ou dupliquer des handles vers les types d’objets suivants :
Jeton d'accès
Appareil de communication
Entrée de la console
Mémoire tampon d’écran de la console
Bureau
Répertoire
Événement
Fichier
Mappage de fichiers
Travail
Mailslots
Mutex
Pipe
Process
Clé de Registre
Semaphore
Prise
Thread
Minuteur
Station Windows
Tous les autres objets sont privés pour le processus qui les a créés ; leurs handles d’objet ne peuvent pas être
dupliqués ou hérités.
Pour plus d’informations, consultez Héritage.
Le système fournit trois catégories d’objets : utilisateur, interface GDI (Graphics Device Interface) et noyau. Le
système utilise les objets utilisateur pour prendre en charge la gestion des fenêtres, les objets GDI pour prendre
en charge les graphiques et les objets noyau pour prendre en charge la gestion de la mémoire, l’exécution des
processus et les communications interprocessus (IPC). Pour plus d’informations sur la création et l’utilisation
d’un objet spécifique, reportez-vous à la vue d’ensemble associée.
O B JET UT IL ISAT EUR VUE D’EN SEM B L E
Table d’accélérateurs Raccourcis clavier
Signe insertion Signes
Curseur Curseurs
Conversation DDE Bibliothèque de gestion des échange dynamique de données
Hook Hooks
Icône Icônes
Menu Menus
Fenêtre Windows
Position de la fenêtre Windows
O B JET GDI VUE D’EN SEM B L E
Bitmap Images bitmap
Brush Pinceaux
DC Contextes de périphérique
Métafichier amélioré Métafichiers
Enhanced-Metafile DC Métafichiers
Police Polices et texte
Mémoire DC Contextes de périphérique
Métafichiers Métafichiers
DC de métafichier Métafichiers
O B JET GDI VUE D’EN SEM B L E
Palette Couleurs
Stylet et stylet étendu Stylets
Région Régions
O B JET DE N O YA U VUE D’EN SEM B L E
Access token (Jeton d’accès) Contrôle d’accès
Notification de modification Notifications de modification de répertoire
Appareil de communication Communications
Entrée de la console Applications en mode caractère
Mémoire tampon d’écran de la console Applications en mode caractère
Bureau Bureaux
Événement Synchronisation
Journal des événements Journalisation des événements
Fichier Fichiers et clusters
Mappage de fichiers Mappage de fichiers
Segment de mémoire (heap) Gestion de la mémoire
Travail Objets de traitement
Mailslots Boîtes
Module Bibliothèques de liens dynamiques
Mutex Synchronisation
Pipe Canaux
Process Processus et threads
Semaphore Synchronisation
Prise Windows Sockets 2
Thread Processus et threads
Minuteur Synchronisation
O B JET DE N O YA U VUE D’EN SEM B L E
File d’attente du minuteur Synchronisation
Minuteur-minuteur de file d’attente Synchronisation
Mettre à jour une ressource Ressources
Station Windows Stations Windows

Objets utilisateur
Les objets d’interface utilisateur ne prennent en charge qu’un seul handle par objet. Les processus ne peuvent
pas hériter ou dupliquer des handles d’objets utilisateur. Les processus d’une session ne peuvent pas faire
référence à un handle d’utilisateur dans une autre session.
Il existe une limite théorique de 65 536 descripteurs utilisateur par session. Toutefois, le nombre maximal de
descripteurs utilisateur qui peuvent être ouverts par session est généralement plus faible, car il est affecté par la
mémoire disponible. Il y a également une limite par processus par défaut des handles utilisateur. Pour modifier
cette limite, définissez la valeur de Registre suivante :
HKEY _ logiciel de l' _ ordinateur LOCAL \ \ Microsoft \ Windows NT \ CurrentVersion \ Windows \
USERProcessHandleQuota
Cette valeur peut être définie sur un nombre compris entre 200 et 18 000.
Handles vers des objets utilisateur

Les handles vers les objets utilisateur sont publics pour tous les processus. Autrement dit, tout processus peut
utiliser le handle d’objet utilisateur, à condition que le processus ait un accès de sécurité à l’objet.
Dans l’illustration suivante, une application crée un objet Window. La fonction CreateWindow crée l’objet de
fenêtre et retourne un handle d’objet.
Une fois l’objet Window créé, l’application peut utiliser le handle de fenêtre pour afficher ou modifier la fenêtre.
Le descripteur reste valide jusqu’à ce que l’objet Window soit détruit.
Dans l’illustration suivante, l’application détruit l’objet Window. La fonction DestroyWindow supprime l’objet
Window de la mémoire, ce qui invalide le handle de fenêtre.
Gestion des objets utilisateur

Le tableau suivant répertorie les objets utilisateur, ainsi que les fonctions de création et de destruction de chaque
objet. Les fonctions Creator créent l’objet et un handle d’objet, ou simplement retournent simplement le handle
d’objet existant. Les fonctions Destroy suppriment l’objet de la mémoire, ce qui invalide le descripteur d’objet.
O B JET UT IL ISAT EUR C REATO R, F O N C T IO N F O N C T IO N DEST RO Y
Table d’accélérateurs CreateAcceleratorTable DestroyAcceleratorTable
Signe insertion CreateCaret DestroyCaret
Curseur CreateCursor , LoadCursor , DestroyCursor

LoadImage
Conversation DDE DdeConnect , DdeConnectList DdeDisconnect ,

DdeDisconnectList
Hook SetWindowsHookEx UnhookWindowsHookEx
Icône CreateIconIndirect , LoadIcon , DestroyIcon

LoadImage
Menu CreateMenu , CreatePopupMenu , DestroyMenu

LoadMenu , LoadMenuIndirect
Fenêtre CreateWindow , CreateWindowEx, DestroyWindow

CreateDialogParam ,
CreateDialogIndirectParam ,
CreateMDIWindow
Position de la fenêtre BeginDeferWindowPos EndDeferWindowPos

Objets GDI
Les objets GDI ne prennent en charge qu’un seul descripteur par objet. Les handles vers les objets GDI sont
privés pour un processus. Autrement dit, seul le processus qui a créé l’objet GDI peut utiliser le descripteur
d’objet.
Il existe une limite théorique de 65 536 descripteurs GDI par session. Toutefois, le nombre maximal de
descripteurs GDI pouvant être ouverts par session est généralement plus faible, car il est affecté par la mémoire
disponible.
Windows 2000 : Il existe une limite de 16 384 descripteurs GDI par session.
Il y a également une limite par processus par défaut des descripteurs GDI. Pour modifier cette limite, définissez
la valeur de Registre suivante :
HKEY _ Logiciel de l' _ ordinateur local \ \ Microsoft \ Windows NT \ CurrentVersion \ Windows \
GdiProcessHandleQuota
Cette valeur peut être définie sur un nombre compris entre 256 et 65 536.
Windows 2000 : Cette valeur peut être définie sur un nombre compris entre 256 et 16 384.
Gestion des objets GDI

Le tableau suivant répertorie les objets GDI, ainsi que les fonctions de création et de destruction de chaque
objet. Les fonctions Creator créent l’objet et un handle d’objet, ou simplement retournent simplement le handle
d’objet existant. Les fonctions Destroy suppriment l’objet de la mémoire, ce qui invalide le descripteur d’objet.
O B JET GDI C REATO R, F O N C T IO N F O N C T IO N DEST RO Y
Bitmap CreateBitmap , DeleteObject

CreateBitmapIndirect ,
CreateCompatibleBitmap ,
CreateDIBitmap ,
CreateDIBSection ,
CreateDiscardableBitmap
Brush CreateBrushIndirect , DeleteObject

CreateDIBPatternBrush ,
CreateDIBPatternBrushPt ,
CreateHatchBrush ,
CreatePatternBrush ,
CreateSolidBrush
DC CreateDC DeleteDC , ReleaseDC
Métafichier amélioré CreateEnhMetaFile DeleteEnhMetaFile
Enhanced-Metafile DC CreateEnhMetaFile CloseEnhMetaFile
Police CreateFont , CreateFontIndirect DeleteObject

O B JET GDI C REATO R, F O N C T IO N F O N C T IO N DEST RO Y
Mémoire DC CreateCompatibleDC DeleteDC
Métafichiers CreateMetaFile DeleteMetaFile
DC de métafichier CreateMetaFile CloseMetaFile
Palette CreatePalette DeleteObject
Stylet et stylet étendu CreatePen , CreatePenIndirect , DeleteObject

ExtCreatePen
Région CombineRgn , CreateEllipticRgn , DeleteObject

CreateEllipticRgnIndirect ,
CreatePolygonRgn ,
CreatePolyPolygonRgn ,
CreateRectRgn ,
CreateRectRgnIndirect ,
CreateRoundRectRgn ,
ExtCreateRegion , PathToRegion
Objets de noyau
Les handles d’objet de noyau sont spécifiques au processus. Autrement dit, un processus doit créer l’objet ou
ouvrir un objet existant pour obtenir un handle d’objet de noyau. La limite par processus sur les handles de
noyau est de 2 ^ 24. Toutefois, les handles étant stockés dans la réserve paginée, le nombre réel de handles que
vous pouvez créer est basé sur la mémoire disponible. le nombre de descripteurs que vous pouvez créer sur les
Windows 32 bits est nettement inférieur à 2 ^ 24.
Tout processus peut créer un nouveau descripteur vers un objet de noyau existant (même créé par un autre
processus), à condition que le processus sache le nom de l’objet et dispose d’un accès de sécurité à l’objet. Les
handles d’objet de noyau incluent des droits d’accès indiquant les actions qui peuvent être accordées ou
refusées à un processus. Une application spécifie des droits d’accès quand elle crée un objet ou obtient un
handle d’objet existant. Chaque type d’objet de noyau prend en charge son propre ensemble de droits d’accès.
Par exemple, les handles d’événements peuvent avoir un accès set ou Wait (ou les deux), les descripteurs de
fichiers peuvent avoir un accès en lecture ou en écriture (ou les deux), et ainsi de suite. Pour plus d’informations,
consultez objets sécurisables.
Dans l’illustration suivante, une application crée un objet d’événement. La fonction CreateEvent crée l’objet
d’événement et retourne un handle d’objet.
Une fois l’objet d’événement créé, l’application peut utiliser le descripteur d’événement pour définir ou attendre
l’événement. Le descripteur reste valide jusqu’à ce que l’application ferme le handle ou se termine.
La plupart des objets de noyau prennent en charge plusieurs descripteurs sur un seul objet. Par exemple,
l’application de l’illustration précédente peut obtenir des descripteurs d’objets d’événement supplémentaires à
l’aide de la fonction OpenEvent , comme indiqué dans l’illustration suivante.
Cette méthode permet à une application d’avoir des handles avec des droits d’accès différents. Par exemple, le
handle 1 peut avoir défini et attendre l’accès à l’événement, et le handle 2 peut avoir uniquement un accès en
attente.
Si un autre processus connaît le nom de l’événement et possède un accès de sécurité à l’objet, il peut créer son
propre handle d’objet d’événement à l’aide de OpenEvent . L’application de création peut également dupliquer
l’un de ses descripteurs dans le même processus ou dans un autre processus à l’aide de la fonction
DuplicateHandle .
Un objet reste en mémoire tant qu’il existe au moins un handle d’objet. Dans l’illustration suivante, les
applications utilisent la fonction CloseHandle pour fermer leurs handles d’objet d’événement. En l’absence de
descripteurs d’événements, le système supprime l’objet de la mémoire, comme indiqué dans l’illustration
suivante.
Le système gère les objets de fichiers différemment des autres objets de noyau. Les objets fichier contiennent le
pointeur de fichier (le pointeur vers l’octet suivant à lire ou écrire dans un fichier). Chaque fois qu’une
application crée un nouveau descripteur de fichier, le système crée un objet de fichier. Par conséquent, plusieurs
objets fichier peuvent faire référence à un seul fichier sur le disque, comme indiqué dans l’illustration suivante.
Seul la duplication ou l’héritage peut faire référence au même objet de fichier, comme indiqué dans l’illustration
suivante.
Le tableau suivant répertorie chacun des objets de noyau, ainsi que les fonctions de création et de destruction
de chaque objet. Les fonctions Creator créent l’objet et un handle d’objet, ou créent un handle d’objet existant.
Les fonctions de destruction ferment le descripteur d’objet. Quand une application ferme le dernier descripteur
d’un objet de noyau, le système supprime l’objet de la mémoire.
O B JET DE N O YA U C REATO R, F O N C T IO N F O N C T IO N DEST RO Y

Access token (Jeton d’accès) CreateRestrictedToken , CloseHandle

DuplicateToken , DuplicateTokenEx,
OpenProcessToken ,
OpenThreadToken
Notification de modification FindFirstChangeNotification FindCloseChangeNotification
Appareil de communication CreateFile CloseHandle
Entrée de la console CreateFile , avec CONIN $ CloseHandle
Mémoire tampon d’écran de la console CreateFile , avec CONOUT $ CloseHandle
Bureau GetThreadDesktop Les applications ne peuvent pas

supprimer cet objet.
Événement CreateEvent , CreateEventEx, CloseHandle

OpenEvent
Journal des événements OpenEventLog , CloseEventLog

RegisterEventSource ,
OpenBackupEventLog
Fichier CreateFile CloseHandle , DeleteFile
Mappage de fichiers CreateFileMapping , CloseHandle

OpenFileMapping
Rechercher un fichier FindFirstFile FindClose
Segment de mémoire (heap) HeapCreate HeapDestroy
Port de terminaison d’e/s CreateIoCompletionPor t CloseHandle
Travail CreateJobObject CloseHandle
Mailslots CreateMailslot CloseHandle
Notification de ressource mémoire CreateMemor yResourceNotificati CloseHandle

on
Module LoadLibrar y , GetModuleHandle FreeLibrar y
Mutex CreateMutex, CreateMutexEx, CloseHandle

OpenMutex
Pipe CreateNamedPipe , CreatePipe CloseHandle ,

DisconnectNamedPipe
Process CreateProcess , OpenProcess , CloseHandle , TerminateProcess

GetCurrentProcess
Semaphore CreateSemaphore, , CloseHandle

CreateSemaphoreEx,
OpenSemaphore
Prise Socket , accepter opération closesocket
Thread CreateThread , CloseHandle , TerminateThread

CreateRemoteThread ,
GetCurrentThread
Minuterie CreateWaitableTimer , CloseHandle

CreateWaitableTimerEx,
OpenWaitableTimer
Mettre à jour une ressource BeginUpdateResource EndUpdateResource
Station Windows GetProcessWindowStation Les applications ne peuvent pas

supprimer cet objet.
Rubriques connexes
Espaces de noms d’objets de noyau
Les éléments suivants sont utilisés avec les handles et les objets.
Les fonctions suivantes sont utilisées avec les handles et les objets.
F O N C T IO N DESC RIP T IO N
CloseHandle Ferme un handle d’objet ouvert.
CompareObjectHandles Compare deux handles d’objet pour déterminer s’ils font

référence au même objet de noyau sous-jacent.
DuplicateHandle Duplique un handle d’objet.
GetHandleInformation Récupère certaines propriétés d’un handle d’objet.
SetHandleInformation Définit certaines propriétés d’un handle d’objet.

Registre
Le Registre est une base de données définie par le système dans laquelle les applications et les composants
système stockent et récupèrent les données de configuration. Les données stockées dans le registre varient en
fonction de la version de Microsoft Windows. Les applications utilisent l’API du Registre pour récupérer, modifier
ou supprimer des données de registre.
Vous ne devez pas modifier les données de Registre qui n’appartiennent pas à votre application, sauf si cela est
absolument nécessaire. En cas d’erreur dans le registre, votre système risque de ne pas fonctionner
correctement. Dans ce cas, vous pouvez restaurer le registre dans l’État où il se trouvait lors du dernier
démarrage réussi de l’ordinateur. Pour plus d’informations, consultez l’aide de votre système d’exploitation.
Pour plus d’informations sur la base de données du Registre et l’accès par programme aux données du Registre,
consultez les rubriques suivantes :
Rubriques connexes
Windows Référence du Registre du kit de ressources serveur 2003
Les rubriques suivantes décrivent le registre et les fonctions que vous pouvez appeler pour récupérer et
modifier les données qui y sont stockées.
Espace de stockage du Registre
Clés prédéfinies
Ruches du Registre
Données d’application 32 bits et 64 bits dans le registre
le registre est une base de données hiérarchique qui contient des données qui sont essentielles pour le
fonctionnement des Windows et des applications et des services qui s’exécutent sur Windows. Les données sont
structurées dans un format d’arborescence. Chaque nœud de l’arborescence est appelé une clé. Chaque clé peut
contenir à la fois des sous-clés et des entrées de données appelées valeurs. Parfois, la présence d’une clé
correspond à toutes les données requises par une application. dans d’autres cas, une application ouvre une clé et
utilise les valeurs associées à la clé. Une clé peut avoir n’importe quel nombre de valeurs, et les valeurs peuvent
se présenter sous n’importe quelle forme. Pour plus d’informations, consultez types de valeurs de Registre et
limites de taille des éléments du registre.
Chaque clé a un nom constitué d’un ou de plusieurs caractères imprimables. Les noms de clés ne respectent pas
la casse. Les noms de clés ne peuvent pas inclure de barre oblique inverse ( \ ), mais tout autre caractère
imprimable peut être utilisé. Les noms de valeur et les données peuvent inclure une barre oblique inverse.
Le nom de chaque sous-clé est unique en ce qui concerne la clé qui est immédiatement au-dessus de celle-ci
dans la hiérarchie. Les noms de clés ne sont pas localisés dans d’autres langues, bien que les valeurs puissent
être.
L’illustration suivante est un exemple de structure de clé de registre telle qu’elle est affichée par l’éditeur du
Registre.
Chaque arborescence sous poste de travail est une clé. La clé de l' _ _ ordinateur local HKEY possède les
sous-clés suivantes : Hardware , Sam , Security , Software et System . Chacune de ces clés a des sous-clés. Par
exemple, la clé matérielle a les sous-clés Description , DEVICEMAP et RESOURCEMAP ; la clé DEVICEMAP a
plusieurs sous-clés, y compris la vidéo .
Chaque valeur se compose d’un nom de valeur et de ses données associées, le cas échéant.
MaxObjectNumber et VgaCompatible sont des valeurs qui contiennent des données sous la sous-clé Video .
Une arborescence du Registre peut avoir 512 niveaux de profondeur. Vous pouvez créer jusqu’à 32 niveaux à la
fois à l’aide d’un appel d’API de Registre unique.
Rubriques connexes
vue d’ensemble du registre de Windows
Espace de stockage du Registre
Bien qu’il existe peu de limites techniques quant au type et à la taille des données qu’une application peut
stocker dans le registre, certaines recommandations pratiques existent pour favoriser l’efficacité du système.
Une application doit stocker des données de configuration et d’initialisation dans le registre, et stocker d’autres
types de données ailleurs.
En règle générale, les données composées de plus d’un ou de deux kilo-octets (K) doivent être stockées en tant
que fichier et référencées à l’aide d’une clé dans le registre plutôt que d’être stockées comme valeur. Au lieu de
dupliquer de grands éléments de données dans le registre, une application doit enregistrer les données en tant
que fichier et faire référence au fichier. Le code binaire exécutable ne doit jamais être stocké dans le registre.
Une entrée de valeur utilise un espace de registre bien inférieur à celui d’une clé. Pour économiser de l’espace,
une application doit regrouper des données similaires en tant que structure et stocker la structure en tant que
valeur au lieu de stocker chacun des membres de la structure sous la forme d’une clé distincte. (Le stockage des
données sous forme binaire permet à une application de stocker des données en une seule valeur qui serait
autrement constituée de plusieurs types incompatibles.)
Les affichages des fichiers du Registre sont mappés dans la mémoire de réserve paginée.
Windows ser ver 2008 pour 32 bits, Windows Vista avec SP1 pour 32 bits, Windows Vista,
Windows Ser ver 2003, Windows XP : Les affichages des fichiers du Registre sont mappés dans l’espace
d’adressage du cache de l’ordinateur. Par conséquent, quelle que soit la taille des données du Registre, il n’y a
pas de facturation supérieure à 4 mégaoctets (Mo).
La taille maximale d’une ruche de Registre est de 2 Go, à l’exception de la ruche système.
Windows ser ver 2003 avec SP1, Windows ser ver 2003 et Windows XP : Il n’existe aucune limite
explicite quant à la quantité d’espace totale pouvant être consommée par les ruches dans la mémoire de réserve
paginée et dans l’espace disque, bien que les quotas système puissent affecter la taille maximale réelle. La taille
maximale d’une ruche de registre était limitée à 2 Go à compter de Windows Server 2003 avec Service Pack 2
(SP2).
La taille maximale de la ruche système est limitée par la mémoire physique, comme indiqué dans le tableau
suivant.
SY ST ÈM E TA IL L E M A XIM A L E DE L A RUC H E SY ST ÈM E
systèmes basés sur x86 50% de la mémoire physique, jusqu’à 400 Mo. Windows
ser ver 2003 avec SP2, Windows ser ver 2003 avec
SP1, Windows ser ver 2003 et Windows XP : 25% de la
mémoire physique, jusqu’à 200 Mo.
systèmes basés sur x64 50% de la mémoire physique, jusqu’à 1,5 Go. Windows
Ser ver 2003 avec SP2 : 25% de la mémoire système,
jusqu’à 200 Mo.
Windows ser ver 2003 avec SP1, Windows ser ver
2003 et Windows XP 64-bit Edition : 32 Mo.
SY ST ÈM E TA IL L E M A XIM A L E DE L A RUC H E SY ST ÈM E
Systèmes basés sur Intel Itanium 50% de la mémoire physique, jusqu’à 1 Go. Windows
ser ver 2008, Windows Vista, Windows ser ver 2003
avec SP2, Windows ser ver 2003 avec SP1, Windows
ser ver 2003 et Windows XP édition 64 bits : 32 Mo.
Windows 2000
Les données du Registre sont stockées dans la réserve paginée, une zone de mémoire physique utilisée pour les
données système qui peuvent être écrites sur le disque quand elles ne sont pas utilisées. La valeur
Registr ySizeLimit établit la quantité maximale de réserve paginée pouvant être consommée par les données
de registre de toutes les applications. Cette valeur se trouve dans la clé de Registre suivante :
HKEY_LOCAL_MACHINE
System
CurrentControlSet
Control
Par défaut, la limite de taille du Registre est de 25% de la réserve paginée. (La taille par défaut de la réserve
paginée est de 32 Mo. il s’agit donc de 8 Mo.) Le système vérifie que la valeur minimale de Registr ySizeLimit
est de 4 Mo et la valeur maximale est environ 80% de la valeur PagedPoolSize . Si la valeur de cette entrée est
supérieure à 80% de la taille de la réserve paginée, le système définit la taille maximale du Registre à 80% de la
taille de la réserve paginée. Cela empêche le registre de consommer l’espace requis par les processus. Notez que
la définition de cette valeur n’alloue pas d’espace dans la réserve paginée et ne garantit pas que l’espace sera
disponible si nécessaire.
La taille de la réserve paginée est déterminée par la valeur PagedPoolSize dans la clé de Registre suivante :
HKEY_LOCAL_MACHINE
System
CurrentControlSet
Control
SessionManager
MemoryManagement
Pour obtenir un exemple de la façon de déterminer la taille actuelle et la taille maximale du Registre, consultez
détermination de la taille du Registre.
La taille maximale de la réserve paginée est d’environ 300 470 Mo, de sorte que la limite de la taille du Registre
est de 240-376 Mo. Toutefois, si le commutateur/3GB est utilisé, la taille maximale de la réserve paginée est de
192 Mo, de sorte que le registre peut comporter jusqu’à 153,6 Mo.
Clés prédéfinies
Une application doit ouvrir une clé avant de pouvoir ajouter des données au registre. Pour ouvrir une clé, une
application doit fournir un handle à une autre clé dans le Registre qui est déjà ouverte. Le système définit des
clés prédéfinies qui sont toujours ouvertes. Les clés prédéfinies permettent à une application de naviguer dans
le registre et de permettre le développement d’outils permettant à un administrateur système de manipuler des
catégories de données. Les applications qui ajoutent des données au registre doivent toujours fonctionner dans
le cadre de clés prédéfinies, afin que les outils d’administration puissent Rechercher et utiliser les nouvelles
données.
Une application peut utiliser des handles pour ces clés comme points d’entrée dans le registre. Ces handles sont
valides pour toutes les implémentations du Registre, bien que l’utilisation des handles puisse varier de la
plateforme à la plateforme. En outre, d’autres descripteurs prédéfinis ont été définis pour des plateformes
spécifiques. Les éléments suivants sont des handles vers les clés prédéfinies.
H A N DL E DESC RIP T IO N
_racine des classes HKEY _ Les entrées de Registre subordonnées à cette clé définissent
les types (ou classes) des documents et les propriétés
associées à ces types. Les applications Shell et COM utilisent
les informations stockées sous cette clé.
Cette clé fournit également une compatibilité descendante
avec la base de données d’inscription de Windows 3,1 en
stockant des informations pour la prise en charge de DDE et
OLE. Les visionneuses de fichiers et les extensions d’interface
utilisateur stockent leurs identificateurs de classe OLE dans
les _ classes HKEY _ root et les serveurs in-process sont
inscrits dans cette clé.
Ce descripteur ne doit pas être utilisé dans un service ou
une application qui emprunte l’identité de différents
utilisateurs.
Pour plus d’informations, consultez HKEY _ classes _ root.
configuration de HKEY _ Current _ Contient des informations sur le profil matériel actuel du
système de l’ordinateur local. Les informations de la section
HKEY _ Current _ config décrivent uniquement les
différences entre la configuration matérielle actuelle et la
configuration standard. Les informations sur la configuration
matérielle standard sont stockées sous les clés logicielles et
système de HKEY _ local _ machine .
HKEY _ La _ configuration actuelle est un alias pour
HKEY _ local _ machine \ System \ CurrentControlSet
\ profils \ actuels .
Pour plus d’informations, consultez HKEY _ Current _ config.
HKEY _ Current _ User Les entrées de Registre subordonnées à cette clé définissent
les préférences de l’utilisateur actuel. Ces préférences
incluent les paramètres des variables d’environnement, les
données relatives aux groupes de programmes, aux couleurs,
aux imprimantes, aux connexions réseau et aux préférences
de l’application. Cette clé facilite l’établissement des
paramètres de l’utilisateur actuel. la clé est mappée à la
branche de l’utilisateur actuel dans HKEY _ Users . Dans
HKEY _ Current _ User , les éditeurs de logiciels stockent
les préférences actuelles propres à l’utilisateur à utiliser dans
leurs applications. Par exemple, Microsoft crée la clé de _
logiciel HKEY Current _ User \ Software \ Microsoft
pour ses applications à utiliser, chaque application créant sa
propre sous-clé sous la clé Microsoft .
Le mappage entre HKEY _ Current _ User et HKEY _
Users est par processus et est établi la première fois que le
processus fait référence à HKEY _ Current _ User . Le
mappage est basé sur le contexte de sécurité du premier
thread pour référencer HKEY _ Current _ User . Si ce
contexte de sécurité n’a pas de ruche de Registre chargée
dans HKEY _ Users , le mappage est établi avec HKEY _
Users \ . Valeur par défaut . Une fois ce mappage établi, il
persiste, même si le contexte de sécurité du thread change.
Toutes les entrées de Registre dans HKEY _ Current _
User , sauf celles sous HKEY _ Current _ User \ \ classes
Software , sont incluses dans la partie Registre par
utilisateur d’un profil utilisateur itinérant. Pour exclure
d’autres entrées d’un profil utilisateur itinérant, stockez-les
dans les paramètres de la variable HKEY _ Current _ User
_ local _ .
Ce descripteur ne doit pas être utilisé dans un service ou
une application qui emprunte l’identité de différents
utilisateurs. Au lieu de cela, appelez la fonction
RegOpenCurrentUser .
Pour plus d’informations, consultez HKEY _ Current _ User.
paramètres locaux de HKEY _ Current _ User _ _ Les entrées de Registre subordonnées à cette clé définissent
les préférences de l’utilisateur actuel qui sont locales sur
l’ordinateur. Ces entrées ne sont pas incluses dans la partie
Registre par utilisateur d’un profil utilisateur itinérant.
Windows ser ver 2008, Windows Vista, Windows
ser ver 2003 et Windows XP/2000 : Cette clé est prise
en charge à partir de Windows 7 et de Windows Server
2008 R2.
HKEY _ local _ machine Les entrées de Registre subordonnées à cette clé définissent
l’état physique de l’ordinateur, y compris les données
relatives au type de bus, à la mémoire système, ainsi que le
matériel et les logiciels installés. Il contient les sous-clés qui
contiennent les données de configuration actuelles, y
compris les informations de Plug-and-Play (la branche
enum , qui inclut la liste complète de tous les matériels qui
se trouvent déjà sur le système), les préférences d’ouverture
de session réseau, les informations de sécurité réseau, les
informations relatives aux logiciels (telles que les noms de
serveurs et l’emplacement du serveur), ainsi que d’autres
Pour plus d’informations, consultez HKEY _ local _ machine.
_données de performances HKEY _ Les entrées de Registre subordonnées à cette clé vous
permettent d’accéder aux données de performances. Les
données ne sont pas réellement stockées dans le registre ;
les fonctions de Registre provoquent la collecte des données
à partir de la source par le système.
HKEY _ performance _ NLSTEXT Les entrées de Registre subordonnées à cette clé référencent
les chaînes de texte qui décrivent les compteurs dans la
langue locale de la zone dans laquelle le système
informatique s’exécute. Ces entrées ne sont pas disponibles
pour Regedit.exe et Regedt32.exe. Windows 2000 : Cette
clé n’est pas prise en charge.
HKEY _ performance _ Text Les entrées de Registre subordonnées à cette clé référencent
les chaînes de texte qui décrivent les compteurs en anglais
des États-Unis. Ces entrées ne sont pas disponibles pour
Regedit.exe et Regedt32.exe. Windows 2000 : Cette clé
n’est pas prise en charge.
HKEY, _ utilisateurs Les entrées de Registre subordonnées à cette clé définissent

la configuration utilisateur par défaut pour les nouveaux
utilisateurs sur l’ordinateur local et la configuration utilisateur
pour l’utilisateur actuel.
La fonction RegOverridePredefKey vous permet de mapper une clé de Registre prédéfinie à une clé spécifiée
dans le registre. Par exemple, un programme d’installation de logiciel peut remapper une clé prédéfinie avant
d’installer un composant DLL. Cela permet au programme d’installation d’examiner facilement les informations
que la procédure d’installation de la DLL écrit dans la clé prédéfinie.
Les fonctions RegDisablePredefinedCache et RegDisablePredefinedCacheEx désactivent la mise en cache
des handles pour les handles de Registre prédéfinis. Les services qui utilisent l’emprunt d’identité doivent
appeler RegDisablePredefinedCacheEx avant d’utiliser des handles de Registre prédéfinis.
Les handles prédéfinis ne sont pas thread-safe. La fermeture d’un handle prédéfini dans un thread affecte tous
les autres threads qui utilisent le descripteur.
_Clé racine de classes HKEY _
La clé HKEY _ classes _ root (HKCR ) contient les associations d’extension de nom de fichier et les informations
d’inscription de classe com, telles que les ProgID, les CLSIDet les IID. Il est principalement destiné à la
compatibilité avec le registre en Windows 16 bits.
L’inscription de classe et les informations d’extension de nom de fichier sont stockées sous les clés HKEY _ local
_ machine et HKEY _ Current _ User . La clé HKEY _ local _ machine \ Software \ classes contient des
paramètres par défaut qui peuvent s’appliquer à tous les utilisateurs sur l’ordinateur local. La clé HKEY _
Current _ User \ Software \ classes contient des paramètres qui s’appliquent uniquement à l’utilisateur
interactif. La clé _ _ racine de classes HKEY fournit une vue du Registre qui fusionne les informations de ces
deux sources. HKEY _ La _ racine des classes fournit également cette vue fusionnée pour les applications
conçues pour les versions antérieures de Windows.
Les paramètres spécifiques à l’utilisateur ont priorité sur les paramètres par défaut. Par exemple, le paramètre
par défaut peut spécifier une application particulière pour gérer .doc fichiers. Toutefois, un utilisateur peut
remplacer ce paramètre en spécifiant une application différente dans le registre.
Les fonctions de Registre telles que RegOpenKeyEx ou RegQuer yValueEx vous permettent de spécifier la clé
_ _ racine de classes HKEY . Lorsque vous appelez ces fonctions à partir d’un processus en cours d’exécution
dans le compte d’utilisateur interactif, le système fusionne les paramètres par défaut dans HKEY _ local _
machine \ Software \ classes avec les paramètres de l’utilisateur interactif dans HKEY _ Current _ User \
Software \ classes . Pour plus d’informations sur la façon dont ces paramètres sont fusionnés, consultez vue
fusionnée de la _ _ racine de la classe HKEY.
Pour modifier les paramètres de l’utilisateur interactif, stockez les modifications sous _ HKEY _ Current \
User \ classes au lieu de HKEY _ classes _ root .
Pour modifier les paramètres par défaut, stockez les modifications sous HKEY _ local _ machine \ Software \
classes . Si vous écrivez des clés dans une clé sous la _ _ racine de classes HKEY , le système stocke les
informations sous HKEY _ local _ machine \ Software \ classes . Si vous écrivez des valeurs dans une clé
sous la _ _ racine de la classe HKEY , et que la clé existe déjà sous les classes de logiciels de la classe HKEY _
Current _ \ \ User , le système stocke les informations à cet emplacement au lieu de sous HKEY _ local _
machine \ Software \ classes .
Les processus qui s’exécutent dans un contexte de sécurité autre que celui de l’utilisateur interactif ne doivent
pas utiliser la clé _ _ racine HKEY classes avec les fonctions de registre. Au lieu de cela, ces processus peuvent
ouvrir explicitement la clé de classes de logiciels de l' _ _ ordinateur \ \ local HKEY pour accéder aux
paramètres par défaut. Pour ouvrir une clé de Registre qui fusionne le contenu de la _ classe de logiciels
HKEY local _ machine \ \ avec les paramètres d’un utilisateur spécifié, ces processus peuvent appeler la
fonction RegOpenUserClassesRoot . Par exemple, un thread qui emprunte l’identité d’un client peut appeler
RegOpenUserClassesRoot s’il doit récupérer une vue fusionnée pour le client faisant l’objet d’un emprunt
d’identité. Notez que RegOpenUserClassesRoot échoue si le profil utilisateur de l’utilisateur spécifié n’a pas
été chargé. Le système charge automatiquement le profil de l’utilisateur interactif lors de l’ouverture de session.
Pour les autres utilisateurs, vous devez appeler la fonction LoadUserProfile pour charger explicitement le
profil de l’utilisateur.
Si une application est exécutée avec des droits d’administrateur et que le contrôle de compte d’utilisateur est
désactivé, le runtime COM ignore la configuration COM par utilisateur et accède uniquement à la configuration
COM par ordinateur. Les applications qui requièrent des droits d’administrateur doivent inscrire les objets COM
dépendants lors de l’installation dans le magasin de configurations COM par ordinateur (HKEY _ local _
machine \ Software \ classes ). Pour plus d’informations, consultez AC : UAC : COM Per-User configuration.
Windows Ser ver 2003 et Windows XP/2000 : Les applications peuvent enregistrer des objets COM
dépendants dans le magasin de configuration COM par ordinateur ou par utilisateur (HKEY _ local _ machine
\ Software \ classes ou HKEY _ Current _ User \ Software \ classes ).
Rubriques connexes
_Racine des classes HKEY _ (référence du Registre du kit de ressources)
Vue fusionnée de la _ racine de la classe HKEY _
La fonction RegOpenUserClassesRoot fournit une vue fusionnée pour les processus, tels que les services, qui
concernent des clients autres que l’utilisateur interactif. Dans ce cas, la clé _ _ racine de classes HKEY fournit
une vue du Registre qui fusionne les informations de la _ _ classe de \ logiciels \ HKEY local machine avec
les informations des classes de logiciel de HKEY _ Current _ User \ \ .
Le système utilise les règles suivantes pour fusionner les informations des deux sources :
La vue fusionnée comprend toutes les sous-clés de la clé HKEY _ Current _ User \ Software \ classes .
La vue fusionnée comprend toutes les sous-clés immédiates de la clé HKEY _ local _ machine \ Software
\ classes qui ne dupliquent pas les sous-clés des classes de logiciels de l' _ _ utilisateur \ \ actuel HKEY .
À la fin de cette rubrique se trouve une liste des sous-clés qui se trouvent dans les classes de logiciel HKEY _
local _ machine \ \ et HKEY _ Current _ User \ \ . Les sous-clés immédiates de ces clés de l’arborescence
de l' _ _ ordinateur local HKEY sont incluses dans l’affichage fusionné uniquement si elles ne sont pas des
doublons de sous-clés immédiates de l’arborescence de l' _ _ utilisateur HKEY CURRENT . La vue
fusionnée n’inclut pas le contenu de la _ _ machine locale HKEY des sous-clés dupliquées.
Si une application est exécutée avec des droits d’administrateur et que le contrôle de compte d’utilisateur est
désactivé, le runtime COM ignore la configuration COM par utilisateur et accède uniquement à la configuration
COM par ordinateur. Les applications qui requièrent des droits d’administrateur doivent inscrire les objets COM
dépendants lors de l’installation dans le magasin de configurations COM par ordinateur (HKEY _ local _
machine \ Software \ classes ). Pour plus d’informations, consultez AC : UAC : COM Per-User configuration.
Windows Ser ver 2003 et Windows XP/2000 : Les applications peuvent enregistrer des objets COM
dépendants dans le magasin de configuration COM par ordinateur ou par utilisateur (HKEY _ local _ machine
\ Software \ classes ou HKEY _ Current _ User \ Software \ classes ).
L’exemple suivant montre un ensemble de sous-clés sous les clés HKEY _ local _ machine et HKEY _ Current
_ User et la vue fusionnée résultante de la racine de la _ _ classe HKEY .
HKEY _ _Classes de \ logiciels \ de l’ordinateur local CLSID 2 4 InprocSer ver32 LocalSer ver32 7
HKEY _ _ \ \ Classes logicielles utilisateur actuelles CLSID 1 4 LocalSer ver 6 10 LocalSer ver
HKEY _ CL ASSES _ racine CLSID 1 2 4 InprocSer ver32 LocalSer ver LocalSer ver32 6 7 10 LocalSer ver
Les sous-clés suivantes se trouvent à la fois dans les classes de logiciels de l' _ _ ordinateur \ \ local HKEY et
les classes de logiciels de HKEY _ Current _ User \ \ . À partir de l’arborescence de l' _ _ ordinateur local
HKEY , les sous-clés immédiates de ces clés sont incluses dans l’affichage fusionné uniquement si elles ne sont
pas des doublons de sous-clés immédiates de l’arborescence de l' _ _ utilisateur HKEY actuelle . La vue
fusionnée n’inclut pas le contenu de la _ _ machine locale HKEY des sous-clés dupliquées.
*
*\shellex
*\shellex \ ContextMenuHandlers
*\shellex \ Proper tySheetHandlers
AppID
Identificateur
Catégories de composant
Lecteur
Lecteur \ shellex
Lecteur \ shellex \ ContextMenuHandlers
Lecteur \ shellex \ Proper tySheetHandlers
FileType
Folder
Dossier \ shellex
Dossier \ shellex \ ColumnHandler
Dossier \ shellex \ ContextMenuHandlers
Dossier \ shellex \ ExtShellFolderViews
Dossier \ shellex \ Proper tySheetHandlers
Composants du programme d’installation \
Fonctionnalités du programme d’installation \
Produits du programme d’installation \
Interface
MIME
\Base de données MIME
\Jeu de caractères de base de données MIME \
\Page de codes de la base de données MIME \
\Type de contenu de base de données MIME \
Expor tation
Ruches du Registre
Une ruche est un groupe logique de clés, de sous-clés et de valeurs dans le Registre qui contient un ensemble de
fichiers de prise en charge chargés en mémoire lors du démarrage du système d’exploitation ou lorsqu’un
utilisateur se connecte.
Chaque fois qu’un nouvel utilisateur ouvre une session sur un ordinateur, une nouvelle ruche est créée pour cet
utilisateur avec un fichier distinct pour le profil utilisateur. C’est ce que l’on appelle la ruche du profil utilisateur.
La ruche d’un utilisateur contient des informations de Registre spécifiques relatives aux paramètres de
l’application, au bureau, à l’environnement, aux connexions réseau et aux imprimantes de l’utilisateur. Les ruches
de profil utilisateur se trouvent sous la clé HKEY _ Users .
Les fichiers du Registre ont les deux formats suivants : standard et latest. le format standard est le seul format
pris en charge par Windows 2000. elle est également prise en charge par les versions ultérieures de Windows à
des fins de compatibilité descendante. le format le plus récent est pris en charge à partir de Windows XP. sur les
versions de Windows qui prennent en charge le format le plus récent, les ruches suivantes utilisent toujours le
format standard : HKEY _ CURRENT _ USER , hkey _ local _ machine \ SAM , hkey _ local _ machine \
Security et hkey _ users \ . PAR défaut ; toutes les autres ruches utilisent le format le plus récent.
La plupart des fichiers de prise en charge pour les ruches se trouvent dans le répertoire% SystemRoot% \
system32 \ config. Ces fichiers sont mis à jour chaque fois qu’un utilisateur ouvre une session. Les extensions de
nom de fichier des fichiers de ces répertoires, ou, dans certains cas, l’absence d’extension, indiquent le type de
données qu’elles contiennent. Le tableau suivant répertorie ces extensions, ainsi qu’une description des données
contenues dans le fichier.
EXT EN SIO N DESC RIP T IO N
aucun Copie complète des données Hive.
. Alt Une copie de sauvegarde de la ruche critique du système de

l' _ _ ordinateur \ local HKEY . Seule la clé système a un
fichier. Alt.
.log Journal des transactions des modifications apportées aux

clés et aux entrées de valeur dans la ruche.
. SAV Copie de sauvegarde d’une ruche.

Windows Ser ver 2003 et Windows XP/2000 : Copie
des fichiers Hive tels qu’ils ont été examinés à la fin de
l’étape en mode texte dans le programme d’installation. Le
programme d’installation comporte deux étapes : le mode
texte et le mode graphique. La ruche est copiée dans un
fichier. SAV après l’étape en mode texte du programme
d’installation pour la protéger contre les erreurs qui peuvent
se produire en cas d’échec de la phase en mode graphique
du programme d’installation. Si le programme d’installation
échoue pendant l’étape en mode graphique, seule l’étape en
mode graphique se répète lorsque l’ordinateur est
redémarré. le fichier. SAV est utilisé pour restaurer les
données Hive.
Le tableau suivant répertorie les ruches standard et leurs fichiers de prise en charge.
RUC H E DU REGIST RE F IC H IERS DE P RISE EN C H A RGE
configuration de HKEY _ Current _ System, System. Alt, System. log, System. SAV
HKEY _ Current _ User Ntuser. dat, Ntuser. dat. log
HKEY _ Sam de l' _ ordinateur local \ Sam, Sam. log, Sam. SAV
HKEY _ sécurité de l' _ ordinateur local \ Security, Security. log, Security. SAV
HKEY _ logiciel de l' _ ordinateur local \ Logiciel, Software. log, Software. SAV
HKEY _ local _ machine \ System System, System. Alt, System. log, System. SAV
HKEY _ Users \ . VALEURS Default (par défaut). log ; default. SAV

Avant de placer des données dans le registre, une application doit diviser les données en deux catégories :
données spécifiques à l’ordinateur et données spécifiques à l’utilisateur. En faisant cette distinction, une
application peut prendre en charge plusieurs utilisateurs, tout en trouvant des données spécifiques à l’utilisateur
sur un réseau et en utilisant ces données dans différents emplacements, ce qui permet d’obtenir des données de
profil utilisateur indépendantes de l’emplacement. (Un profil utilisateur est un ensemble de données de
configuration enregistrées pour chaque utilisateur.)
Lorsque l’application est installée, elle doit enregistrer les données spécifiques à l’ordinateur sous la clé de l' _ _
ordinateur local HKEY . En particulier, il doit créer des clés pour le nom de la société, le nom du produit et le
numéro de version, comme indiqué dans l’exemple suivant :
HKEY _ _ \ Logiciel \ de l’ordinateur local MyCompany \ MyProduct \ 1,0
Si l’application prend en charge COM, elle doit enregistrer ces données sous HKEY _ local _ machine \
Software \ classes .
Une application doit enregistrer des données spécifiques à l’utilisateur sous la clé HKEY _ Current _ User ,
comme illustré dans l’exemple suivant :
HKEY _ _ \ Logiciel \ utilisateur actuel MyCompany \ MyProduct \ 1,0
Pour qu’une application puisse ajouter des données au registre, elle doit créer ou ouvrir une clé. Pour créer ou
ouvrir une clé, une application fait toujours référence à la clé en tant que sous-clé d’une clé actuellement
ouverte. Les clés prédéfinies suivantes sont toujours ouvertes : HKEY _ local _ machine , HKEY _ classes _
root , HKEY _ Users et HKEY _ Current _ User . Une application utilise la fonction RegOpenKeyEx pour
ouvrir une clé et la fonction RegCreateKeyEx pour créer une clé. Une arborescence du Registre peut avoir 512
niveaux de profondeur. Vous pouvez créer jusqu’à 32 niveaux à la fois à l’aide d’un appel d’API de Registre
unique.
Une application peut utiliser la fonction échec RegCloseKey pour fermer une clé et écrire les données qu’elle
contient dans le registre. Échec RegCloseKey n’écrit pas nécessairement les données dans le registre avant de
retourner. le vidage du cache sur le disque dur peut prendre jusqu’à plusieurs secondes. Si une application doit
écrire explicitement des données du Registre sur le disque dur, elle peut utiliser la fonction regflushkey a .
Toutefois, regflushkey a utilise de nombreuses ressources système et doit être appelé uniquement lorsque cela
est absolument nécessaire.
Une application peut utiliser la fonction RegSetValueEx pour associer une valeur et ses données à une clé. Pour
obtenir la liste des types de valeurs pris en charge par RegSetValueEx , consultez types de valeur de registre.
Pour supprimer une valeur d’une clé, une application peut utiliser la fonction RegDeleteValue . Pour supprimer
une clé, elle peut utiliser la fonction RegDeleteKey . Une clé supprimée n’est pas supprimée tant que le dernier
descripteur n’a pas été fermé. Les sous-clés et les valeurs ne peuvent pas être créées sous une clé supprimée.
Il n’est pas possible de verrouiller une clé de Registre pendant une opération d’écriture pour synchroniser l’accès
aux données. Toutefois, vous pouvez contrôler l’accès à une clé de Registre à l’aide des attributs de sécurité. Pour
plus d’informations, consultez sécurité de la clé de Registre et droits d’accès.
Plusieurs opérations de Registre peuvent être effectuées au sein d’une même transaction. Pour associer une clé
de Registre à une transaction, une application peut utiliser la fonction RegCreateKeyTransacted ou
RegOpenKeyTransacted . Pour plus d’informations sur les transactions, consultez Gestionnaire de transactions
du noyau.
Pour récupérer des données du Registre, une application énumère généralement les sous-clés d’une clé jusqu’à
ce qu’elle en trouve une spécifique, puis récupère les données à partir de la ou des valeurs associées. Une
application peut appeler la fonction RegEnumKeyEx pour énumérer les sous-clés d’une clé donnée.
Pour récupérer des données détaillées sur une sous-clé particulière, une application peut appeler la fonction
RegQuer yInfoKey . La fonction RegGetKeySecurity récupère une copie du descripteur de sécurité
protégeant une clé.
Une application peut utiliser la fonction RegEnumValue pour énumérer les valeurs d’une clé donnée et la
fonction RegQuer yValueEx pour récupérer une valeur particulière pour une clé. Une application appelle
généralement RegEnumValue pour déterminer les noms de valeur, puis RegQuer yValueEx pour récupérer les
données pour les noms.
La fonction RegQuer yMultipleValues récupère le type et les données pour une liste de noms de valeurs
associés à une clé de Registre ouverte. Cette fonction est utile pour les fournisseurs de clés dynamiques, car elle
garantit la cohérence des données en extrayant plusieurs valeurs dans une opération atomique.
Étant donné que d’autres applications peuvent modifier les données d’une valeur de Registre entre le moment
où votre application peut lire une valeur et l’utiliser, vous devrez peut-être vous assurer que votre application
contient les données les plus récentes. Vous pouvez utiliser la fonction RegNotifyChangeKeyValue pour
notifier le thread appelant lorsqu’il y a des modifications apportées aux attributs ou au contenu d’une clé de
Registre, ou si la clé est supprimée. La fonction signale un objet d’événement pour notifier l’appelant. Si le
thread qui appelle RegNotifyChangeKeyValue se termine, l’événement est signalé et l’analyse de la clé de
Registre est arrêtée.
Vous pouvez contrôler ou spécifier les modifications qui doivent être signalées à l’aide d’un filtre ou d’un
indicateur Notify. En règle générale, les modifications sont signalées en signalant un événement que vous
spécifiez à la fonction. Notez que la fonction RegNotifyChangeKeyValue ne fonctionne pas avec les handles
distants.
Pour surveiller les opérations du registre plus en détail, consultez Registr y .
Les applications peuvent enregistrer une partie du Registre dans un fichier, puis charger à nouveau le contenu
du fichier dans le registre. Un fichier de Registre est utile quand une grande quantité de données est manipulée,
lorsque de nombreuses entrées sont effectuées dans le registre, ou lorsque les données sont transitives et
doivent être chargées, puis déchargées à nouveau. Les applications qui sauvegardent et restaurent des parties
du Registre sont susceptibles d’utiliser des fichiers du Registre.
Pour enregistrer une clé et ses sous-clés et valeurs dans un fichier de Registre, une application peut appeler la
fonction RegSaveKey ou RegSaveKeyEx .
RegSaveKey et RegSaveKeyEx créent le fichier avec l’attribut archive. Le fichier est créé dans le répertoire actif
du processus pour une clé locale, et dans le répertoire% SystemRoot% \ system32 pour une clé distante.
Les fichiers du Registre ont les deux formats suivants : standard et latest. le format standard est le seul format
pris en charge par Windows 2000. elle est également prise en charge par les versions ultérieures de Windows à
des fins de compatibilité descendante. RegSaveKey crée des fichiers au format standard.
le format le plus récent est pris en charge à partir de Windows XP. les fichiers de registre créés dans ce format ne
peuvent pas être chargés sur Windows 2000. RegSaveKeyEx peut enregistrer les fichiers du Registre dans l’un
ou l’autre format en spécifiant le format reg _ standard _ ou le _ format reg latest _ . Par conséquent, il peut être
utilisé pour convertir les fichiers de Registre qui utilisent le format standard au format le plus récent.
Pour réécrire le fichier de Registre dans le registre, une application peut utiliser les fonctions RegLoadKey ,
RegReplaceKey ou RegRestoreKey comme suit.
RegLoadKey charge les données de Registre à partir d’un fichier spécifié dans une sous-clé spécifiée sous
HKEY _ Users ou HKEY _ local _ machine sur l’ordinateur de l’application appelante ou sur un ordinateur
distant. La fonction crée la sous-clé spécifiée si elle n’existe pas déjà. Après l’appel de cette fonction, une
application peut utiliser la fonction RegUnLoadKey pour restaurer le registre à son état précédent.
RegReplaceKey remplace une clé et toutes ses sous-clés et valeurs dans le registre par les données
contenues dans un fichier spécifié. Les nouvelles données prennent effet lors du prochain démarrage du
système.
RegRestoreKey charge les données de Registre à partir d’un fichier spécifié dans une clé spécifiée sur
l’ordinateur de l’application appelante ou sur un ordinateur distant. Cette fonction remplace les sous-clés et
les valeurs inférieures à la clé spécifiée par les sous-clés et les valeurs qui suivent la clé de niveau supérieur
dans le fichier.
La fonction RegConnectRegistr y établit une connexion à un handle de Registre prédéfini sur un autre
ordinateur. Une application utilise cette fonction principalement pour accéder à des informations à partir d’un
Registre distant sur d’autres ordinateurs dans un environnement réseau, ce que vous pouvez également
effectuer à l’aide de l’éditeur du Registre. Vous pouvez avoir besoin d’accéder à un Registre distant pour
sauvegarder un registre ou en réguler l’accès réseau. Notez que vous devez disposer des autorisations
appropriées pour accéder à un Registre distant à l’aide de cette fonction.
le modèle de sécurité Windows vous permet de contrôler l’accès aux clés de registre. Pour plus d’informations
sur la sécurité, consultez modèle de contrôle d’accès.
Vous pouvez spécifier un descripteur de sécurité pour une clé de registre lorsque vous appelez la fonction
RegCreateKeyEx ou RegSetKeySecurity . Si vous spécifiez la valeur null , la clé obtient un descripteur de
sécurité par défaut. Les listes de contrôle d’accès dans un descripteur de sécurité par défaut pour une clé sont
héritées de sa clé parente directe.
Pour obtenir le descripteur de sécurité d’une clé de Registre, appelez la fonction RegGetKeySecurity ,
GetNamedSecurityInfo ou GetSecurityInfo .
Les droits d’accès valides pour les clés de Registre incluent les droits d’accès supprimer, lire le _ contrôle, écriture
_ DAC et écrire _ propriétaire standard. Les clés de registre ne prennent pas en charge le droit d’accès
synchronisation standard.
Le tableau suivant répertorie les droits d’accès spécifiques aux objets de clé de registre.
VA L EUR SIGN IF IC AT IO N
_Tout _ accès à la clé (0xF003F) Combine les droits _ standard _ requis, la _ _ valeur de
requête clé, la valeur de _ jeu de clés, la sous-clé de création
de clé _ _ _ _ , _ les sous-clés d’énumération _ de clé, la
notification de _ clé _ et les _ droits d’accès à la création de
lien de clé _ .
_ _ Lien de création de clé (0x0020) Réservé pour le système.
CLÉ _ Create _ Sub _ (0x0004) Requis pour créer une sous-clé d’une clé de registre.
CLÉ _ énumérer les _ sous- _ clés (0x0008) Requis pour énumérer les sous-clés d’une clé de registre.
CLÉ d' _ exécution (0x20019) Équivalent à la lecture de la clé _ .
CLÉ _ Notify (0x0010) Requis pour demander des notifications de modification pour
une clé de registre ou pour les sous-clés d’une clé de
registre.
_ _ Valeur de la requête de clé (0x0001) Requis pour interroger les valeurs d’une clé de registre.
_Lecture de clé (0x20019) Combine la _ valeur de lecture des droits standard, la valeur
de _ _ requête clé, les sous-clés d' _ énumération de clé _ _ _
et les valeurs de notification de clé _ .
_Valeur du jeu _ de clés (0x0002) Requis pour créer, supprimer ou définir une valeur de
registre.
VA L EUR SIGN IF IC AT IO N
CLÉ _ WOW64 _ 32KEY (0x0200) indique qu’une application sur l’Windows 64 bits doit
fonctionner sur la vue de registre 32 bits. Cet indicateur est
ignoré par le Windows 32 bits. Pour plus d’informations,
consultez accès à une autre vue de Registre.
Cet indicateur doit être combiné à l’aide de l’opérateur OR
avec les autres indicateurs de ce tableau qui interrogent ou
accèdent aux valeurs de registre.
Windows 2000 : Cet indicateur n’est pas pris en charge.
CLÉ _ WOW64 _ 64KEY (0x0100) indique qu’une application sur l’Windows 64 bits doit
fonctionner sur la vue de registre 64 bits. Cet indicateur est
ignoré par le Windows 32 bits. Pour plus d’informations,
consultez accès à une autre vue de Registre.
Cet indicateur doit être combiné à l’aide de l’opérateur OR
avec les autres indicateurs de ce tableau qui interrogent ou
accèdent aux valeurs de registre.
Windows 2000 : Cet indicateur n’est pas pris en charge.
_Écriture de clé (0x20006) Combine les _ droits d' _ accès standard en écriture, valeur
du jeu de clés _ _ et clé _ créer une sous- _ _ clé.
Quand vous appelez la fonction RegOpenKeyEx , le système vérifie les droits d’accès demandés par rapport au
descripteur de sécurité de la clé. Si l’utilisateur ne dispose pas de l’accès approprié à la clé de Registre,
l’opération d’ouverture échoue. si un administrateur a besoin d’accéder à la clé, la solution consiste à activer _ le
_ privilège SE prendre possession du _ nom et à ouvrir la clé de registre avec un accès en écriture au _
propriétaire. Pour plus d’informations, consultez activation et désactivation des privilèges.
Vous pouvez demander le _ droit d’accès à la sécurité du système Access _ à une clé de Registre si vous
souhaitez lire ou écrire la liste de contrôle d’accès système (SACL) de la clé. Pour plus d’informations, consultez
listes de contrôle d’accès (ACL) et droit d’accès SACL.
Pour afficher les droits d’accès actuels d’une clé, y compris les clés prédéfinies, utilisez l’éditeur du Registre
(Regedt32.exe). Après avoir accédé à la clé souhaitée, accédez au menu Edition , puis sélectionnez
autorisations .
Données d’application 32 bits et 64 bits dans le
registre
sur les Windowss 64 bits, les portions des entrées de registre sont stockées séparément pour les applications 32
bits et 64 bits et mappées dans des vues de registre logique distinctes à l’aide du redirecteur du registre et de la
réflexion du registre, car la version de 64 bits d’une application peut utiliser des clés de registre et des valeurs
différentes de celles de la version de 32 bits. Il existe également des clés de Registre partagées qui ne sont pas
redirigées ou reflétées.
Le parent de chaque nœud de Registre 64 bits est le nœud Image-Specific ou ISN. Le redirecteur du Registre
dirige en toute transparence l’accès au registre d’une application vers le sous-nœud ISN approprié. Les sous-
nœuds de redirection de l’arborescence du Registre sont créés automatiquement par le composant WOW64 en
utilisant le nom Wow6432Node . Par conséquent, il est essentiel de ne pas nommer une clé de registre que
vous créez Wow6432Node .
Les _ indicateurs Key WOW64 _ 64KEY et Key _ WOW64 _ 32KEY permettent un accès explicite à la vue de
Registre 64 bits et à la vue 32 bits, respectivement. Pour plus d’informations, consultez accès à une autre vue de
Registre.
Pour désactiver et activer la réflexion du Registre pour une clé particulière, utilisez les fonctions
RegDisableReflectionKey et RegEnableReflectionKey . Les applications doivent désactiver la réflexion
uniquement pour les clés de registre qu’elles créent et ne pas tenter de désactiver la réflexion pour les clés
prédéfinies, telles que HKEY _ local _ machine ou HKEY _ Current _ User . Pour déterminer quelles clés
figurent dans la liste de réflexion, utilisez la fonction RegQuer yReflectionKey .
Rubriques connexes
redirecteur du Registre
réflexion du Registre
La virtualisation du Registre est une technologie de compatibilité des applications qui permet d’effectuer des
opérations d’écriture dans le Registre qui ont un impact global pour être redirigées vers des emplacements par
utilisateur. Cette redirection est transparente pour les applications qui lisent ou écrivent dans le registre. il est
pris en charge à partir de Windows Vista.
Cette forme de virtualisation est une technologie de compatibilité d’application temporaire. Microsoft a
l’intention de la supprimer des versions ultérieures du système d’exploitation Windows à mesure que d’autres
applications sont compatibles avec Windows Vista et les versions ultérieures de Windows. Par conséquent, il est
important que votre application ne devienne pas dépendante du comportement de la virtualisation du Registre
dans le système.
La virtualisation est destinée uniquement à assurer la compatibilité des applications existantes. les Applications
conçues pour Windows Vista et les versions ultérieures de Windows ne doivent pas écrire dans des zones
système sensibles, ni s’appuyer sur la virtualisation pour résoudre les problèmes. lors de la mise à jour du code
existant pour qu’il s’exécute sur Windows Vista et les versions ultérieures de Windows, les développeurs doivent
s’assurer que les applications stockent uniquement des données dans des emplacements par utilisateur ou dans
des emplacements de% alluserprofile% qui utilisent correctement une liste de contrôle d’accès (ACL).
Pour plus d’informations sur la création d’applications conformes au contrôle de compte d’utilisateur, consultez
le Guide du développeur UAC.
Vue d’ensemble de la virtualisation

avant Windows Vista, les applications étaient généralement exécutées par les administrateurs. Par conséquent,
les applications peuvent accéder librement aux fichiers système et aux clés de registre. Si ces applications ont été
exécutées par un utilisateur standard, elles échouent en raison de droits d’accès insuffisants. Windows Vista et
les versions ultérieures de Windows améliorent la compatibilité des applications pour ces applications en
redirigeant automatiquement ces opérations. Par exemple, les opérations du Registre dans le magasin global
(HKEY _ local _ machine \ Software ) sont redirigées vers un emplacement par utilisateur au sein du profil de
l’utilisateur, connu sous le nom de « magasin virtuel » (classes de l’utilisateur HKEY _ \ _ \ Vir tualStore \ \ ).
La virtualisation du Registre peut être largement classée dans les types suivants :
Ouvrir la virtualisation du Registre
Si l’appelant ne dispose pas d’un accès en écriture à une clé et tente d’ouvrir la clé, la clé est ouverte avec l’accès
maximal autorisé pour cet appelant.
Si l' _ _ _ indicateur d’échec sans assistance de la clé Reg _ est défini pour la clé, l’opération échoue et la clé n’est
pas ouverte. Pour plus d’informations, consultez « contrôle de la virtualisation du registre » plus loin dans cette
rubrique.
Écrire la virtualisation du Registre
Si l’appelant ne dispose pas d’un accès en écriture à une clé et tente d’y écrire une valeur ou de créer une sous-
clé, la valeur est écrite dans le magasin virtuel.
Par exemple, si un utilisateur limité tente d’écrire une valeur dans la clé suivante : HKEY _ local _ machine \
Software \ AppKey1, Virtualization redirige l’opération d’écriture vers les classes de HKEY _ Users \ _ \
Vir tualStore \ machine \ \ AppKey1.
Lire la virtualisation du Registre
Si l’appelant lit à partir d’une clé virtualisée, le registre présente une vue fusionnée des valeurs virtualisées (à
partir du magasin virtuel) et des valeurs non virtuelles (du magasin global) à l’appelant.
Par exemple, supposons que HKEY _ local _ machine \ Software \ AppKey1 contient deux valeurs v1 et v2 et
qu’un utilisateur limité écrit une valeur de v3 sur la clé. Lorsque l’utilisateur tente de lire des valeurs à partir de
cette clé, la vue fusionnée comprend les valeurs v1 et V2 du magasin global et la valeur v3 du magasin virtuel.
Notez que les valeurs virtuelles ont priorité sur les valeurs globales quand elles sont présentes. Dans l’exemple
ci-dessus, même si le magasin global comportait la valeur v3 sous cette clé, la valeur v3 serait toujours
renvoyée à l’appelant à partir du magasin virtuel. Si v3 devait être supprimé du magasin virtuel, v3 serait
retourné à partir du magasin global. En d’autres termes, si v3 devait être supprimé des classes de HKEY _
Users \ _ \ Vir tualStore \ machine \ Software \ AppKey1 mais HKEY _ local _ machine \ Software \
AppKey1 avait une valeur v3, cette valeur serait retournée par le magasin global.
Étendue de la virtualisation du Registre

La virtualisation du Registre est activée uniquement pour les éléments suivants :
processus interactifs 32 bits.
Clés dans HKEY _ local _ machine \ Software .
Clés dans lesquelles un administrateur peut écrire. (si un administrateur ne peut pas écrire dans une clé,
l’application aurait échoué sur les versions précédentes de Windows même si elle a été exécutée par un
administrateur.)
La virtualisation du Registre est désactivée pour les éléments suivants :
processus 64 bits.
Processus qui ne sont pas interactifs, tels que les services.
Notez que l’utilisation du Registre comme mécanisme de communication entre processus (IPC) entre un
service (ou tout autre processus pour lequel la virtualisation n’est pas activée) et une application ne
fonctionnera pas correctement si la clé est virtualisée. Par exemple, si un service antivirus met à jour ses
fichiers de signature en fonction d’une valeur définie par une application, le service ne mettra jamais à
jour ses fichiers de signature, car le service lit à partir du magasin global, mais l’application écrit dans le
magasin virtuel.
Processus qui empruntent l’identité d’un utilisateur. Si un processus tente une opération en usurpant
l’identité d’un utilisateur, cette opération ne sera pas virtualisée.
Les processus en mode noyau, tels que les pilotes.
Processus dont l' requestedExecutionLevel est spécifié dans leurs manifestes.
clés et sous-clés de _ hkey _ local \ machine \ Classes software Classes , hkey _ local _ machine
\ software \ microsoft \ Windows et hkey _ local _ machine \ software \ microsoft \ Windows
NT .
Contrôle de la virtualisation du Registre

En plus de contrôler la virtualisation au niveau de l’application à l’aide de requestedExecutionLevel dans le
manifeste, un administrateur peut activer ou désactiver la virtualisation sur une base par clé pour les clés dans
HKEY _ local _ machine \ Software . Pour ce faire, utilisez l’option indicateurs de l’utilitaire de ligne de
commande Reg.exe avec les indicateurs figurant dans le tableau suivant.
IN DIC AT EUR SIGN IF IC AT IO N
_échec de _ la _ désinstallation de la clé de Registre _ Cet indicateur désactive la virtualisation open Registry. Si cet
indicateur est défini et qu’une opération d’ouverture échoue
sur une clé pour laquelle la virtualisation est activée, le
registre ne tente pas de rouvrir la clé. Si cet indicateur est
désactivé, le registre tente de rouvrir la clé avec un _ accès
maximal autorisé au lieu de l’accès demandé.
_clé Reg _ non _ virtualiser Cet indicateur désactive la virtualisation du registre

d’écriture. Si cet indicateur est défini et si une opération de
création de clé ou de valeur définie échoue parce que
l’appelant ne dispose pas des droits d’accès suffisants à la clé
parente, le registre fait échouer l’opération. Si cet indicateur
est désactivé, le registre tente d’écrire la clé ou la valeur dans
le magasin virtuel. L’appelant doit disposer de la clé _ Read
Right sur la clé parente.
_ _ indicateur recurse de clé de Registre _ Si cet indicateur est défini, les indicateurs de virtualisation du
Registre sont propagés à partir de la clé parente. Si cet
indicateur est désactivé, les indicateurs de virtualisation du
registre ne sont pas propagés. La modification de cet
indicateur affecte uniquement les nouvelles clés de
descendant créées après la modification de l’indicateur. Elle
ne définit pas ou n’efface pas ces indicateurs pour les clés
descendantes existantes.
L’exemple suivant illustre l’utilisation de l’utilitaire de ligne de commande Reg.exe avec l’option FLAGs pour
interroger l’état des indicateurs de virtualisation pour une clé.
C:\>reg flags HKLM\Software\AppKey1 QUERY
HKEY_LOCAL_MACHINE\Software\AppKey1
REG_KEY_DONT_VIRTUALIZE: CLEAR
REG_KEY_DONT_SILENT_FAIL: CLEAR
REG_KEY_RECURSE_FLAG: CLEAR
The operation completed successfully.
Chaque fois que l’audit est activé sur une clé qui est virtualisée, un nouvel événement d’audit de virtualisation
est généré pour indiquer que la clé est virtualisée (en plus des événements d’audit habituels). Les
administrateurs peuvent utiliser ces informations pour surveiller l’état de la virtualisation sur leurs systèmes.
Rubriques connexes
Prise en main avec le contrôle de compte d’utilisateur
Comprendre et configurer le contrôle de compte d’utilisateur
Meilleures pratiques et recommandations pour les développeurs pour les applications dans un environnement
de moindre privilège
L’exemple de code suivant illustre l’utilisation des fonctions de registre.

L’exemple suivant utilise les fonctions RegQuer yInfoKey , RegEnumKeyEx et RegEnumValue pour énumérer
les sous-clés de la clé spécifiée. Le paramètre hKey passé à chaque fonction est un handle vers une clé ouverte.
Cette clé doit être ouverte avant l’appel de fonction et fermée par la suite.
// QueryKey - Enumerates the subkeys of key and its associated values.

// hKey - Key whose subkeys and values are to be enumerated.
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#define MAX_KEY_LENGTH 255

#define MAX_VALUE_NAME 16383
void QueryKey(HKEY hKey)

{
TCHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name
DWORD cbName; // size of name string
TCHAR achClass[MAX_PATH] = TEXT(""); // buffer for class name
DWORD cchClassName = MAX_PATH; // size of class string
DWORD cSubKeys=0; // number of subkeys
DWORD cbMaxSubKey; // longest subkey size
DWORD cchMaxClass; // longest class string
DWORD cValues; // number of values for key
DWORD cchMaxValue; // longest value name
DWORD cbMaxValueData; // longest value data
DWORD cbSecurityDescriptor; // size of security descriptor
FILETIME ftLastWriteTime; // last write time
DWORD i, retCode;
TCHAR achValue[MAX_VALUE_NAME];
DWORD cchValue = MAX_VALUE_NAME;
// Get the class name and the value count.

retCode = RegQueryInfoKey(
hKey, // key handle
achClass, // buffer for class name
&cchClassName, // size of class string
NULL, // reserved
&cSubKeys, // number of subkeys
&cbMaxSubKey, // longest subkey size
&cchMaxClass, // longest class string
&cValues, // number of values for this key
&cchMaxValue, // longest value name
&cbMaxValueData, // longest value data
&cbSecurityDescriptor, // security descriptor
&ftLastWriteTime); // last write time
// Enumerate the subkeys, until RegEnumKeyEx fails.
if (cSubKeys)
{
printf( "\nNumber of subkeys: %d\n", cSubKeys);
for (i=0; i<cSubKeys; i++)

{
cbName = MAX_KEY_LENGTH;
retCode = RegEnumKeyEx(hKey, i,
retCode = RegEnumKeyEx(hKey, i,
achKey,
&cbName,
NULL,
NULL,
NULL,
&ftLastWriteTime);
if (retCode == ERROR_SUCCESS)
{
_tprintf(TEXT("(%d) %s\n"), i+1, achKey);
}
}
}
// Enumerate the key values.
if (cValues)
{
printf( "\nNumber of values: %d\n", cValues);
for (i=0, retCode=ERROR_SUCCESS; i<cValues; i++)

{
cchValue = MAX_VALUE_NAME;
achValue[0] = '\0';
retCode = RegEnumValue(hKey, i,
achValue,
&cchValue,
NULL,
NULL,
NULL,
NULL);
if (retCode == ERROR_SUCCESS )
{
_tprintf(TEXT("(%d) %s\n"), i+1, achValue);
}
}
}
}
int __cdecl _tmain()

{
HKEY hTestKey;
if( RegOpenKeyEx( HKEY_CURRENT_USER,

TEXT("SOFTWARE\\Microsoft"),
0,
KEY_READ,
&hTestKey) == ERROR_SUCCESS
)
{
QueryKey(hTestKey);
}
RegCloseKey(hTestKey);
}
L’exemple de cette rubrique utilise les fonctions RegOpenKeyEx , RegEnumKeyEx et RegDeleteKey pour
supprimer une clé de Registre avec des sous-clés.
Pour tester cet exemple, créez la clé de Registre suivante à l’aide de Regedt32.exe, puis ajoutez les valeurs et les
sous-clés suivantes :
HKEY _ _ TestDir du \ logiciel \ de l’utilisateur actuel
Après avoir exécuté le code, utilisez la touche F5 pour actualiser les données du Registre et notez que la clé
TestDir est supprimée.
#include <stdio.h>
#include <strsafe.h>
//*************************************************************
//
// RegDelnodeRecurse()
//
// Purpose: Deletes a registry key and all its subkeys / values.
//
// Parameters: hKeyRoot - Root key
// lpSubKey - SubKey to delete
//
// Return: TRUE if successful.
// FALSE if an error occurs.
//
//*************************************************************
BOOL RegDelnodeRecurse (HKEY hKeyRoot, LPTSTR lpSubKey)

{
LPTSTR lpEnd;
LONG lResult;
DWORD dwSize;
TCHAR szName[MAX_PATH];
HKEY hKey;
FILETIME ftWrite;
// First, see if we can delete the key without having

// to recurse.
lResult = RegDeleteKey(hKeyRoot, lpSubKey);
if (lResult == ERROR_SUCCESS)
return TRUE;
lResult = RegOpenKeyEx (hKeyRoot, lpSubKey, 0, KEY_READ, &hKey);
if (lResult != ERROR_SUCCESS)
{
if (lResult == ERROR_FILE_NOT_FOUND) {
printf("Key not found.\n");
return TRUE;
}
else {
printf("Error opening key.\n");
return FALSE;
}
}
// Check for an ending slash and add one if it is missing.
lpEnd = lpSubKey + lstrlen(lpSubKey);
if (*(lpEnd - 1) != TEXT('\\'))
{
*lpEnd = TEXT('\\');
lpEnd++;
*lpEnd = TEXT('\0');
}
// Enumerate the keys
dwSize = MAX_PATH;
lResult = RegEnumKeyEx(hKey, 0, szName, &dwSize, NULL,
NULL, NULL, &ftWrite);
{
do {
StringCchCat(lpSubKey, MAX_PATH * 2, szName);
if (!RegDelnodeRecurse(hKeyRoot, lpSubKey)) {
break;
}
dwSize = MAX_PATH;
lResult = RegEnumKeyEx(hKey, 0, szName, &dwSize, NULL,

NULL, NULL, &ftWrite);
} while (lResult == ERROR_SUCCESS);

}
lpEnd--;
RegCloseKey (hKey);
// Try again to delete the key.
lResult = RegDeleteKey(hKeyRoot, lpSubKey);
return TRUE;
return FALSE;
}
//*************************************************************
//
// RegDelnode()
//
// Purpose: Deletes a registry key and all its subkeys / values.
//
// Parameters: hKeyRoot - Root key
// lpSubKey - SubKey to delete
//
// Return: TRUE if successful.
// FALSE if an error occurs.
//
//*************************************************************
BOOL RegDelnode (HKEY hKeyRoot, LPCTSTR lpSubKey)

{
TCHAR szDelKey[MAX_PATH*2];
StringCchCopy (szDelKey, MAX_PATH*2, lpSubKey);

return RegDelnodeRecurse(hKeyRoot, szDelKey);
int __cdecl main()

{
BOOL bSuccess;
bSuccess = RegDelnode(HKEY_CURRENT_USER, TEXT("Software\\TestDir"));
if(bSuccess)
printf("Success!\n");
else printf("Failure.\n");
return 0;
}
sur Windows 2000, il est courant qu’un utilitaire d’installation vérifie la taille actuelle et la taille maximale du
registre pour déterminer s’il y a suffisamment d’espace disponible pour les nouvelles données à ajouter. Cet
exemple montre comment effectuer cette opération par programme à l’aide du compteur de performances « %
quota du registre en cours d’utilisation » dans l’objet système.
L’exemple suivant utilise l’assistance des données de performance (PDH) pour obtenir la valeur de compteur ;
elle doit être liée à PDH. lib. PDH est un ensemble d’API de haut niveau utilisé pour obtenir les données de
performances.
NOTE
il n’est pas nécessaire d’implémenter cette taille de registre-vérifiez sur Windows Server 2003 ou Windows XP, car ils n’ont
pas de limite de quota du registre.
//*******************************************************************
//
// Determines the current and maximum registry size.
//
//*******************************************************************
#include <tchar.h>
#include <stdio.h>
#include <pdh.h>
PDH_STATUS GetRegistrySize( LPTSTR szMachineName,

LPDWORD lpdwCurrentSize, LPDWORD lpdwMaximumSize );
//*******************************************************************
//
// Entry point for the program. This function demonstrates how to
// use the GetRegistrySize function implemented below.
//
// It will use the first argument, if present, as the name of the
// computer whose registry you wish to determine. If unspecified,
// it will use the local computer.
//*******************************************************************
int _tmain( int argc, TCHAR *argv[] )

{
LPTSTR szMachineName = NULL;

PDH_STATUS pdhStatus = 0;
DWORD dwCurrent = 0;
DWORD dwMaximum = 0;
// Allow a computer name to be specified on the command line.

if ( argc > 1 )
szMachineName = argv[1];
// Get the registry size.

pdhStatus=GetRegistrySize(szMachineName, &dwCurrent, &dwMaximum);
// Print the results.

if ( pdhStatus == ERROR_SUCCESS )
{
{
_tprintf( TEXT("Registry size: %ld bytes\n"), dwCurrent );
_tprintf( TEXT("Max registry size: %ld bytes\n"), dwMaximum );
}
else
{
// If the operation failed, print the PDH error message.
LPTSTR szMessage = NULL;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_HMODULE,
GetModuleHandle( TEXT("PDH.DLL") ), pdhStatus,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
szMessage, 0, NULL );
_tprintf( TEXT("GetRegistrySize failed: %s"), szMessage );
LocalFree( szMessage );
}
return 0;
}
//*******************************************************************
//
// Retrieves the current and maximum registry size. It gets this
// information from the raw counter values for the "% Registry Quota
// In Use" performance counter within the System object.
//
// PARAMETERS:
// szMachineName - Null-terminated string that specifies the
// name of the computer whose registry you wish to query.
// If this parameter is NULL, the local computer is used.
//
// lpdwCurrentSize - Receives the current registry size.
//
// lpdwMaximumSize - Receives the maximum registry size.
//
// RETURN VALUE:
// ERROR_SUCCESS if successful. Otherwise, the function
// returns a PDH error code. These error codes can be
// found in PDHMSG.H. A textual error message can be
// retrieved from PDH.DLL using the FormatMessage function.
//
//******************************************************************
PDH_STATUS GetRegistrySize( LPTSTR szMachineName,

LPDWORD lpdwCurrentSize, LPDWORD lpdwMaximumSize )
{
PDH_STATUS pdhResult = 0;
TCHAR szCounterPath[1024];
DWORD dwPathSize = 1024;
PDH_COUNTER_PATH_ELEMENTS pe;
PDH_RAW_COUNTER pdhRawValues;
HQUERY hQuery = NULL;
HCOUNTER hCounter = NULL;
DWORD dwType = 0;
// Open PDH query

pdhResult = PdhOpenQuery( NULL, 0, &hQuery );
if ( pdhResult != ERROR_SUCCESS )
return pdhResult;
__try
{
// Create counter path
pe.szMachineName = szMachineName;
pe.szObjectName = TEXT("System");
pe.szInstanceName = NULL;
pe.szParentInstance = NULL;
pe.dwInstanceIndex = 1;
pe.szCounterName = TEXT("% Registry Quota In Use");
pdhResult = PdhMakeCounterPath( &pe, szCounterPath,

&dwPathSize, 0 );
__leave;
// Add the counter to the query

pdhResult=PdhAddCounter(hQuery, szCounterPath, 0, &hCounter);
__leave;
// Run the query to collect the performance data

pdhResult = PdhCollectQueryData( hQuery );
__leave;
// Retrieve the raw counter data:

// The dividend (FirstValue) is the current registry size
// The divisor (SecondValue) is the maximum registry size
ZeroMemory( &pdhRawValues, sizeof(pdhRawValues) );
pdhResult = PdhGetRawCounterValue( hCounter, &dwType,
&pdhRawValues );
__leave;
// Store the sizes in variables.

if ( lpdwCurrentSize )
*lpdwCurrentSize = (DWORD) pdhRawValues.FirstValue;
if ( lpdwMaximumSize )
*lpdwMaximumSize = (DWORD) pdhRawValues.SecondValue;
}
__finally
{
// Close the query
PdhCloseQuery( hQuery );
}
return 0;
}
Les éléments suivants sont utilisés avec le registre.

Les fonctions de Registre sont les suivantes.
GetSystemRegistr yQuota Récupère la taille actuelle du Registre et la taille maximale

que le Registre est autorisé à atteindre sur le système.
Échec RegCloseKey Ferme un handle vers la clé de Registre spécifiée.
RegConnectRegistr y Établit une connexion à un handle de Registre prédéfini sur

un autre ordinateur.
RegCopyTree Copie la clé de Registre spécifiée, ainsi que ses valeurs et

sous-clés, dans la clé de destination spécifiée.
RegCreateKeyEx Crée la clé de Registre spécifiée.
RegCreateKeyTransacted Crée la clé de Registre spécifiée et l’associe à une transaction.
RegDeleteKey Supprime une sous-clé et ses valeurs.
RegDeleteKeyEx Supprime une sous-clé et ses valeurs de la vue spécifique à

la plateforme spécifiée du Registre.
RegDeleteKeyTransacted Supprime une sous-clé et ses valeurs de la vue spécifique à

la plateforme spécifiée du registre en tant qu’opération
traitée.
RegDeleteKeyValue Supprime la valeur spécifiée de la clé de Registre et de la

sous-clé spécifiées.
RegDeleteTree Supprime les sous-clés et les valeurs de la clé spécifiée de

manière récursive.
RegDeleteValue Supprime une valeur nommée de la clé de Registre spécifiée.
RegDisablePredefinedCache Désactive la mise en cache des handles pour le handle de

Registre prédéfini pour HKEY _ Current _ User pour le
processus en cours.
RegDisablePredefinedCacheEx Désactive la mise en cache des handles pour tous les

descripteurs de Registre prédéfinis pour le processus en
cours.
RegDisableReflectionKey Désactive la réflexion du Registre pour la clé spécifiée.
RegEnableReflectionKey Active la réflexion du Registre pour la clé désactivée spécifiée.

RegEnumKeyEx Énumère les sous-clés de la clé de Registre ouverte spécifiée.
RegEnumValue Énumère les valeurs de la clé de Registre ouverte spécifiée.
Regflushkey a Écrit tous les attributs de la clé de Registre ouverte spécifiée

dans le registre.
RegGetKeySecurity Récupère une copie du descripteur de sécurité protégeant la

clé de Registre ouverte spécifiée.
RegGetValue Récupère le type et les données pour la valeur de Registre

spécifiée.
RegLoadKey Crée une sous-clé sous HKEY _ Users ou HKEY _ local _

machine et stocke les informations d’inscription d’un fichier
spécifié dans cette sous-clé.
RegLoadMUIString Charge la chaîne spécifiée à partir de la clé et de la sous-clé

spécifiées.
RegNotifyChangeKeyValue Notifie l’appelant des modifications apportées aux attributs

ou au contenu d’une clé de Registre spécifiée.
RegOpenCurrentUser Récupère un handle vers la clé de l' _ _ utilisateur actuel

HKEY pour l’utilisateur que le thread actuel emprunte.
RegOpenKeyEx Ouvre la clé de Registre spécifiée.
RegOpenKeyTransacted Ouvre la clé de Registre spécifiée et l’associe à une

transaction.
RegOpenUserClassesRoot Récupère un handle vers la clé _ _ racine HKEY classes

pour l’utilisateur spécifié.
RegOverridePredefKey Cartes une clé de registre prédéfinie à une clé de registre

spécifiée.
RegQuer yInfoKey Récupère des informations sur la clé de Registre spécifiée.
RegQuer yMultipleValues Récupère le type et les données pour une liste de noms de
valeurs associés à une clé de Registre ouverte.
RegQuer yReflectionKey Détermine si la réflexion a été désactivée ou activée pour la

clé spécifiée.
RegQuer yValueEx Récupère le type et les données pour un nom de valeur

spécifié associé à une clé de Registre ouverte.
RegReplaceKey Remplace le fichier qui stocke une clé de Registre et toutes

ses sous-clés par un autre fichier.
RegRestoreKey Lit les informations de Registre dans un fichier spécifié et les

copie sur la clé spécifiée.
RegSaveKey Enregistre la clé spécifiée et toutes ses sous-clés et valeurs

dans un nouveau fichier.
RegSaveKeyEx Enregistre la clé spécifiée et toutes ses sous-clés et valeurs

dans un nouveau fichier. Vous pouvez spécifier le format de
la clé ou de la ruche enregistrée.
RegSetKeyValue Définit les données pour la valeur spécifiée dans la clé de

Registre et la sous-clé spécifiées.
RegSetKeySecurity Définit la sécurité d’une clé de Registre ouverte.
RegSetValueEx Définit les données et le type d’une valeur spécifiée sous une
clé de registre.
RegUnLoadKey Décharge la clé de Registre spécifiée et ses sous-clés du

Registre.
Les fonctions Shell suivantes peuvent être utilisées avec le registre :

AssocCreate
AssocQuer yKey
AssocQuer yString
AssocQuer yStringByKey
SHCopyKey
SHDeleteEmptyKey
SHDeleteKey
SHDeleteValue
SHEnumKeyEx
SHEnumValue
SHGetValue
SHQuer yInfoKey
SHQuer yValueEx
SHRegCloseUSKey
SHRegCreateUSKey
SHRegDeleteEmptyUSKey
SHRegDeleteUSValue
SHRegDuplicateHKey
SHRegEnumUSKey
SHRegEnumUSValue
SHRegGetBoolUSValue
SHRegGetIntW
SHRegGetPath
SHRegGetUSValue
SHRegOpenUSKey
SHRegQuer yInfoUSKey
SHRegQuer yUSValue
SHRegSetPath
SHRegSetUSValue
SHRegWriteUSValue
SHSetValue
Les fonctions de fichier d’initialisation sont les suivantes. Ils récupèrent les informations de et copient les
informations dans un fichier d’initialisation défini par le système ou par l’application. Ces fonctions sont fournies
uniquement à des fins de compatibilité avec les versions 16 bits de Windows. Les nouvelles applications doivent
utiliser le registre.
GetPrivateProfileInt Récupère un entier associé à une clé dans la section spécifiée

d’un fichier d’initialisation.
GetPrivateProfileSection Récupère toutes les clés et valeurs de la section spécifiée

d’un fichier d’initialisation.
GetPrivateProfileSectionNames Récupère les noms de toutes les sections d’un fichier

d’initialisation.
GetPrivateProfileString Récupère une chaîne à partir de la section spécifiée dans un

fichier d’initialisation.
GetPrivateProfileStruct Récupère les données associées à une clé dans la section

spécifiée d’un fichier d’initialisation.
GetProfileInt Récupère un entier d’une clé dans la section spécifiée du

fichier Win.ini.
GetProfileSection Récupère toutes les clés et valeurs de la section spécifiée du

fichier Win.ini.
GetProfileString Récupère la chaîne associée à une clé dans la section

spécifiée du fichier Win.ini.
WritePrivateProfileSection Remplace les clés et les valeurs de la section spécifiée dans

un fichier d’initialisation.
WritePrivateProfileString Copie une chaîne dans la section spécifiée d’un fichier

d’initialisation.
WritePrivateProfileStruct Copie des données dans une clé de la section spécifiée d’un
fichier d’initialisation.
WriteProfileSection Remplace le contenu de la section spécifiée dans le fichier

Win.ini par les valeurs et clés spécifiées.
WriteProfileString Copie une chaîne dans la section spécifiée du fichier Win.ini.
Fonctions obsolètes
Ces fonctions sont fournies uniquement à des fins de compatibilité avec les versions 16 bits de Windows :
RegCreateKey
RegEnumKey
RegOpenKey
RegQuer yValue
RegSetValue
La structure suivante est utilisée avec le registre.

FRÉQUENT
Le tableau suivant identifie les limites de taille pour les différents éléments du Registre.
ÉL ÉM EN T REGIST RY TA IL L E M A XIM A L E
Nom de clé 255 caractères. Le nom de clé comprend le chemin d’accès

absolu de la clé dans le registre, en commençant toujours à
une clé de base, par exemple, HKEY _ local _ machine.
Nom de la valeur 16 383 caractères Windows 2000 : 260 caractères ANSI

ou 16 383 caractères Unicode.
Valeur Mémoire disponible (format le plus récent) 1 Mo (format

standard)
Arborescence Une arborescence du Registre peut avoir 512 niveaux de

profondeur. Vous pouvez créer jusqu’à 32 niveaux à la fois à
l’aide d’un appel d’API de Registre unique.
Les valeurs longues (plus de 2 048 octets) doivent être stockées dans un fichier et l’emplacement du fichier doit
être stocké dans le registre. Cela permet au registre de fonctionner efficacement.
L’emplacement du fichier peut être le nom d’une valeur ou les données d’une valeur. Chaque barre oblique
inverse dans la chaîne d’emplacement doit être précédée d’une autre barre oblique inverse comme caractère
d’échappement. Par exemple, spécifiez « C : \ \ mydir \ \ MyFile » pour stocker la chaîne « c : \ mydir \ MyFile ».
Un emplacement de fichier peut également être le nom d’une clé s’il se trouve dans la limite de 255 caractères
pour les noms de clé et ne contient pas de barres obliques inverses, qui ne sont pas autorisées dans les noms de
clés.
Une valeur de Registre peut stocker des données dans différents formats. Lorsque vous stockez des données
sous une valeur de Registre, par exemple en appelant la fonction RegSetValueEx , vous pouvez spécifier l’une
des valeurs suivantes pour indiquer le type de données stockées. Lorsque vous récupérez une valeur de
Registre, les fonctions telles que RegQuer yValueEx utilisent ces valeurs pour indiquer le type de données
récupérées.
Les types de valeurs de registre suivants sont définis dans Winnt. h.
VA L EUR TYPE
_fichier binaire reg Données binaires dans tout formulaire.
_valeur DWORD reg Nombre de 32 bits.
REG _ DWORD _ Little _ ENDIAN Nombre 32 bits au format avec primauté des octets de poids
faible (Little endian).
Windows est conçu pour s’exécuter sur des architectures
d’ordinateur little-endian. par conséquent, cette valeur est
définie en tant que REG _ DWORD dans les fichiers d’en-tête
Windows.
REG _ DWORD _ Big _ ENDIAN Nombre 32 bits au format Big-endian.

certains systèmes de UNIX prennent en charge les
architectures de big-endian.
REG _ développer _ SZ Chaîne terminée par le caractère null qui contient des
références non développées à des variables d’environnement
(par exemple, "% PATH%"). Il s’agit d’une chaîne Unicode ou
ANSI selon que vous utilisez les fonctions Unicode ou ANSI.
Pour développer les références de variable d’environnement,
utilisez la fonction ExpandEnvironmentStrings .
_lien reg Chaîne Unicode terminée par le caractère null qui contient le
chemin d’accès cible d’un lien symbolique qui a été créé en
appelant la fonction RegCreateKeyEx avec l’option de
création de la _ commande reg _ _ .
REG _ multiple _ SZ Séquence de chaînes se terminant par un caractère null,

terminée par une chaîne vide ( \ 0).
Par exemple :
Chaîne1 \ 0 Chaîne2 \ 0 string3 \ 0 LastString \ 0 \ 0
Le premier \ 0 termine la première chaîne, la seconde
jusqu’au dernier \ 0 termine la dernière chaîne, et le \ 0 final
termine la séquence. Notez que la marque de fin finale doit
être factorisée dans la longueur de la chaîne.
REG _ aucun Aucun type valeur défini.
_q QWord Nombre de 64 bits.

VA L EUR TYPE
_ _ faible primauté des _ octets de poids faible Nombre 64 bits au format avec primauté des octets de poids
faible (Little endian).
Windows est conçu pour s’exécuter sur des architectures
d’ordinateur little-endian. par conséquent, cette valeur est
définie sous _ la forme REG QWORD dans les fichiers d’en-
tête Windows.
SZ de REG _ Chaîne se terminant par une valeur null. Il s’agit d’une chaîne
Unicode ou ANSI, selon que vous utilisez les fonctions
Unicode ou ANSI.
Valeurs de type chaîne

Si les données ont le _ type reg SZ, reg _ _ multisz ou reg _ expand _ SZ, la chaîne n’a peut-être pas été stockée
avec les caractères null de fin appropriés. Par conséquent, lors de la lecture d’une chaîne à partir du Registre,
vous devez vous assurer que la chaîne se termine correctement avant de l’utiliser. Sinon, elle peut remplacer une
mémoire tampon. (Notez que REG _ Les _ chaînes à plusieurs SZ doivent avoir deux caractères null de fin.)
Lors de l’écriture d’une chaîne dans le registre, vous devez spécifier la longueur de la chaîne, y compris le
caractère null de fin ( \ 0). Une erreur courante consiste à utiliser la fonction strlen pour déterminer la longueur
de la chaîne, mais d’oublier que strlen retourne uniquement le nombre de caractères de la chaîne, à l’exclusion
de la valeur null de fin. Par conséquent, la longueur de la chaîne doit être calculée comme suit :
strlen( string ) + 1
Une _ _ chaîne à plusieurs SZS reg se termine par une chaîne de longueur 0. Par conséquent, il n’est pas possible
d’inclure une chaîne de longueur nulle dans la séquence. Une séquence vide est définie comme suit : \ 0.
L’exemple suivant parcourt _ une _ chaîne reg multiple sz.
#include <tchar.h>
#include <stdio.h>
void SampleSzz(PTSTR pszz)

{
_tprintf(_TEXT("\tBegin multi-sz string\n"));
while (*pszz)
{
_tprintf(_TEXT("\t\t%s\n"), pszz);
pszz = pszz + _tcslen(pszz) + 1;
}
_tprintf(_TEXT("\tEnd multi-sz\n"));
}
int __cdecl main(int argc, char **argv)

{
// Because the compiler adds a \0 at the end of quoted strings,
// there are two \0 terminators at the end.
_tprintf(_TEXT("Conventional multi-sz string:\n"));

SampleSzz(_TEXT("String1\0String2\0String3\0LastString\0"));
_tprintf(_TEXT("\nTest case with no strings:\n"));

SampleSzz(_TEXT(""));
return 0;
}
Formats d’octets
Dans un format avec primauté des octets de poids faible ( Little-endian), une valeur multioctet est stockée en
mémoire à partir de l’octet le plus bas (le « petit end ») jusqu’à l’octet le plus élevé. Par exemple, la valeur
0x12345678 sinon est stockée sous la forme (0x78 0x56 0x34 0x12) au format avec primauté des octets de
poids faible (Little endian).
Au format Big-endian, une valeur sur plusieurs octets est stockée en mémoire à partir de l’octet le plus élevé (le
« Big end ») jusqu’à l’octet le plus bas. Par exemple, la valeur 0x12345678 sinon est stockée sous la forme (0x12
0x34 0x56 0x78) au format Big-endian.
Informations système
Les fonctions d’informations système et les messages décrivent ou modifient la configuration, les paramètres et
les attributs du système.
Utilisation de System Information
Les fonctions décrites dans cette vue d’ensemble récupèrent une variété de données. Les informations de
configuration du système décrivent le matériel de l’ordinateur, le nom de l’ordinateur et le nom d’utilisateur. Les
informations de configuration du système d’exploitation décrivent la version du système d’exploitation, les
répertoires de clés et les variables d’environnement. Les paramètres système décrivent les attributs système. Les
métriques du système fournissent les dimensions des éléments dans la zone d’affichage.
Les sections suivantes expliquent comment obtenir ces types d’informations :
Configuration matérielle
Noms des ordinateurs
Version du système d’exploitation
Hardware Configuration
Les fonctions de configuration matérielle récupèrent des informations telles que le processeur, le profil matériel
et les informations de clavier.
La fonction GetSystemInfo récupère les informations sur le processeur et la mémoire, telles que la taille de la
page, l’identificateur OEM (Original Equipment Manufacturer), le nombre et le type de processeurs, la plage
d’adresses d’application, etc. La fonction IsProcessorFeaturePresent récupère des informations sur les
opérations à virgule flottante et les jeux d’instructions pris en charge par le processeur.
La fonction GetCurrentHwProfile récupère des informations sur le profil matériel. Le profil matériel comprend
des informations telles que l’état d’ancrage, l’identificateur global unique (GUID) et le nom d’affichage du profil.
La fonction GetKeyboardType récupère des informations telles que le type de clavier et le nombre de touches
de fonction sur le clavier actuel.
Noms d'ordinateur
Les noms DNS se composent d’un ou plusieurs composants séparés par un point (par exemple,
msdn.microsoft.com). Chaque composant peut comporter jusqu’à 63 octets. Chaque nom peut comporter
jusqu’à 255 octets au total. Les noms DNS sont représentés dans le jeu de caractères UTF-8 ou Unicode. Ce nom
ne respecte pas la casse. Pour plus d’informations, consultez DnsValidateName .
Un ordinateur est identifié de manière unique par son nom DNS complet, qui se compose de son nom d’hôte
DNS et du nom du domaine DNS auquel il est attribué. Pour récupérer le nom DNS complet d’un ordinateur, le
nom d’hôte DNS ou le nom de domaine DNS, appelez la fonction GetComputerNameEx . Pour définir le nom
d’hôte DNS ou le nom de domaine DNS d’un ordinateur, appelez la fonction SetComputerNameEx . Les
modifications de nom ne prennent pas effet tant que l’utilisateur n’a pas redémarré l’ordinateur.
Les noms NetBIOS comportent jusqu’à 15 octets de caractères OEM, notamment des lettres, des chiffres, des
traits d’Union et des points. Certains caractères sont spécifiques au jeu de caractères. Les noms NetBIOS sont
généralement représentés dans le jeu de caractères OEM. Le jeu de caractères OEM dépend des paramètres
régionaux. Certains jeux de caractères OEM représentent certains caractères sous la forme de deux octets. Les
noms NetBIOS, par Convention, sont représentés en majuscules lorsque l’algorithme de traduction des
minuscules et majuscules est dépendant du jeu de caractères OEM.
Les fonctions SetComputerNameEx et GetComputerNameEx peuvent également définir et récupérer le
nom NetBIOS de l’ordinateur. Par Convention, le nom NetBIOS et le nom d’hôte DNS sont interdépendants.
Lorsque vous modifiez le nom DNS, le nom NetBIOS est également mis à jour. Le nom NetBIOS est la
représentation OEM du nom d’hôte DNS jusqu’à la _ longueur maximale des _ caractères ComputerName. Si
vous définissez un nom d’hôte DNS supérieur à la longueur maximale du nom d' _ ordinateur _ , le nom
NetBIOS est défini sur une version tronquée du nom d’hôte DNS. Dans le cas contraire, le nom d’hôte DNS
entier est converti en nom NetBIOS OEM. AVERTISSEMENT : Si vous modifiez le nom NetBIOS afin qu’il ne s’agit
pas d’un mappage tronqué du nom DNS, vous allez rompre les applications qui utilisent des fonctions telles que
DnsHostnameToComputerName qui reposent sur cette Convention.
Version du système d'exploitation
Les fonctions d’assistance de l’API de version sont utilisées pour déterminer la version du système d’exploitation
en cours d’exécution. Pour plus d’informations, consultez obtention de la version du système.
Le tableau suivant récapitule les numéros de version des systèmes d’exploitation les plus récents.
SY ST ÈM E D’EXP LO ITAT IO N N UM ÉRO DE VERSIO N
Windows 10 10,0*
Windows Server 2019 10,0*
Windows Server 2016 10,0*
Windows 8.1 6.3*
Windows Server 2012 R2 6.3*
Windows 8 6.2
Windows Server 2012 6.2
Windows 7 6.1
Windows Server 2008 R2 6.1
Windows Vista 6.0
Windows Server 2003 R2 5.2
Windows XP Édition 64 bits 5.2
Windows XP 5,1
Windows 2000 5.0
* pour les applications qui ont été manifestées pour Windows 8.1 ou Windows 10. les Applications qui ne sont
pas manifestes pour Windows 8.1 ou Windows 10 retourneront la valeur de version du système d’exploitation
Windows 8 (6,2). pour manifester vos applications pour Windows 8.1 ou Windows 10, consultez ciblage de
votre application pour Windows.
L’identification du système d’exploitation actuel n’est généralement pas la meilleure façon de déterminer si une
fonctionnalité particulière du système d’exploitation est présente. Cela est dû au fait que de nouvelles
fonctionnalités ont été ajoutées au système d’exploitation dans une DLL redistribuable. Au lieu d’utiliser les
fonctions d’assistance de l' API de version pour déterminer la plate-forme ou le numéro de version du système
d’exploitation, vérifiez la présence de la fonctionnalité elle-même.
Pour déterminer la meilleure façon de tester une fonctionnalité, reportez-vous à la documentation de la
fonctionnalité qui vous intéresse. La liste suivante présente quelques techniques courantes pour la détection de
fonctionnalités :
Vous pouvez tester la présence des fonctions associées à une fonctionnalité. Pour tester la présence d’une
fonction dans une DLL système, appelez la fonction LoadLibrar y pour charger la dll. Appelez ensuite la
fonction GetProcAddress pour déterminer si la fonction d’intérêt est présente dans la dll. Utilisez le
pointeur retourné par GetProcAddress pour appeler la fonction. Notez que même si la fonction est
présente, il peut s’agir d’un stub qui retourne simplement un code d’erreur tel que l’appel d’erreur _ _ non _
implémenté.
Vous pouvez déterminer la présence de certaines fonctionnalités à l’aide de la fonction GetSystemMetrics .
Par exemple, vous pouvez détecter plusieurs moniteurs d’affichage en appelant GetSystemMetrics (SM _
CMONITORS).
Il existe plusieurs versions des dll redistribuables qui implémentent l’interpréteur de commandes et les
fonctionnalités de contrôle communes. Pour plus d’informations sur la détermination des versions présentes
sur le système sur lequel votre application s’exécute, consultez la rubrique Shell et versions des contrôles
communs.
Si vous devez exiger un système d’exploitation particulier, veillez à l’utiliser comme version minimale prise en
charge, plutôt que de concevoir le test pour l’un des systèmes d’exploitation. De cette façon, votre code de
détection continuera à fonctionner sur les futures versions de Windows.
Notez qu’une application 32 bits peut détecter si elle s’exécute sous WOW64 en appelant la fonction
IsWow64Process . Il peut obtenir des informations supplémentaires sur le processeur en appelant la fonction
GetNativeSystemInfo .
pour plus d’informations, consultez la page informations de mise en Windows 10 et Windows cycle de vie du
cycle de vie.
le répertoire Windows est le répertoire qui contient des applications basées sur des Windows, des fichiers
d’initialisation et des fichiers d’aide. La fonction GetWindowsDirector y récupère le chemin d’accès à ce
répertoire.
Le répertoire système est le répertoire qui contient les bibliothèques de liens dynamiques, les pilotes et les
fichiers de police. La fonction GetSystemDirector y récupère le chemin d’accès à ce répertoire.
La fonction getUserName récupère le nom de l’utilisateur actuellement connecté au système. Le nom
d’utilisateur est soit le nom d’ouverture de session, soit le nom complet de l’utilisateur, si ce dernier est inclus
dans le registre.
Une variable d’environnement est une variable symbolique qui représente un élément du système, tel qu’un
chemin d’accès, un nom de fichier ou d’autres données littérales. Par exemple, le chemin d’accès de la variable
d’environnement représente les répertoires dans lesquels rechercher les fichiers exécutables. Lorsqu’un
utilisateur ouvre une session, le système initialise les variables d’environnement en fonction de la section
environnement du Registre. La fonction ExpandEnvironmentStrings récupère les valeurs des variables
d’environnement spécifiées.
Des informations supplémentaires sont fournies par l’interface IADsADSystemInfo .
Utilisation des informations système
Les rubriques suivantes expliquent comment utiliser les informations système :

Obtention d’informations système
Accéder aux informations SMBIOS à partir d’une application Windows universelle
Accéder aux variables de microprogramme UEFI à partir d’une application Windows universelle
accéder aux informations SMBIOS à partir d’une
application de Windows universel
OBSERVE Certaines informations relatives aux produits précommercialisés peuvent être substantiellement
modifiées avant leur commercialisation. Microsoft exclut toute garantie, expresse ou implicite, concernant
les informations fournies ici.
comment accéder aux informations SMBIOS (System Management BIOS) à partir d’une application Windows
universelle.
accéder aux informations SMBIOS à partir d’une application

plateforme Windows universelle
à compter de Windows 10, la version 1803, les applications universelles Windows peuvent utiliser
GetSystemFirmwareTable et EnumSystemFirmwareTables pour accéder aux informations smbios en déclarant la
fonctionnalité restreinte smbios dans le manifeste de l’application.
IMPORTANT
seul l’accès aux tables du microprogramme SMBIOS brut (RSMB) est pris en charge à partir d’une application Windows
universelle. Accès _ le refus est retourné si vous essayez d’accéder à d’autres types de table de microprogramme à partir
d’une application de Windows universelle.
Pour déclarer la fonctionnalité restreinte SMBIOS dans le manifeste de l’application, ajoutez l’espace de noms
ResCap et la fonction SMBIOS comme suit :
<Package
...
xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
IgnorableNamespaces="uap mp rescap">
...
<Capabilities>
<rescap:Capability Name="smbios"/>
</Capabilities>
</Package>
Rubriques connexes
Fonctionnalités spéciales et restreintes
GetSystemFirmwareTable
EnumSystemFirmwareTables
accéder aux variables de microprogramme UEFI à partir d’une application Windows universelle
Accéder aux variables de microprogramme UEFI à
partir d’une application Windows universelle
[Certaines informations relatives aux produits précommercialisés peuvent être substantiellement modifiées
avant leur commercialisation. Microsoft ne donne aucune garantie, expresse ou implicite, concernant les
informations fournies ici.]
Comment accéder aux variables du microprogramme Unified Extensible Firmware Interface (UEFI) à partir d’une
application Windows universelle.
À compter de Windows 10, version 1803, les applications Windows universelles peuvent utiliser
GetFirmwareEnvironmentVariable et SetFirmwareEnvironmentVariable (et leurs variantes « ex ») pour
accéder aux variables de microprogramme UEFI en procédant comme suit :
Déclarez la fonctionnalité personnalisée _ Cw5n1h2txyewy de Microsoft. firmwareRead dans le
manifeste pour lire une variable de microprogramme, et/ou la fonction Microsoft. firmwareWrite _
cw5n1h2txyewy pour écrire une variable de microprogramme.
Déclarez également la fonctionnalité restreinte protectedApp dans le manifeste de l’application.
Par exemple, les ajouts du manifeste de l’application suivants permettent à l’application Windows
universelle de lire les variables du microprogramme :
<Package
...
xmlns:uap4=http://schemas.microsoft.com/appx/manifest/uap/windows10/4
xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
IgnorableNamespaces="uap mp uap4 rescap">
...
<Capabilities>
<rescap:Capability Name="protectedApp"/>
<uap4:CustomCapability Name="microsoft.firmwareRead_cw5n1h2txyewy" />
</Capabilities>
</Package>
Définissez l’option de l’éditeur de liens /INTEGRITYCHECK , pour toutes les configurations de projet,
avant d’envoyer l’application au Microsoft Store. Cela permet de s’assurer que l’application sera lancée
comme une application protégée. Pour plus d’informations , consultez/INTEGRITYCHECK (exiger la
vérification de la signature) .
Obtenez un fichier de descripteur de capacité personnalisée (SCCD) signé auprès de Microsoft. Consultez
création d’une fonctionnalité personnalisée pour associer un pilote à une application de prise en charge
matérielle (HSA) et utilisation d’une fonctionnalité personnalisée pour associer une application de
support matériel (HSA) à un pilote pour plus d’informations sur la façon d’obtenir un fichier SCCD signé
de Microsoft, de l’empaqueter avec votre application et de l’activation du mode développeur. Voici un
exemple de fichier SSCD de l' exemple CustomCapability:
<?xml version="1.0" encoding="utf-8"?>
<CustomCapabilityDescriptor xmlns="http://schemas.microsoft.com/appx/2016/sccd"
xmlns:s="http://schemas.microsoft.com/appx/2016/sccd">
<CustomCapabilities>
<CustomCapability Name="microsoft.hsaTestCustomCapability_q536wpkpf5cy2"></CustomCapability>
<CustomCapability Name="microsoft.firmwareRead_cw5n1h2txyewy"></CustomCapability>
</CustomCapabilities>
<AuthorizedEntities>
<AuthorizedEntity AppPackageFamilyName="Microsoft.SDKSamples.CustomCapability.CPP_8wekyb3d8bbwe"
CertificateSignatureHash="ca9fc964db7e0c2938778f4559946833e7a8cfde0f3eaa07650766d4764e86c4">
</AuthorizedEntity>
<AuthorizedEntity AppPackageFamilyName="Microsoft.SDKSamples.CustomCapability.CPP_8wekyb3d8bbwe"
CertificateSignatureHash="279cd652c4e252bfbe5217ac722205d7729ba409148cfa9e6d9e5b1cb94eaff1">
</AuthorizedEntity>
</AuthorizedEntities>
<Catalog>xxxx</Catalog>
</CustomCapabilityDescriptor>
Soumettez l’application à la Microsoft Store pour la faire signer. À des fins de développement, vous
pouvez ignorer la signature en activant test-Signing dans la base de données de configuration de
démarrage (BCD). Pour plus d’informations, consultez l’option de configuration de démarrage testsigning
.
Rubriques connexes
Fonctionnalités spéciales et restreintes
GetFirmwareEnvironmentVariable
GetFirmwareEnvironmentVariableEx
SetFirmwareEnvironmentVariable
SetFirmwareEnvironmentVariableEx
Accéder aux informations SMBIOS à partir d’une application Windows universelle
Obtention de System Information
L’exemple suivant utilise les fonctions GetComputerName , getUserName , GetSystemDirector y ,

GetWindowsDirector y et ExpandEnvironmentStrings pour récupérer des informations qui décrivent la
configuration du système.
#include <tchar.h>
#include <stdio.h>
TCHAR* envVarStrings[] =
{
TEXT("OS = %OS%"),
TEXT("PATH = %PATH%"),
TEXT("HOMEPATH = %HOMEPATH%"),
TEXT("TEMP = %TEMP%")
};
#define ENV_VAR_STRING_COUNT (sizeof(envVarStrings)/sizeof(TCHAR*))
#define INFO_BUFFER_SIZE 32767
void printError( TCHAR* msg );
void main( )
{
DWORD i;
TCHAR infoBuf[INFO_BUFFER_SIZE];
DWORD bufCharCount = INFO_BUFFER_SIZE;
// Get and display the name of the computer.

bufCharCount = INFO_BUFFER_SIZE;
if( !GetComputerName( infoBuf, &bufCharCount ) )
printError( TEXT("GetComputerName") );
_tprintf( TEXT("\nComputer name: %s"), infoBuf );
// Get and display the user name.

bufCharCount = INFO_BUFFER_SIZE;
if( !GetUserName( infoBuf, &bufCharCount ) )
printError( TEXT("GetUserName") );
_tprintf( TEXT("\nUser name: %s"), infoBuf );
// Get and display the system directory.

if( !GetSystemDirectory( infoBuf, INFO_BUFFER_SIZE ) )
printError( TEXT("GetSystemDirectory") );
_tprintf( TEXT("\nSystem Directory: %s"), infoBuf );
// Get and display the Windows directory.

if( !GetWindowsDirectory( infoBuf, INFO_BUFFER_SIZE ) )
printError( TEXT("GetWindowsDirectory") );
_tprintf( TEXT("\nWindows Directory: %s"), infoBuf );
// Expand and display a few environment variables.

_tprintf( TEXT("\n\nSmall selection of Environment Variables:") );
for( i = 0; i < ENV_VAR_STRING_COUNT; ++i )
{
bufCharCount = ExpandEnvironmentStrings(envVarStrings[i], infoBuf,
INFO_BUFFER_SIZE );
if( bufCharCount > INFO_BUFFER_SIZE )
_tprintf( TEXT("\n\t(Buffer too small to expand: \"%s\")"),
envVarStrings[i] );
else if( !bufCharCount )
printError( TEXT("ExpandEnvironmentStrings") );
else
else
_tprintf( TEXT("\n %s"), infoBuf );
}
_tprintf( TEXT("\n\n"));
}
void printError( TCHAR* msg )

{
DWORD eNum;
TCHAR sysMsg[256];
TCHAR* p;
eNum = GetLastError( );
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, eNum,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
sysMsg, 256, NULL );
// Trim the end of the line and terminate it with a null

p = sysMsg;
while( ( *p > 31 ) || ( *p == 9 ) )
++p;
do { *p-- = 0; } while( ( p >= sysMsg ) &&
( ( *p == '.' ) || ( *p < 33 ) ) );
// Display the message

_tprintf( TEXT("\n\t%s failed with error %d (%s)"), msg, eNum, sysMsg );
}
L’exemple suivant utilise les fonctions d’assistance de l’API de version pour déterminer la version du système
d’exploitation actuel, s’il s’agit d’une version serveur ou client, puis affiche ces informations dans la console. Si le
mode de compatibilité est activé, l’exemple affiche le système d’exploitation sélectionné pour la compatibilité des
applications.
Le fait de compter sur les informations de version n’est pas la meilleure façon de tester une fonctionnalité. Au
lieu de cela, reportez-vous à la documentation de la fonctionnalité qui vous intéresse. Pour plus d’informations
sur les techniques courantes de détection des fonctionnalités, consultez version du système d’exploitation.
#include <stdio.h>
#include <VersionHelpers.h>
int
__cdecl
wmain(
__in int argc,
__in_ecount(argc) PCWSTR argv[]
)
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
if (IsWindowsXPOrGreater())
{
printf("XPOrGreater\n");
}
if (IsWindowsXPSP1OrGreater())
{
printf("XPSP1OrGreater\n");
}
{
}
{
}
if (IsWindowsVistaOrGreater())
{
printf("VistaOrGreater\n");
}
if (IsWindowsVistaSP1OrGreater())
{
printf("VistaSP1OrGreater\n");
}
if (IsWindowsVistaSP2OrGreater())
{
printf("VistaSP2OrGreater\n");
}
if (IsWindows7OrGreater())
{
printf("Windows7OrGreater\n");
}
if (IsWindows7SP1OrGreater())
{
printf("Windows7SP1OrGreater\n");
}
{
}
if (IsWindows8Point1OrGreater())
{
printf("Windows8Point1OrGreater\n");
}
{
}
if (IsWindowsServer())
{
printf("Server\n");
}
else
{
printf("Client\n");
}
}
[ L’utilisation de la fonction VerifyVersionInfo pour vérifier le système d’exploitation en cours d’exécution n’est
pas recommandée. Utilisez plutôt les API d’assistance de version ]
Contient des exemples qui utilisent la fonction VerifyVersionInfo pour déterminer si l’application s’exécute sur
un système d’exploitation spécifique.
Les principales étapes de chaque exemple sont les suivantes :
1. Définissez les valeurs appropriées dans la structure OSVERSIONINFOEX .
2. Définissez le masque de condition approprié à l’aide de la macro de _ _ condition Set de ver .
3. Appelez VerifyVersionInfo pour effectuer le test.
Exemple 1
L’exemple suivant détermine si l’application s’exécute sur Windows XP avec Service Pack 2 (SP2) ou une version
ultérieure de Windows, telle que Windows Server 2003 ou Windows Vista.
#include <stdio.h>
BOOL Is_WinXP_SP2_or_Later ()
{
OSVERSIONINFOEX osvi;
DWORDLONG dwlConditionMask = 0;
int op=VER_GREATER_EQUAL;
// Initialize the OSVERSIONINFOEX structure.
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
osvi.dwMajorVersion = 5;
osvi.dwMinorVersion = 1;
osvi.wServicePackMajor = 2;
osvi.wServicePackMinor = 0;
// Initialize the condition mask.
VER_SET_CONDITION( dwlConditionMask, VER_MAJORVERSION, op );

VER_SET_CONDITION( dwlConditionMask, VER_MINORVERSION, op );
VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMAJOR, op );
VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMINOR, op );
// Perform the test.
return VerifyVersionInfo(
&osvi,
VER_MAJORVERSION | VER_MINORVERSION |
VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
dwlConditionMask);
}
void main()
{
if(Is_WinXP_SP2_or_Later())
printf("The system meets the requirements.\n");
else printf("The system does not meet the requirements.\n");
}
Exemple 2
Le code suivant vérifie que l’application s’exécute sur le serveur Windows 2000 ou sur un serveur ultérieur, tel
que Windows Server 2003 ou Windows Server 2008.
#include <stdio.h>
BOOL Is_Win_Server()
{
int op=VER_GREATER_EQUAL;
osvi.dwMajorVersion = 5;
osvi.dwMinorVersion = 0;
osvi.wServicePackMajor = 0;
osvi.wServicePackMinor = 0;
osvi.wProductType = VER_NT_SERVER;
// Initialize the condition mask.
VER_SET_CONDITION( dwlConditionMask, VER_MAJORVERSION, op );

VER_SET_CONDITION( dwlConditionMask, VER_MINORVERSION, op );
VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMAJOR, op );
VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMINOR, op );
VER_SET_CONDITION( dwlConditionMask, VER_PRODUCT_TYPE, VER_EQUAL );
&osvi,
VER_MAJORVERSION | VER_MINORVERSION |
VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR |
VER_PRODUCT_TYPE,
dwlConditionMask);
}
void main()
{
if(Is_Win_Server())
printf("The system meets the requirements.\n");
else printf("The system does not meet the requirements.\n");
}
L’exemple suivant utilise la fonction VerifyVersionInfo pour déterminer si la suite de produits spécifiée est
installée sur l’ordinateur local.
Cet exemple utilise le VER _ et l’indicateur. Si deux indicateurs sont spécifiés dans le masque de suite, la fonction
retourne true uniquement si les deux suites de produits sont présentes. Si l’exemple a été modifié pour utiliser
le VER _ ou l’indicateur, VerifyVersionInfo retourne la valeur true si l’une des suites de produits était
présente.
#include <stdio.h>
BOOL CheckProductSuite ( WORD wSuite )

{
osvi.wSuiteMask = wSuite;
// Set up the condition mask.
VER_SET_CONDITION( dwlConditionMask,
VER_SUITENAME, VER_AND );
&osvi,
VER_SUITENAME,
dwlConditionMask);
}
void main()
{
if( CheckProductSuite(VER_SUITE_ENTERPRISE) )
printf( "The system meets the requirements.\n" );
else printf( "The system does not meet the requirements.\n");
}
L’exemple suivant utilise la fonction GetSystemInfo pour obtenir des informations matérielles, telles que
l’identificateur OEM, le type de processeur, la taille de page, etc. L’exemple affiche les informations dans la
console.
#include <stdio.h>
#pragma comment(lib, "user32.lib")
void main()
{
SYSTEM_INFO siSysInfo;
// Copy the hardware information to the SYSTEM_INFO structure.
GetSystemInfo(&siSysInfo);
// Display the contents of the SYSTEM_INFO structure.
printf("Hardware information: \n");

printf(" OEM ID: %u\n", siSysInfo.dwOemId);
printf(" Number of processors: %u\n",
siSysInfo.dwNumberOfProcessors);
printf(" Page size: %u\n", siSysInfo.dwPageSize);
printf(" Processor type: %u\n", siSysInfo.dwProcessorType);
printf(" Minimum application address: %lx\n",
siSysInfo.lpMinimumApplicationAddress);
printf(" Maximum application address: %lx\n",
siSysInfo.lpMaximumApplicationAddress);
printf(" Active processor mask: %u\n",
siSysInfo.dwActiveProcessorMask);
}
Ciblage de votre application pour Windows
dans Windows 8.1 et Windows 10, les fonctions GetVersion et GetVersionEx sont dépréciées. dans Windows
10, la fonction VerifyVersionInfo a également été dépréciée. bien que vous puissiez toujours appeler les
fonctions déconseillées, si votre application ne cible pas spécifiquement Windows 8.1 ou Windows 10, les
fonctions retournent la version Windows 8 (6,2).
NOTE
GetVersion , GetVersionEx, VerifyVersionInfo et les fonctions d’assistance de version concernent uniquement les
applications de bureau. les applications de Windows universelles peuvent utiliser la propriété AnalyticsInfo.
VersionInfo pour les journaux de diagnostic et de télémétrie.
pour que votre application cible Windows 8.1 ou Windows 10, vous devez inclure un manifeste d’application
(exécutable) pour l’exécutable de l’application. ensuite, dans la section < > compatibilité du manifeste, vous
devez ajouter un élémentos < pris en charge > pour chaque version de Windows que vous souhaitez déclarer
prise en charge par votre application.
l’exemple suivant montre un fichier manifeste d’application pour une application qui prend en charge toutes les
versions de Windows de Windows Vista à Windows 10 :

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-
com:asm.v3">
<assemblyIdentity
type="win32"
name="Contoso.ExampleApplication.ExampleBinary"
version="1.2.3.4"
processorArchitecture="x86"
/>
<description>Contoso Example Application</description>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>

<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>

<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>

<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>

<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>

<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
</application>
</compatibility>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>

<requestedExecutionLevel
level="asInvoker"
uiAccess="false"
/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>
la déclaration de la prise en charge de Windows 8.1 ou Windows 10 dans le manifeste de votre application
n’aura aucun effet lors de l’exécution de votre application sur les systèmes d’exploitation précédents.
Le manifeste d’application ci-dessus comprend également une section < > trustInfo , qui spécifie la façon dont
le système doit le traiter en ce qui concerne le contrôle de compte d’utilisateur (UAC). L’ajout de trustInfo n’est
pas essentiel, mais il est vivement recommandé, même si votre application n’a pas besoin d’un comportement
spécifique au contrôle de compte d’utilisateur. en particulier, si vous n’ajoutez pas de trustInfo , les versions 32
bits x86 de votre application seront soumises à la virtualisation de fichiers UAC, ce qui permet aux écritures sur
des dossiers privilégiés par l’administrateur comme les dossiers système Windows de réussir quand ils
échouent, mais les redirige vers un dossier « VirtualStore » spécifique à l’utilisateur.
Rubriques connexes
OSVERSIONINFO
OSVERSIONINFOEX
Les éléments suivants sont utilisés avec les informations système :

System Information Types énumération
Les fonctions suivantes sont utilisées pour récupérer ou définir des informations système.
CeipIsOptedIn Vérifie si l’utilisateur a opté pour la collecte de données SQM

dans le cadre de l’Programme d’amélioration des services
(CEIP).
DnsHostnameToComputerName Convertit un nom DNS en un nom NetBIOS.
EnumSystemFirmwareTables Énumère toutes les tables du microprogramme du système

du type spécifié.
ExpandEnvironmentStrings Remplace les chaînes de variable d’environnement par leurs

valeurs définies.
GetComputerName Récupère le nom NetBIOS de l’ordinateur local.
GetComputerNameEx Récupère le nom NetBIOS ou DNS de l’ordinateur local.
GetComputerObjectName Récupère le nom de l’ordinateur local dans un format

spécifié.
GetCurrentHwProfile Récupère le profil matériel actuel de l’ordinateur local.
GetFirmwareEnvironmentVariable Récupère la valeur de la variable d’environnement de

microprogramme spécifiée à partir de NVRAM.
GetFirmwareEnvironmentVariableEx Récupère la valeur de la variable d’environnement de

microprogramme spécifiée et de ses attributs.
GetFirmwareType Récupère le type de microprogramme de l’ordinateur local.
GetIntegratedDisplaySize Récupère la meilleure estimation de la taille diagonale de

l’écran intégré, en pouces.
GetNativeSystemInfo Récupère des informations sur le système actuel pour une

application s’exécutant sous WOW64.
GetProductInfo Récupère le type de produit pour le système d’exploitation

sur l’ordinateur local et mappe le type aux types de produits
pris en charge par le système d’exploitation spécifié.
GetSystemDirector y Récupère le chemin d’accès du répertoire système.
GetSystemFirmwareTable Récupère la table du microprogramme spécifiée à partir du

fournisseur de la table du microprogramme.
GetSystemInfo Récupère des informations sur le système actuel.
GetSystemRegistr yQuota Récupère la taille actuelle du Registre et la taille maximale

que le Registre est autorisé à atteindre sur le système.
GetSystemWindowsDirector y récupère le chemin d’accès du répertoire de Windows

partagé sur un système multi-utilisateur.
GetSystemWow64Director y Récupère le chemin d’accès du répertoire système utilisé par

WOW64.
GetSystemWow64Director y2 Récupère le chemin d’accès du répertoire système utilisé par

WOW64, à l’aide du type d’ordinateur du fichier image
spécifié.
GetUserName Récupère le nom d’utilisateur du thread actuel.
GetUserNameEx Récupère le nom de l’utilisateur ou d’un autre principal de

sécurité associé au thread appelant. Vous pouvez spécifier le
format du nom retourné.
GetVersion Récupère le numéro de version du système d’exploitation

actuel.
Tourne Récupère des informations sur le système d’exploitation

actuel.
GetWindowsDirector y récupère le chemin d’accès du répertoire de Windows.
IsNativeVhdBoot Indique si le système d’exploitation a été démarré à partir

d’un conteneur de disque dur virtuel.
IsWow64GuestMachineSuppor ted
IsProcessorFeaturePresent Détermine si une fonctionnalité de processeur est prise en

charge par l’ordinateur actuel.
IsWow64Message Détermine si le dernier message lu à partir de la file d’attente

du processus actuel provient d’un processus WOW64.
IsWow64Process Détermine si un processus s’exécute sous WOW64.
Quer yPerformanceCounter Récupère la valeur actuelle du compteur de performance

haute résolution.
Quer yPerformanceFrequency Récupère la fréquence du compteur de performance haute

résolution.
RtlGetSuiteMask Récupère un masque de bits qui identifie les suites de

produits disponibles sur le système. Si cette fonction est
appelée dans une application qui s’exécute dans le contexte
d’un silo de serveurs, le masque de suite du silo de serveurs
est récupéré à la place.
SetComputerName Définit un nouveau nom NetBIOS pour l’ordinateur local.
SetComputerNameEx Définit un nouveau nom NetBIOS ou DNS pour l’ordinateur

local.
SetFirmwareEnvironmentVariable Définit la valeur de la variable d’environnement de

microprogramme spécifiée.
SetFirmwareEnvironmentVariableEx Définit la valeur de la variable d’environnement de

microprogramme spécifiée et de ses attributs.
TranslateName Convertit un nom d’objet de service d’annuaire d’un format

à un autre.
VerifyVersionInfo Compare un ensemble d’exigences de version aux valeurs du

système d’exploitation actuel.
VerSetConditionMask Génère le masque de condition pour la fonction

VerifyVersionInfo .
Wow64DisableWow64FsRedirection Désactive la redirection du système de fichiers pour le thread

appelant.
Wow64EnableWow64FsRedirection Active ou désactive la redirection du système de fichiers pour

le thread appelant.
Wow64Rever tWow64FsRedirection Restaure la redirection du système de fichiers pour le thread

appelant.
Fonctions obsolètes
NtQuer ySystemInformation
ZwQuer ySystemInformation
ApiSetQueryApiSetPresence fonction)
avant leur commercialisation. Microsoft ne donne aucune garantie, expresse ou implicite, concernant les
informations fournies ici.]
Cette API est réservée à un usage interne et ne doit pas être utilisée dans votre code.
Syntaxe
BOOL WINAPI ApiSetQueryApiSetPresence(
_In_ PCUNICODE_STRING Namespace,
_Out_ PBOOLEAN Present
);
Paramètres
Espace de noms [ dans]
Présent [ à]
Configuration requise
C O N DIT IO N REQ UISE VA L EUR
Client minimal pris en charge Applications de [ Bureau Windows 10 uniquement]
Serveur minimal pris en charge Applications de bureau Windows Server 2016 [ uniquement]
En-tête
Apiquery. h
Bibliothèque
API-MS-Win-Core-apiquery-L1. lib ;
API-MS-Win-Core-apiquery-L1-1 1/-0. lib
DLL
Api-ms-win-core-apiquery-l1-1-0.dll
RtlGetSuiteMask fonction)
avant leur commercialisation. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations
fournies ici.]
Récupère un masque de bits qui identifie les suites de produits disponibles sur le système. Si cette fonction est
appelée dans une application qui s’exécute dans le contexte d’un silo de serveurs, le masque de suite du silo de
serveurs est récupéré à la place.
Syntaxe
ULONG NTAPI RtlGetSuiteMask(void);
Paramètres
Cette fonction n’a pas de paramètres.
Valeur retournée
Masque de bits qui identifie les suites de produits disponibles sur le système. Le masque de bits peut inclure les
valeurs suivantes.
VA L EUR RETO URN ÉE DESC RIP T IO N
Microsoft Small Business Server a été installé sur le système,

0x00000001 mais il a peut-être été mis à niveau vers une autre version de
Windows. Reportez-vous à la section Remarques pour plus
d’informations sur cet indicateur de bit.
Windows 10 Entreprise, Windows 8.1 Entreprise, Windows

0x00000002 server 2008 Enterprise, Windows server 2003, Êdition
Entreprise ou Windows 2000 Advanced Server est installé.
Reportez-vous à la section Remarques pour plus
d’informations sur cet indicateur de bit.
Les composants Microsoft BackOffice sont installés.

0x00000004
Communications Server 2003, Communications Server

0x00000008 2005, Communications Server 2007 ou Communications
Server 2007 R2 sont installés.
Les services Terminal Server sont installés. Cette valeur est

0x00000010 toujours définie.
Si TerminalSer ver est défini mais que SingleUserTS n’est
pas défini, le système s’exécute en mode serveur
d’applications.
VA L EUR RETO URN ÉE DESC RIP T IO N
Microsoft Small Business Server est installé avec la licence

0x00000020 client restrictive en vigueur. Reportez-vous à la section
Remarques pour plus d’informations sur cet indicateur de bit.
Windows XP Embedded est installé.

0x00000040
Windows le serveur 2008 datacenter, Windows server 2003,

0x00000080 datacenter Edition ou Windows 2000 datacenter server est
installé.
Bureau à distance est pris en charge, mais une seule session

0x00000100 interactive est prise en charge. Cette valeur est définie, sauf
si le système s’exécute en mode serveur d’applications.
Windows vista édition familial Premium, Windows Vista

0x00000200 édition familial Basic ou Windows XP édition personnelle est
installé.
Windows Server 2003, Web Edition est installé.

0x00000400
Windows Stockage server 2003 R2 ou Windows Stockage

0x00002000 server 2003 est installé.
Windows Le serveur 2003, Compute Cluster Edition est

0x00004000 installé.
Windows Le serveur d’hébergement est installé.

0x00008000
Remarques
Vous ne devez pas compter uniquement sur l’indicateur 0x00000001 pour déterminer si Small Business Server
a été installé sur le système, car cet indicateur et l’indicateur 0x00000020 sont définis lors de l’installation de
cette suite de produits. si vous mettez à niveau cette installation vers Windows serveur, Édition Standard,
l’indicateur 0x00000020 sera désactivé, mais l’indicateur 0x00000001 restera défini. Dans ce cas, cela indique
que Small Business Server a été installé sur ce système. si cette installation est encore mise à niveau vers
Windows Server, Êdition Entreprise, l’indicateur 0x00000001 restera défini.
Client minimal pris en charge Windows 10 [ applications de bureau uniquement]
Serveur minimal pris en charge Windows Server 2016 [ applications de bureau uniquement]
En-tête
Ntddk. h
Bibliothèque
Ntdll. lib
DLL
Ntdll.dll
Les fonctions suivantes peuvent être utilisées pour déterminer la version actuelle du système d’exploitation ou
pour déterminer s’il s’agit d’une version Windows ou Windows Server. Ces fonctions fournissent des tests
simples qui utilisent la fonction VerifyVersionInfo et les comparaisons plus ou moins recommandées qui sont
prouvées comme un moyen fiable de déterminer la version du système d’exploitation.
NOTE
Ces API sont définies par versionhelpers. h , qui est inclus dans le kit de développement logiciel (SDK) Windows 8.1. Ce
fichier peut être utilisé avec d’autres versions de Microsoft Visual Studio pour implémenter les mêmes fonctionnalités pour
les versions de Windows antérieures à Windows 8.1.
IsWindowsXPOrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows XP, ou est supérieure à
celle-ci.
IsWindowsXPSP1OrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows XP avec Service Pack 1
(SP1), ou est supérieure à celle-ci.


IsWindowsVistaOrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows Vista ou est supérieure
à celle-ci.
IsWindowsVistaSP1OrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows Vista avec Service Pack
1 (SP1), ou est supérieure à celle-ci.
IsWindowsVistaSP2OrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows Vista avec Service Pack
2 (SP2) ou est supérieure à celle-ci.
IsWindows7OrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows 7, ou est supérieure à
celle-ci.
IsWindows7SP1OrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows 7 avec Service Pack 1

correspond à la version Windows 8, ou est supérieure à
celle-ci.
IsWindows8Point1OrGreater Indique si la version actuelle du système d’exploitation

correspond à la version de Windows 8.1, ou est supérieure à
celle-ci.
Pour Windows 10, IsWindows8Point1OrGreater retourne
la valeur false, sauf si l’application contient un manifeste qui
inclut une section de compatibilité qui contient les GUID qui
désignent Windows 8.1 et/ou Windows 10.

correspond à la version Windows 10, ou est supérieure à
celle-ci.
Pour Windows 10, IsWindows10OrGreater retourne la
valeur false, sauf si l’application contient un manifeste qui
inclut une section de compatibilité qui contient le GUID qui
désigne Windows 10.
IsWindowsSer ver Indique si le système d’exploitation actuel est une version de

Windows Server. Les applications qui doivent faire la
distinction entre les versions client et serveur de Windows
doivent appeler cette fonction.
IsWindowsVersionOrGreater
Vous ne devez utiliser cette fonction que si les autres
fonctions d’assistance de version fournies ne
correspondent pas à votre scénario.
Indique si la version actuelle du système d’exploitation

correspond à, ou est supérieur à, aux informations de
version fournies. Cette fonction est utile pour confirmer une
version de Windows Server qui ne partage pas de numéro
de version avec une version client.
Exemple
Les fonctions inline définies dans le fichier d’en-tête VersionHelpers. h vous permettent de vérifier la version
du système d’exploitation en retournant une valeur booléenne lors du test d’une version de Windows.
Par exemple, si votre application nécessite Windows 8 ou version ultérieure, utilisez le test suivant.
#include <VersionHelpers.h>
if (!IsWindows8OrGreater())
{
MessageBox(NULL, "You need at least Windows 8", "Version Not Supported", MB_OK);
}
Rubriques connexes
OSVERSIONINFOEX
ZwQuerySystemInformation fonction)
[ZwQuer ySystemInformation n’est plus disponible pour une utilisation à partir de Windows 8. Utilisez plutôt
les autres fonctions indiquées dans cette rubrique.]
Récupère les informations système spécifiées.
Syntaxe
NTSTATUS WINAPI ZwQuerySystemInformation(
_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
_Inout_ PVOID SystemInformation,
_In_ ULONG SystemInformationLength,
_Out_opt_ PULONG ReturnLength
);
Paramètres
SystemInformationClass [ dans]
Type d’informations système à récupérer. Ce paramètre peut avoir l’une des valeurs suivantes du type
d’énumération de _ _ classe d’informations système .
SystemBasicInformation
Nombre de processeurs dans le système dans une structure d' _ _ information de base du système . Utilisez
à la place la fonction GetSystemInfo .
SystemPerformanceInformation
Structure d' _ _ informations sur les performances du système opaque qui peut être utilisée pour générer
une valeur de départ imprévisible pour un générateur de nombres aléatoires. Utilisez à la place la fonction
Cr yptGenRandom .
SystemTimeOfDayInformation
Structure d' _ _ informations TimeOfDay du système opaque qui peut être utilisée pour générer une valeur
de départ imprévisible pour un générateur de nombres aléatoires. Utilisez à la place la fonction
Cr yptGenRandom .
SystemProcessInformation
Tableau de structures d' _ _ informations de processus système , un pour chaque processus s’exécutant
dans le système.
Ces structures contiennent des informations sur l’utilisation des ressources de chaque processus, y compris le
nombre de handles utilisés par le processus, l’utilisation du fichier de page de pic et le nombre de pages de
mémoire allouées par le processus.
SystemProcessorPerformanceInformation
Tableau des structures d' _ _ _ informations sur les performances du processeur système , une pour
chaque processeur installé dans le système.
SystemInterruptInformation
Structure d' _ _ informations d’interruption système opaque qui peut être utilisée pour générer une valeur
de départ imprévisible pour un générateur de nombres aléatoires. Utilisez à la place la fonction
Cr yptGenRandom .
SystemExceptionInformation
Structure d' _ _ informations d’exception système opaque qui peut être utilisée pour générer une valeur de
départ imprévisible pour un générateur de nombres aléatoires. Utilisez à la place la fonction
Cr yptGenRandom .
SystemRegistr yQuotaInformation
Structure d' _ _ _ informations de quota du Registre système .
SystemLookasideInformation
Structure d' _ _ information de système non opaque qui peut être utilisée pour générer une valeur de départ
imprévisible pour un générateur de nombres aléatoires. Utilisez à la place la fonction Cr yptGenRandom .
SystemInformation [ in, out]
Pointeur vers une mémoire tampon qui reçoit les informations demandées. La taille et la structure de ces
informations varient en fonction de la valeur du paramètre SystemInformationClass , comme indiqué dans le
tableau suivant.
_informations de base sur le système _

Lorsque le paramètre SystemInformationClass est SystemBasicInformation , la mémoire tampon vers laquelle
pointe le paramètre SystemInformation doit être suffisamment grande pour contenir une structure d' _ _
information de base du système unique ayant la disposition suivante :
typedef struct _SYSTEM_BASIC_INFORMATION {

BYTE Reserved1[24];
PVOID Reserved2[4];
CCHAR NumberOfProcessors;
} SYSTEM_BASIC_INFORMATION;
Le membre NumberOfProcessors contient le nombre de processeurs présents dans le système. Utilisez

GetSystemInfo à la place pour récupérer ces informations.
Les autres membres de la structure sont réservés à un usage interne par le système d’exploitation.
_informations sur les performances du système _

Lorsque le paramètre SystemInformationClass est SystemPerformanceInformation , la mémoire tampon vers
laquelle pointe le paramètre SystemInformation doit être suffisamment grande pour contenir une structure d' _
_ informations de performances système opaque à utiliser pour générer une valeur de départ imprévisible
pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :
typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
BYTE Reserved1[312];
} SYSTEM_PERFORMANCE_INFORMATION;
Les membres individuels de la structure sont réservés à un usage interne par le système d’exploitation.
Utilisez plutôt la fonction Cr yptGenRandom pour générer des données aléatoires du point de vue du
chiffrement.
_informations sur la TimeOfDay du système _

Lorsque le paramètre SystemInformationClass est SystemTimeOfDayInformation , la mémoire tampon vers
_ informations TimeOfDay du système opaque à utiliser pour générer une valeur de départ imprévisible
pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :
typedef struct _SYSTEM_TIMEOFDAY_INFORMATION {

BYTE Reserved1[48];
} SYSTEM_TIMEOFDAY_INFORMATION;
chiffrement.
_informations sur le processus système _

Lorsque le paramètre SystemInformationClass est SystemProcessInformation , la mémoire tampon vers
laquelle pointe le paramètre SystemInformation doit être suffisamment grande pour contenir un tableau qui
contient autant de structures d' _ _ informations sur le processus système qu’il y a de processus en cours
d’exécution dans le système. Chaque structure a la disposition suivante :
typedef struct _SYSTEM_PROCESS_INFORMATION {

ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
PVOID Reserved2[3];
HANDLE UniqueProcessId;
PVOID Reserved3;
ULONG HandleCount;
BYTE Reserved4[4];
PVOID Reserved5[11];
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved6[6];
} SYSTEM_PROCESS_INFORMATION;
Le membre NumberOfThreads contient le nombre total de threads en cours d’exécution dans le processus.
Le membre HandleCount contient le nombre total de handles utilisés par le processus en question ; Utilisez
GetProcessHandleCount pour récupérer ces informations à la place.
Le membre PeakPagefileUsage contient le nombre maximal d’octets du stockage de fichiers de pages utilisé
par le processus, et le membre PrivatePageCount contient le nombre de pages mémoire allouées pour
l’utilisation de ce processus.
Vous pouvez également récupérer ces informations à l’aide de la fonction GetProcessMemor yInfo ou de la
classe de _ processus Win32 .
Les autres membres de la structure sont réservés à un usage interne par le système d’exploitation.
_ _ informations sur les performances du processeur système _

Lorsque le paramètre SystemInformationClass est SystemProcessorPerformanceInformation , la mémoire
tampon vers laquelle pointe le paramètre SystemInformation doit être suffisamment grande pour contenir un
tableau qui contient autant de structures d' _ _ informations sur le processus système qu’il y a de
processeurs (UC) installés dans le système. Chaque structure a la disposition suivante :
typedef struct
_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
LARGE_INTEGER IdleTime;
LARGE_INTEGER KernelTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER Reserved1[2];
ULONG Reserved2;
} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
Le membre IdleTime contient la durée pendant laquelle le système est inactif, en 1/centièmes de nanoseconde.
Le membre KernelTime contient la durée d’exécution du système en mode noyau (y compris tous les threads
de tous les processus, sur tous les processeurs), en 1/centièmes de nanosecondes.
Le membre UserTime contient la durée d’exécution du système en mode utilisateur (y compris tous les threads
de tous les processus, sur tous les processeurs), en 1/centièmes de nanosecondes.
Utilisez GetSystemTimes à la place pour récupérer ces informations.
_informations sur les interruptions système _

Lorsque le paramètre SystemInformationClass est SystemInterruptInformation , la mémoire tampon vers
laquelle pointe le paramètre SystemInformation doit être suffisamment grande pour contenir un tableau qui
contient autant de structures d' _ _ informations d’interruptions système opaques qu’il n’y a de
processeurs (UC) installés sur le système. Chaque structure, ou le tableau dans son ensemble, peut être utilisée
pour générer une valeur de départ imprévisible pour un générateur de nombres aléatoires. À cet effet, la
structure a la disposition suivante :
typedef struct _SYSTEM_INTERRUPT_INFORMATION {

BYTE Reserved1[24];
} SYSTEM_INTERRUPT_INFORMATION;
chiffrement.
_informations sur l’exception système _

Lorsque le paramètre SystemInformationClass est SystemExceptionInformation , la mémoire tampon vers
_ informations d’exception système opaque à utiliser pour générer une valeur de départ imprévisible pour
un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :
typedef struct _SYSTEM_EXCEPTION_INFORMATION {
BYTE Reserved1[16];
} SYSTEM_EXCEPTION_INFORMATION;
chiffrement.
_ _ informations sur les quotas du Registre système _

Lorsque le paramètre SystemInformationClass est SystemRegistr yQuotaInformation , la mémoire tampon
vers laquelle pointe le paramètre SystemInformation doit être suffisamment grande pour contenir une structure
d' _ _ _ informations de quota du Registre du système unique ayant la disposition suivante :
typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION {

ULONG RegistryQuotaAllowed;
ULONG RegistryQuotaUsed;
PVOID Reserved1;
} SYSTEM_REGISTRY_QUOTA_INFORMATION;
Le membre Registr yQuotaAllowed contient la taille maximale, en octets, que le registre peut atteindre sur ce
système.
Le membre Registr yQuotaUsed contient la taille actuelle du Registre, en octets.
Utilisez GetSystemRegistr yQuota à la place pour récupérer ces informations.
L’autre membre de la structure est réservé à un usage interne par le système d’exploitation.
_informations système _
Lorsque le paramètre SystemInformationClass est SystemLookasideInformation , la mémoire tampon vers
_ informations de système insuffisante pour une utilisation lors de la génération d’une valeur de départ
imprévisible pour un générateur de nombres aléatoires. À cet effet, la structure a la disposition suivante :
typedef struct _SYSTEM_LOOKASIDE_INFORMATION {

BYTE Reserved1[32];
} SYSTEM_LOOKASIDE_INFORMATION;
chiffrement.
SystemInformationLength [ dans]
Taille de la mémoire tampon vers laquelle pointe le paramètre SystemInformation , en octets.
ReturnLength [ out, facultatif]
Pointeur facultatif vers un emplacement où la fonction écrit la taille réelle des informations demandées. Si cette
taille est inférieure ou égale au paramètre SystemInformationLength , la fonction copie les informations dans la
mémoire tampon SystemInformation ; Sinon, elle retourne un code d’erreur NTSTATUS et retourne dans
ReturnLength la taille de la mémoire tampon requise pour recevoir les informations demandées.
Valeur retournée
Retourne un code d’erreur ou de réussite NTSTATUS.
Les formulaires et la signification des codes d’erreur de NTSTATUS sont répertoriés dans le fichier d’en-tête
Ntstatus. h disponible dans le DDK et sont décrits dans la documentation du DDK.
Notes
La fonction ZwQuer ySystemInformation et les structures qu’elle retourne sont internes au système
d’exploitation et peuvent être modifiées d’une version de Windows à une autre. Pour maintenir la compatibilité
de votre application, il est préférable d’utiliser les autres fonctions mentionnées précédemment.
Si vous utilisez ZwQuer ySystemInformation , accédez à la fonction via la liaison dynamique au moment de
l’exécution. Cela donne à votre code la possibilité de répondre correctement si la fonction a été modifiée ou
supprimée du système d’exploitation. Toutefois, les modifications de signature peuvent ne pas être détectables.
Cette fonction n’a pas de bibliothèque d’importation associée. Vous devez utiliser les fonctions LoadLibrar y et
GetProcAddress pour établir une liaison dynamique à Ntdll.dll.
DLL
Ntdll.dll
Voir aussi
GetSystemInfo
GetProcessHandleCount
GetProcessMemor yInfo
GetSystemTimes
GetSystemRegistr yQuota
Les structures suivantes sont utilisées pour récupérer ou définir des informations système.
_informations sur le profil matériel _
OSVERSIONINFO
OSVERSIONINFOEX
_informations système
La macro suivante est utilisée pour récupérer ou définir des informations système.
_condition Set de ver _
Types d’énumération des informations système
Les types d’énumération suivants sont utilisés pour récupérer ou définir des informations système.
_format du nom de l’ordinateur _
_format de nom étendu _
TYPE de microprogramme _
_ordinateur de fichier image _
Décrit les architectures d’ordinateur possibles. Utilisé dans GetSystemWow64Director y2 ,

IsWow64GuestMachineSuppor ted et IsWow64Process2 .
_ordinateur de fichier image _ _ inconnu
0
Unknown
IMAGE de l' _ _ ordinateur _ _ hôte cible de l’ordinateur
0x0001
Interagit avec l’hôte et non un invité WOW64
NOTE
Cette constante est disponible à partir de Windows 10, version 1607 et Windows Server 2016.
_Fichier image _ ordinateur _ i386

0x014c
Intel 386
_Ordinateur de fichier image _ _ R3000
0x0162
Big endian de MIPS, 0x160 Big-endian
0x0166
Big-endian MIPS
0x0168
Big-endian MIPS
_Ordinateur de fichier image _ _ WCEMIPSV2
0x0169
MIPS Little-endian WCE v2
_ordinateur de fichier image _ _ alpha
0x0184
Alpha _ AXP
_Ordinateur du fichier image _ _ SH3
0x01a2
SH3 Little-endian
_Ordinateur de fichier image _ _ SH3DSP
0x01a3
SH3DSP
_Ordinateur de fichier image _ _ SH3E
0x01a4
SH3E Little-endian
_Machine fichier _ image _ sh4
0x01a6
SH4 Little-endian
_Ordinateur de fichier image _ _ SH5
0x01a8
SH5
fichier IMAGE bras de l' _ _ ordinateur _
0x01c0
Little-Endian ARM
curseur de l' _ ordinateur du fichier image _ _
0x01c2
Little-Endian ARM/Thumb-2
_ordinateur de fichier image _ _ ARMNT
0x01c4
ARM Thumb-2 Little-Endian
NOTE
Cette constante est disponible à partir de Windows 7 et de Windows Server 2008 R2.
_Ordinateur de fichier image _ _ AM33

0x01d3
TAM33BD
_fichier image _ ordinateur _ powerpc
0x01F0
Little-Endian IBM PowerPC
_ordinateur de fichier image _ _ POWERPCFP
0x01f1
POWERPCFP
_Machine de fichier image _ _ ia64
0x0200
Intel 64
_Ordinateur de fichier image _ _ MIPS16
0x0266
MIPS
_Ordinateur de fichier image _ _ ALPHA64
0x0284
ALPHA64
_ordinateur de fichier image _ _ MIPSFPU
0x0366
MIPS
_Ordinateur de fichier image _ _ MIPSFPU16
0x0466
MIPS
_Ordinateur de fichier image _ _ AXP64
0x0284
AXP64
_ordinateur de fichier image _ _ TriCore
0x0520
Infineon
_ordinateur de fichier image _ _ CEF
0x0CEF
CEF
_fichier d' _ image _ EBC machine
0x0EBC
Code d’octet EFI
_Machine de fichier image _ _ amd64
0x8664
AMD64 (K8)
_Ordinateur de fichier image _ _ m32r
0x9041
M32R Little-endian
_Ordinateur de fichier image _ _ ARM64
0xAA64
ARM64 Little-Endian
NOTE
Cette constante est disponible à partir de Windows 8.1 et de Windows Server 2012 R2.
_machine de fichier image _ _ CEE

0xC0EE
CEE
Client minimal pris en charge Applications de [ Bureau Windows XP uniquement]
Serveur minimal pris en charge Windows 2000 Server - [Applications de bureau

uniquement]
En-tête
Winnt. h
Temps
Les fonctions de date et d’heure récupèrent et définissent la date et l’heure du système et des fichiers
individuels. Cette vue d’ensemble explique comment utiliser ces fonctions pour examiner et modifier les dates et
les heures.
À propos du temps
À propos du temps
Les fonctions relatives à l’heure retournent du temps dans l’un des nombreux formats. Vous pouvez utiliser les
fonctions d’heure pour effectuer une conversion entre des formats d’heure pour faciliter la comparaison et
l’affichage. Le tableau suivant récapitule les formats d’heure.
F O RM AT TYPE DESC RIP T IO N
Système SYSTEMTIME Année, mois, jour, heure, seconde et

milliseconde, pris de l’horloge
matérielle interne.
Local SystemTime ou fileTime Heure système ou heure du fichier

convertie dans le fuseau horaire local
du système.
Fichier FILETIME Nombre d’intervalles de 100

nanosecondes depuis le 1er janvier
1601.
MS-DOS WORD Mot condensé pour la date, un autre

pour le moment.
Windows DWORD ou ULONGLONG Nombre de millisecondes écoulées

depuis le dernier démarrage du
système. en cas de récupération en
tant que valeur DWORD, Windows
cycles de temps tous les 49,7 jours.
Nombre d’interruptions ULONGLONG Nombre d’intervalles de 100

nanosecondes depuis le dernier
démarrage du système.
Pour plus d'informations, voir les rubriques suivantes :

Temps système
Heure locale
Heures du fichier
Horloge Windows
Temps système
L' heure système correspond à la date et à l’heure actuelles de la journée. Le système conserve le temps
nécessaire pour que vos applications soient en mesure d’accéder à un délai précis. Le système base l’heure
système sur le temps universel coordonné (UTC). L’heure UTC est faiblement définie comme la date et l’heure
actuelles de Greenwich, Angleterre.
Lorsque le système démarre pour la première fois, il définit l’heure système sur une valeur en fonction de
l’horloge en temps réel de l’ordinateur, puis met régulièrement à jour l’heure. Pour récupérer l’heure système,
utilisez la fonction GetSystemTime . GetSystemTime copie l’heure dans une structure SystemTime qui
contient des membres individuels pour le mois, le jour, l’année, le jour de la semaine, l’heure, les minutes, les
secondes et les millisecondes. Il est facile d’afficher ce format à un utilisateur.
Vous pouvez également obtenir l’heure système au format d’heure de fichier à l’aide de la fonction
GetSystemTimeAsFileTime . GetSystemTimeAsFileTime copie l’heure dans une structure fileTime .
Pour définir l’heure système, utilisez la fonction setsystemtime . Setsystemtime suppose que vous avez
spécifié une heure UTC.
Les fonctions GetSystemTimeAdjustment et SetSystemTimeAdjustment synchronisent l’horloge de
l’heure avec une autre source de temps à l’aide d’un ajustement de temps périodique appliqué à chaque
interruption de l’horloge.
Notez que le système peut actualiser régulièrement l’heure en synchronisant avec une source de temps. Étant
donné que l’heure système peut être ajustée vers l’avant ou vers l’arrière, ne comparez pas les lectures
temporelles système pour déterminer le temps écoulé. Au lieu de cela, utilisez l’une des méthodes décrites dans
le temps Windows.
Heure locale
Si le système utilise l’heure UTC en interne, vos applications affichent généralement l' heure locale , qui
correspond à la date et à l’heure de votre fuseau horaire. Par conséquent, pour garantir des résultats corrects,
vous devez savoir si une fonction s’attend à recevoir une heure UTC ou une heure locale, et si la fonction
retourne une heure UTC ou une heure locale.
Les paramètres de fuseau horaire actuels contrôlent la façon dont le système convertit l’heure UTC et l’heure
locale. Vous pouvez récupérer les paramètres de fuseau horaire en cours à l’aide de la fonction
GetTimeZoneInformation . La fonction copie le résultat dans une structure d' _ _ informations de fuseau
horaire et retourne une valeur indiquant si l’heure locale est actuellement en heure d’hiver ou d’heure d’été
(DST). Vous pouvez définir les paramètres de fuseau horaire à l’aide de la fonction SetTimeZoneInformation .
Pour prendre en charge les limites de l’heure d’été qui changent d’une année à l’autre, utilisez les fonctions
GetTimeZoneInformationForYear , GetDynamicTimeZoneInformation et
SetDynamicTimeZoneInformation .
Pour récupérer l’heure locale, utilisez la fonction GetLocalTime . GetLocalTime convertit l’heure système en
heure locale en fonction des paramètres de fuseau horaire en cours et copie le résultat dans une structure
SystemTime . Vous pouvez définir l’heure système à l’aide de la fonction SetLocalTime . SetLocalTime
suppose que vous avez spécifié une heure locale et convertit en heure UTC avant de définir l’heure système.
Quand vous appelez SetLocalTime , le système utilise les informations de fuseau horaire actuelles, y compris le
paramètre d’heure d’été, pour effectuer la conversion. Notez que le système utilise le paramètre d’heure d’été
de l’heure actuelle, et non la nouvelle heure que vous définissez. Par conséquent, pour garantir le résultat
correct, appelez SetLocalTime une deuxième fois, maintenant que le premier appel a mis à jour le paramètre
d’heure d’été.
Pour convertir une heure UTC en heure locale, utilisez la fonction SystemTimeToTzSpecificLocalTime . Pour
convertir une heure locale en heure UTC, utilisez la fonction TzSpecificLocalTimeToSystemTime .
Heures du fichier
Une heure de fichier est une valeur 64 bits qui représente le nombre d’intervalles de 100 nanosecondes qui se
sont écoulés depuis 12:00 h 00. Le 1er janvier 1601 temps universel coordonné (UTC). Le système enregistre les
heures de fichier lorsque les applications créent, accèdent et écrivent dans des fichiers.
Le système de fichiers NTFS stocke les valeurs d’heure au format UTC. elles ne sont donc pas affectées par les
modifications apportées au fuseau horaire ou à l’heure d’été. Le système de fichiers FAT stocke les valeurs
d’heure en fonction de l’heure locale de l’ordinateur. Par exemple, un fichier enregistré à l’adresse 3:14:00 PST à
Washington s’affiche sous la forme 6:14:00 est à New York sur un volume NTFS, mais il est considéré comme
3:14:00 est à New York sur un volume FAT.
Les horodatages sont mis à jour à différents moments et pour diverses raisons. La seule garantie concernant un
horodatage de fichier est que l’heure du fichier est correctement reflétée lorsque le handle qui rend la
modification est fermé.
Tous les systèmes de fichiers ne peuvent pas enregistrer les heures de création et de dernier accès, et tous les
systèmes de fichiers ne les enregistrent pas de la même manière. Par exemple, la résolution de l’heure de
création sur la FAT est de 10 millisecondes, tandis que le temps d’écriture a une résolution de 2 secondes et le
temps d’accès a une résolution de 1 jour. il s’agit donc vraiment de la date d’accès. Le système de fichiers NTFS
retarde les mises à jour de l’heure du dernier accès pour un fichier jusqu’à 1 heure après le dernier accès.
Pour récupérer l’heure du fichier d’un fichier spécifié, utilisez la fonction GetFileTime . GetFileTime copie les
heures de création, de dernier accès et de dernière écriture dans les structures fileTime individuelles. Vous
pouvez également récupérer des heures de fichier à l’aide des fonctions FindFirstFile et FindNextFile . Ces
fonctions copient les heures de fichier dans les structures fileTime dans une structure de _ _ données de
recherche Win32 . Lors de l’écriture dans un fichier, l’heure de la dernière écriture n’est pas entièrement mise à
jour jusqu’à ce que tous les handles utilisés pour l’écriture soient fermés.
Pour définir l’heure d’un fichier, utilisez la fonction SetFileTime . Cette fonction vous permet de modifier les
heures de création, de dernier accès et de dernière écriture sans modifier le contenu du fichier. Vous pouvez
comparer les heures des différents fichiers à l’aide de la fonction CompareFileTime . La fonction compare deux
heures de fichier et retourne une valeur qui indique l’heure ultérieure ou retourne 0 (zéro) si les heures sont
égales.
Si vous envisagez de modifier les heures de fichier des fichiers spécifiés, vous pouvez convertir une date et une
heure en une heure de fichier à l’aide de la fonction SystemTimeToFileTime . Vous pouvez également obtenir
l’heure système dans une structure fileTime en appelant la fonction GetSystemTimeAsFileTime .
Pour faciliter l’affichage de l’heure d’un fichier pour un utilisateur, utilisez la fonction FileTimeToSystemTime .
FileTimeToSystemTime convertit l’heure du fichier et copie le mois, le jour, l’année et l’heure du jour à partir
de l’heure du fichier vers une structure SystemTime .
Heures du fichier et heure de l’heure d’été

Vous devez être prudent lorsque vous utilisez des heures de fichier si l’utilisateur a défini le système pour qu’il
s’ajuste automatiquement à l’heure d’été.
Pour convertir une heure de fichier en heure locale, utilisez la fonction FileTimeToLocalFileTime . Toutefois,
FileTimeToLocalFileTime utilise les paramètres actuels pour le fuseau horaire et l’heure d’été. Par conséquent,
s’il s’agit de l’heure d’été, il prend en compte l’heure d’été, même si l’heure du fichier que vous convertissez est
en heure d’hiver.
Le système de fichiers FAT enregistre les temps sur le disque en heure locale. GetFileTime récupère les heures
UTC mises en cache à partir du système de fichiers FAT. Lorsqu’il s’agit de l’heure d’été, le temps récupéré par
GetFileTime est en retard d’une heure, car le cache n’est pas mis à jour. Lorsque vous redémarrez l’ordinateur,
la durée de mise en cache que GetFileTime récupère est correcte. FindFirstFile récupère l’heure locale à partir
du système de fichiers FAT et la convertit en heure UTC en utilisant les paramètres actuels pour le fuseau horaire
et l’heure d’été. Par conséquent, s’il s’agit de l’heure d’été, FindFirstFile prend en compte l’heure d’été, même si
l’heure du fichier que vous convertissez est en heure d’hiver.
Le système de fichiers NTFS enregistre les temps sur le disque au format UTC. Pour tenir compte de l’heure d’été
lors de la conversion d’une heure de fichier en heure locale, utilisez la séquence de fonctions suivante au lieu
d’utiliser FileTimeToLocalFileTime :
SystemTimeToFileTime
Heures du fichier et CDFS

Les horodatages des fichiers qui se trouvent sur le support ou proviennent d’un média à l’aide du système CDFS
(Compact Disc File System) sont ajustés pour le fuseau horaire local. ISO 9660 déclare que CDFS doit afficher les
informations de date correctement pour le fuseau horaire local. Cela a pour effet que les dates des fichiers sur
CDFS sont affichées de la même façon que sur le format de disque universel (UDF). UDF est la norme la plus
récente pour le support de distribution. Si votre code dépend des informations de date non modifiées pour un
fichier qui réside sur ou provient d’un média à l’aide de CDFS, il peut ne pas fonctionner correctement.
La Date et l' heure ms-dos sont des valeurs compactes 16 bits qui spécifient le mois, le jour, l’année et l’heure
de la dernière écriture dans un fichier MS-DOS. MS-DOS enregistre la date et l’heure à chaque fois qu’une
application MS-DOS crée ou écrit dans un fichier. Les applications MS-DOS récupèrent cette date et cette heure
à l’aide des fonctions MS-DOS. Lorsque vous utilisez la fonction GetFileTime pour récupérer les heures de
fichier des fichiers qui ont été créés par MS-DOS, GetFileTime convertit automatiquement les dates et heures
ms-dos en heures UTC.
Si vous rencontrez une date et une heure MS-DOS qui n’ont pas été converties, vous pouvez les convertir en
heure UTC à l’aide de la fonction DosDateTimeToFileTime . Cette fonction copie la date et l’heure converties
dans une structure fileTime . Vous pouvez reconvertir la valeur en date et heure MS-DOS à l’aide de la fonction
FileTimeToDosDateTime .
Horloge Windows
Windows temps est le nombre de millisecondes écoulées depuis le dernier démarrage du système. Ce format
existe principalement pour la compatibilité descendante avec la Windows 16 bits. pour vous assurer que les
applications conçues pour une Windows de 16 bits continuent de fonctionner correctement, la fonction
GetTickCount retourne l’heure de Windows actuelle.
en général, vous utilisez la fonction GetTickCount ou GetTickCount64 pour comparer l’heure actuelle
Windows à l’heure retournée par la fonction GetMessageTime . GetMessageTime retourne l’heure de
Windows de la création du message spécifié. GetTickCount et GetTickCount64 sont limités à la résolution de
la minuterie du système, qui est d’environ 10 millisecondes à 16 millisecondes. Le temps écoulé récupéré par
GetTickCount ou GetTickCount64 comprend le temps que le système passe en mode veille ou veille
prolongée.
Si vous avez besoin d’un minuteur de résolution plus élevée, utilisez la fonction
Quer yUnbiasedInterruptTime , un minuteur multimédiaou un minuteur haute résolution. Le temps écoulé
récupéré par la fonction Quer yUnbiasedInterruptTime comprend uniquement l’heure à laquelle le système
passe à l’état de travail.
Windows ser ver 2008, Windows Vista, Windows ser ver 2003 et Windows XP/2000 : la fonction
Quer yUnbiasedInterruptTime est disponible à partir de Windows 7 et Windows Server 2008 R2.
Vous pouvez utiliser le compteur de performances temps système du système pour obtenir le nombre de
secondes écoulées depuis le démarrage de l’ordinateur. Ce compteur de performance peut être récupéré à partir
des données de performances de la clé de Registre HKEY _ performance _ Data . La valeur retournée est une
valeur de 8 octets. Pour plus d’informations, consultez Compteurs de performances.
Le temps d’interruption correspond à la durée écoulée depuis le dernier démarrage du système, en intervalles
de 100 nanosecondes. Le nombre de temps d’interruptions commence à zéro lorsque le système démarre et est
incrémenté à chaque interruption d’horloge par la longueur d’un cycle d’horloge. La longueur exacte d’un cycle
d’horloge dépend du matériel sous-jacent et peut varier entre les systèmes.
Contrairement à l' heure système, le nombre d’interruptions n’est pas soumis aux ajustements des utilisateurs
ou du service de temps Windows, ce qui en fait un meilleur choix pour mesurer les durées courtes. Les
applications qui requièrent une plus grande précision que le nombre d’interruptions doivent utiliser un
minuteur de haute résolution. Utilisez la fonction Quer yPerformanceFrequency pour récupérer la fréquence
de la minuterie haute résolution et la fonction Quer yPerformanceCounter pour récupérer la valeur du
compteur.
Les fonctions Quer yInterruptTime , Quer yInterruptTimePrecise , Quer yUnbiasedInterruptTime et
Quer yUnbiasedInterruptTimePrecise peuvent être utilisées pour récupérer le nombre d’interruptions.
L’interruption non biaisée signifie que seul le moment où le système est en état de fonctionnement est compté.
par conséquent, le nombre de temps d’interruption n’est pas « biaisé » au moment où le système passe en mode
veille ou veille prolongée.
Windows ser ver 2008, Windows Vista, Windows ser ver 2003 et Windows XP/2000 : La fonction
Quer yUnbiasedInterruptTime est disponible à partir de Windows 7 et de windows Server 2008 R2.
La résolution de l’horloge définie par les fonctions timeBeginPeriod et timeEndPeriod affecte la résolution
des fonctions Quer yInterruptTime et Quer yUnbiasedInterruptTime . Toutefois, l’augmentation de la
résolution de la minuterie n’est pas recommandée, car elle peut réduire les performances globales du système et
augmenter la consommation d’énergie en empêchant le processeur de pénétrer dans des États d’économie
d’énergie. Au lieu de cela, les applications doivent utiliser un minuteur haute résolution.
NOTE
Les fonctions Quer yInterruptTime , Quer yInterruptTimePrecise , Quer yUnbiasedInterruptTime et
Quer yUnbiasedInterruptTimePrecise produisent des résultats différents sur les versions Debug (« checked ») de
Windows, car le nombre de temps d’interruption et le nombre de cycles sont avancés d’environ 49 jours. Cela permet
d’identifier les bogues qui peuvent ne pas se produire tant que le système n’a pas été exécuté pendant une longue
période. La version vérifiée est disponible pour les abonnés MSDN via le site Web Microsoft Developer Network (MSDN) .
L’exemple suivant montre comment récupérer le nombre de temps d’interruption en appelant les fonctions
Quer yInterruptTime , Quer yInterruptTimePrecise , Quer yUnbiasedInterruptTime et
Quer yUnbiasedInterruptTimePrecise . Créez un lien vers la bibliothèque OneCore. lib lorsque vous générez
une application console qui appelle ces fonctions.
#include "stdafx.h"
#include <realtimeapiset.h>
void InterruptTimeTest()
{
ULONGLONG InterruptTime;
ULONGLONG PreciseInterruptTime;
ULONGLONG UnbiasedInterruptTime;
ULONGLONG PreciseUnbiasedInterruptTime;
// The interrupt time that QueryInterruptTime reports is based on the

// latest tick of the system clock timer. The system clock timer is
// the hardware timer that periodically generates interrupts for the
// system clock. The uniform period between system clock timer
// interrupts is referred to as a system clock tick, and is typically
// in the range of 0.5 milliseconds to 15.625 milliseconds, depending
// on the hardware platform. The interrupt time value retrieved by
// QueryInterruptTime is accurate within a system clock tick.
QueryInterruptTime(&InterruptTime);
printf("Interrupt time: %.7f seconds\n",
(double)InterruptTime/(double)10000000);
// Precise interrupt time is more precise than the interrupt time that
// QueryInterruptTime reports because the functions that report
// precise interrupt time read the timer hardware directly.
QueryInterruptTimePrecise(&PreciseInterruptTime);
printf("Precise interrupt time: %.7f seconds\n",
(double)PreciseInterruptTime/(double)10000000);
// Unbiased interrupt time means that only time that the system is in
// the working state is counted. Therefore, the interrupt-time count
// is not biased by time the system spends in sleep or hibernation.
QueryUnbiasedInterruptTime(&UnbiasedInterruptTime);
printf("Unbiased interrupt time: %.7f seconds\n",
(double)UnbiasedInterruptTime/(double)10000000);
// QueryUnbiasedInterruptTimePrecise gets an interrupt-time count

// that is both unbiased and precise, as defined in the comments
// included earlier in this example.
QueryUnbiasedInterruptTimePrecise(&PreciseUnbiasedInterruptTime);
printf("Precise unbiased interrupt time: %.7f seconds\n",
(double)PreciseUnbiasedInterruptTime/(double)10000000);
int main(void)
{
void InterruptTimeTime();
InterruptTimeTest();
return(0);
}
Pour récupérer le temps écoulé qui compte pour la mise en veille ou la mise en veille prolongée, utilisez la
fonction GetTickCount ou GetTickCount64 , ou utilisez le compteur de performances système de temps
d’activité du système. Ce compteur de performance peut être récupéré à partir des données de performances de
la clé de Registre HKEY _ performance _ Data . La valeur retournée est une valeur de 8 octets. Pour plus
d’informations, consultez Compteurs de performances.
Rubriques connexes
Quer yInterruptTime
Quer yInterruptTimePrecise
Quer yUnbiasedInterruptTime
Quer yUnbiasedInterruptTimePrecise
timeBeginPeriod
timeEndPeriod
Les sections suivantes décrivent comment utiliser les fonctions Time :

Modification de l’heure d’un fichier à l’heure actuelle
Conversion d’une _ valeur de temps t en heure de fichier
L’exemple suivant utilise la fonction GetFileTime pour récupérer l’heure de dernière écriture d’un fichier. Il
convertit l’heure en heure locale en fonction des paramètres du fuseau horaire en cours et crée une chaîne de
date et d’heure qui peut être présentée à l’utilisateur.
#include <tchar.h>
#include <strsafe.h>
// GetLastWriteTime - Retrieves the last-write time and converts

// the time to a string
//
// Return value - TRUE if successful, FALSE otherwise
// hFile - Valid file handle
// lpszString - Pointer to buffer to receive string
BOOL GetLastWriteTime(HANDLE hFile, LPTSTR lpszString, DWORD dwSize)

{
FILETIME ftCreate, ftAccess, ftWrite;
SYSTEMTIME stUTC, stLocal;
DWORD dwRet;
// Retrieve the file times for the file.

if (!GetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite))
return FALSE;
// Convert the last-write time to local time.

FileTimeToSystemTime(&ftWrite, &stUTC);
SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
// Build a string showing the date and time.

dwRet = StringCchPrintf(lpszString, dwSize,
TEXT("%02d/%02d/%d %02d:%02d"),
stLocal.wMonth, stLocal.wDay, stLocal.wYear,
stLocal.wHour, stLocal.wMinute);
if( S_OK == dwRet )

return TRUE;
else return FALSE;
}
int _tmain(int argc, TCHAR *argv[])

{
HANDLE hFile;
TCHAR szBuf[MAX_PATH];
if( argc != 2 )
{
printf("This sample takes a file name as a parameter\n");
return 0;
}
hFile = CreateFile(argv[1], GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
printf("CreateFile failed with %d\n", GetLastError());
return 0;
}
if(GetLastWriteTime( hFile, szBuf, MAX_PATH ))
_tprintf(TEXT("Last write time is: %s\n"), szBuf);
CloseHandle(hFile);
}
Rubriques connexes
Modification de l’heure d’un fichier à l’heure
actuelle
L’exemple suivant définit l’heure de dernière écriture d’un fichier à l’heure système actuelle à l’aide de la fonction
SetFileTime .
Le système de fichiers NTFS stocke les valeurs d’heure au format UTC. elles ne sont donc pas affectées par les
modifications apportées au fuseau horaire ou à l’heure d’été. Le système de fichiers FAT stocke les valeurs
d’heure en fonction de l’heure locale de l’ordinateur.
Le fichier doit être ouvert avec la fonction CreateFile à l’aide des attributs d’écriture de fichier _ _ .
// SetFileToCurrentTime - sets last write time to current system time

// Return value - TRUE if successful, FALSE otherwise
// hFile - must be a valid file handle
BOOL SetFileToCurrentTime(HANDLE hFile)

{
FILETIME ft;
SYSTEMTIME st;
BOOL f;
GetSystemTime(&st); // Gets the current system time

SystemTimeToFileTime(&st, &ft); // Converts the current system time to file time format
f = SetFileTime(hFile, // Sets last-write time of the file
(LPFILETIME) NULL, // to the converted current system time
(LPFILETIME) NULL,
&ft);
return f;
}
Conversion d’une _ valeur de temps t en heure de
fichier
Les fonctions d’heure incluses dans le runtime C utilisent le _ type de temps t pour représenter le nombre de
secondes écoulées depuis le 1er janvier 1970 à minuit. L’exemple suivant convertit une _ valeur t Time t en une
heure de fichier, à l’aide de la fonction Int32x32To64 .
#include <time.h>
void TimetToFileTime( time_t t, LPFILETIME pft )

{
LONGLONG ll = Int32x32To64(t, 10000000) + 116444736000000000;
pft->dwLowDateTime = (DWORD) ll;
pft->dwHighDateTime = ll >>32;
}
Une fois que vous avez obtenu une heure de fichier, vous pouvez convertir cette valeur en heure système à l’aide
de la fonction FileTimeToSystemTime .
Windows fournit des api que vous pouvez utiliser pour acquérir des horodatages haute résolution ou mesurer
des intervalles de temps. L’API principale pour le code natif est Quer yPerformanceCounter (QPC) . Pour les
pilotes de périphérique, l’API en mode noyau est KeQuer yPerformanceCounter . Pour le code managé, la
classe System. Diagnostics. chronomètre utilise QPC comme heure précise.
QPC est indépendant de et n’est pas synchronisé avec les références d’heure externes. Pour récupérer les
horodatages qui peuvent être synchronisés avec une référence horaire externe, par exemple, le temps universel
coordonné (UTC, Universal Time Coordinated) pour une utilisation dans des mesures à un moment donné dans
le temps de haute résolution, utilisez GetSystemTimePreciseAsFileTime .
Les horodatages et les mesures de l’intervalle de temps font partie intégrante des mesures de performances de
l’ordinateur et du réseau. Ces opérations de mesure des performances incluent le calcul du temps de réponse, le
débit et la latence, ainsi que l’exécution du code de profilage. Chacune de ces opérations implique une mesure
des activités qui se produisent pendant un intervalle de temps défini par un événement de début et de fin qui
peut être indépendant de toute référence au moment de la journée externe.
QPC est généralement la meilleure méthode pour utiliser les événements d’horodatage et mesurer les petits
intervalles de temps qui se produisent sur le même système ou la même machine virtuelle. Envisagez d’utiliser
GetSystemTimePreciseAsFileTime lorsque vous souhaitez horodater des événements sur plusieurs
ordinateurs, à condition que chaque ordinateur participe à un schéma de synchronisation horaire tel que NTP
(Network Time Protocol). QPC vous aide à éviter les difficultés qui peuvent être rencontrées avec d’autres
approches de mesure du temps, telles que la lecture directe du compteur d’horodatage du processeur (TSC).
prise en charge de QPC dans les versions Windows
Conseils pour l’acquisition d’horodatages
Virtualisation
Utilisation directe du TSC
Exemples d’acquisition d’horodatages
FAQ générale sur QPC et TSC
FAQ sur la programmation avec QPC et TSC
Caractéristiques de l’horloge matérielle de bas niveau
Horloges absolues et horloges de différence
Résolution, précision, précision et stabilité
Informations sur la minuterie matérielle
prise en charge de QPC dans les versions Windows

QPC a été introduite dans Windows 2000 et Windows XP et a évolué pour tirer parti des améliorations
apportées à la plate-forme matérielle et aux processeurs. ici, nous décrivons les caractéristiques de QPC sur
différentes versions de Windows pour vous aider à gérer les logiciels qui s’exécutent sur ces versions Windows.
Windows XP et Windows 2000
QPC est disponible sur Windows XP et Windows 2000 et fonctionne bien sur la plupart des systèmes. Toutefois,
le BIOS de certains systèmes matériels n’indique pas correctement les caractéristiques de l’UC matérielle (TSC
non indifférent), et certains systèmes à plusieurs cœurs ou multiprocesseurs utilisaient des processeurs avec
TSCs qui n’ont pas pu être synchronisés entre les cœurs. les systèmes avec un microprogramme défectueux qui
exécutent ces versions de Windows peuvent ne pas fournir la même QPC de lecture sur différents cœurs s’ils
ont utilisé le TSC comme base pour QPC .
Windows Vista et Windows Server 2008
tous les ordinateurs livrés avec Windows Vista et Windows Server 2008 utilisaient un compteur de plateforme
High Precision Event Timer (HPET) ou le minuteur de gestion de l’alimentation ACPI (temporisateur PM) comme
base pour QPC . Ces minuteurs de plateforme ont une latence d’accès plus élevée que le TSC et sont partagés
entre plusieurs processeurs. Cela limite l’extensibilité de QPC si elle est appelée simultanément à partir de
plusieurs processeurs.
Windows 7 et Windows Server 2008 R2
la majorité des ordinateurs Windows 7 et Windows Server 2008 R2 disposent de processeurs avec TSCs à débit
constant et utilisent ces compteurs comme base pour QPC . Les TSCs sont des compteurs matériels à haute
résolution par processeur qui sont accessibles avec une latence et une surcharge très faibles (dans l’ordre des
dizaines ou des centaines de cycles d’ordinateur, selon le type de processeur). Windows 7 et Windows Server
2008 R2 utilisent TSCs comme base de QPC sur des systèmes de domaine à une seule horloge où le système
d’exploitation (ou l’hyperviseur) est en mesure de synchroniser étroitement les TSCs individuels sur tous les
processeurs pendant l’initialisation du système. Sur ces systèmes, le coût de lecture du compteur de
performances est nettement plus faible par rapport aux systèmes qui utilisent un compteur de plateforme. En
outre, il n’existe aucune surcharge supplémentaire pour les appels simultanés et les requêtes en mode utilisateur
contournent souvent des appels système, ce qui réduit encore davantage la surcharge. sur les systèmes où le
TSC n’est pas adapté à la minuterie, Windows sélectionne automatiquement un compteur de plateforme (le
minuteur HPET ou la minuterie ACPI PM) comme base pour QPC .
Windows 8, Windows 8.1, Windows Server 2012 et Windows Server 2012 R2
Windows 8, Windows 8.1, Windows Server 2012 et Windows Server 2012 R2 utilisent TSCs comme base pour
le compteur de performance. L’algorithme de synchronisation TSC a été considérablement amélioré pour mieux
prendre en charge de grands systèmes avec de nombreux processeurs. En outre, la prise en charge de la
nouvelle API précise de l’heure du jour a été ajoutée, ce qui permet d’obtenir des horodatages précis de
l’horloge du système d’exploitation. Pour plus d’informations, consultez GetSystemTimePreciseAsFileTime .
sur les plateformes pc Windows RT, le compteur de performances est basé sur un compteur de plateforme
propriétaire ou sur le compteur système fourni par le minuteur générique Windows RT PC si la plateforme est
équipée.
Conseils pour l’acquisition d’horodatages

Windows a et continuera à investir dans la fourniture d’un compteur de performances fiable et efficace. Lorsque
vous avez besoin d’horodatages avec une résolution de 1 microsecondes ou plus et que vous n’avez pas besoin
des horodatages à synchroniser avec une référence horaire externe, choisissez Quer yPerformanceCounter ,
KeQuer yPerformanceCounter ou KeQuer yInterruptTimePrecise . Lorsque vous avez besoin d’horodatages
synchronisés UTC avec une résolution de 1 microsecondes ou plus, choisissez
GetSystemTimePreciseAsFileTime ou KeQuer ySystemTimePrecise .
Sur un nombre relativement faible de plateformes qui ne peuvent pas utiliser le registre TSC comme base QPC ,
par exemple, pour des raisons expliquées dans informations sur la minuterie matérielle, l’acquisition
d’horodatages haute résolution peut être considérablement plus coûteuse que l’acquisition d’horodatages avec
une résolution inférieure. Si la résolution de 10 à 16 millisecondes est suffisante, vous pouvez utiliser
GetTickCount64 , Quer yInterruptTime , Quer yUnbiasedInterruptTime , KeQuer yInterruptTime ou
KeQuer yUnbiasedInterruptTime pour obtenir des horodatages qui ne sont pas synchronisés avec une
référence horaire externe. Pour les horodatages synchronisés en UTC, utilisez GetSystemTimeAsFileTime ou
KeQuer ySystemTime . Si vous avez besoin d’une résolution supérieure, vous pouvez utiliser
Quer yInterruptTimePrecise , Quer yUnbiasedInterruptTimePrecise ou KeQuer yInterruptTimePrecise
pour obtenir des horodatages à la place.
En général, les résultats des compteurs de performances sont cohérents sur tous les processeurs des systèmes
multicœurs et multiprocesseurs, même s’ils sont mesurés sur différents threads ou processus. Voici quelques
exceptions à cette règle :
les systèmes d’exploitation antérieurs à Windows Vista qui s’exécutent sur certains processeurs peuvent
violer cette cohérence pour l’une des raisons suivantes :
Les processeurs matériels ont un TSC non indifférent et le BIOS n’indique pas correctement cette
condition.
L’algorithme de synchronisation TSC utilisé n’était pas adapté aux systèmes avec un grand nombre de
processeurs.
Lorsque vous comparez les résultats des compteurs de performance obtenus à partir de différents
threads, envisagez des valeurs qui diffèrent par un battement de ± 1 pour avoir un classement ambigu. Si
les horodatages sont tirés du même thread, cette incertitude de l’intervalle ± 1 ne s’applique pas. Dans ce
contexte, le terme « Tick » fait référence à un laps de temps égal à 1 ÷ (fréquence du compteur de
performance obtenu de Quer yPerformanceFrequency ).
quand vous utilisez le compteur de performances sur des systèmes de serveur de grande taille avec des
domaines à plusieurs horloges qui ne sont pas synchronisés dans le matériel, Windows détermine que le TSC ne
peut pas être utilisé à des fins de synchronisation et sélectionne un compteur de plateforme comme base pour
QPC . Bien que ce scénario produise toujours des horodatages fiables, la latence d’accès et l’évolutivité sont
affectées. Par conséquent, comme indiqué précédemment dans les instructions d’utilisation précédentes, utilisez
uniquement les API qui fournissent 1 microseconde ou une meilleure résolution lorsque cette résolution est
nécessaire. Le TSC est utilisé comme base pour les QPC sur des systèmes de domaine à plusieurs horloges qui
incluent la synchronisation matérielle de tous les domaines d’horloge de processeur, car cela leur fait
fonctionner en tant que système de domaine à horloge unique.
La fréquence du compteur de performances est fixée au démarrage du système et est cohérente sur tous les
processeurs. vous devez donc uniquement interroger la fréquence à partir de Quer yPerformanceFrequency
à mesure que l’application est initialisée, puis mettre en cache le résultat.
Virtualisation
Le compteur de performances est censé fonctionner de manière fiable sur toutes les machines virtuelles invitées
s’exécutant sur des hyperviseurs correctement implémentés. Toutefois, les hyperviseurs qui sont conformes à
l’interface de la version 1,0 de l’hyperviseur et qui surveillent l’indisponibilité du temps de référence peuvent
offrir une surcharge nettement inférieure. Pour plus d’informations sur les interfaces d’hyperviseur et les
indications, consultez spécifications de l' hyperviseur.
Utilisation directe du TSC
nous vous déconseillons fortement d’utiliser l’instruction de processeur RDTSC ou rdtscp, pour interroger
directement le TSC, car vous n’obtiendrez pas de résultats fiables sur certaines versions de Windows, sur des
migrations dynamiques de machines virtuelles et sur des systèmes matériels sans invariant ou synchronisés
étroitement TSCs. Au lieu de cela, nous vous encourageons à utiliser QPC pour tirer parti de l’abstraction, de la
cohérence et de la portabilité qu’il offre.
Exemples d’acquisition d’horodatages
Les différents exemples de code de ces sections montrent comment obtenir des horodatages.
Utilisation de QPC en code natif
Cet exemple montre comment utiliser QPC en code natif C et C++.
LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds;
LARGE_INTEGER Frequency;
QueryPerformanceFrequency(&Frequency);
QueryPerformanceCounter(&StartingTime);
// Activity to be timed
QueryPerformanceCounter(&EndingTime);
ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
//
// We now have the elapsed number of ticks, along with the
// number of ticks-per-second. We use these values
// to convert to the number of elapsed microseconds.
// To guard against loss-of-precision, we convert
// to microseconds *before* dividing by ticks-per-second.
//
ElapsedMicroseconds.QuadPart *= 1000000;
ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
Acquisition d’horodatages haute résolution à partir du code managé

Cet exemple montre comment utiliser la classe System. Diagnostics. chronomètre du code managé.
using System.Diagnostics;
long StartingTime = Stopwatch.GetTimestamp();
long EndingTime = Stopwatch.GetTimestamp();

long ElapsedTime = EndingTime - StartingTime;
double ElapsedSeconds = ElapsedTime * (1.0 / Stopwatch.Frequency);
La classe System. Diagnostics. chronomètre fournit également plusieurs méthodes pratiques pour effectuer
des mesures d’intervalle de temps.
Utilisation de QPC à partir du mode noyau
le noyau Windows fournit un accès en mode noyau au compteur de performances par le biais de
KeQuer yPerformanceCounter à partir desquels le compteur de performance et la fréquence de performance
peuvent être obtenus. KeQuer yPerformanceCounter est disponible uniquement à partir du mode noyau et
est fourni pour les rédacteurs de pilotes de périphériques et d’autres composants en mode noyau.
Cet exemple montre comment utiliser KeQuer yPerformanceCounter en mode noyau C et C++.
LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds;

LARGE_INTEGER Frequency;
StartingTime = KeQueryPerformanceCounter(&Frequency);
EndingTime = KeQueryPerformanceCounter(NULL);
ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
ElapsedMicroseconds.QuadPart *= 1000000;
ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
FAQ générale sur QPC et TSC
Voici des réponses aux questions fréquemment posées sur QPC et TSCs en général.
Quer yPerformanceCounter () est-il identique à la fonction Win32 GetTickCount () ou
GetTickCount64 () ?
Non. GetTickCount et GetTickCount64 ne sont pas liés à QPC . GetTickCount et GetTickCount64
retournent le nombre de millisecondes écoulées depuis le démarrage du système.
Dois-je utiliser QPC ou appeler directement les instructions RDTSC/RDTSCP ?
Pour éviter les problèmes d’inexactitude et de portabilité, nous vous encourageons vivement à utiliser QPC au
lieu d’utiliser le registre TSC ou les instructions de processeur RDTSC ou rdtscp, .
Qu’est-ce que la relation entre QPC et une époque de temps externe ? Peut-il être synchronisé
avec une époque externe telle que l’heure UTC ?
QPC est basé sur un compteur matériel qui ne peut pas être synchronisé avec une référence horaire externe, par
exemple UTC. Pour obtenir des horodatages précis au moment de la journée qui peuvent être synchronisés avec
une référence UTC externe, utilisez GetSystemTimePreciseAsFileTime .
Le QPC est-il affecté par l’heure d’été, les secondes bissextiles, les fuseaux horaires ou les
modifications de l’heure système effectuées par l’administrateur ?
Non. QPC est complètement indépendant de l’heure système et du temps universel coordonné (UTC).
La précision QPC est-elle affectée par les modifications de fréquence du processeur dues à la
gestion de l’alimentation ou à la technologie Turbo Boost ?
Non. Si le processeur a un TSC invariant, le QPC n’est pas affecté par ce type de modifications. Si le processeur
ne dispose pas d’un TSC invariant, QPC reviendra à une horloge matérielle de la plateforme qui n’est pas
affectée par les modifications de fréquence du processeur ou la technologie Turbo Boost.
QPC fonctionne-t-il de manière fiable sur les systèmes multiprocesseurs, le système multicœur et
les systèmes avec Hyper-Threading ?
Oui
Comment faire déterminer et vérifier que QPC fonctionne sur mon ordinateur ?
Vous n’avez pas besoin d’effectuer ces vérifications.
Quels processeurs ont des TSCs non invariants ? Comment puis-je vérifier si mon système a un
TSC non indifférent ?
Vous n’avez pas besoin d’effectuer cette vérification vous-même. Windows systèmes d’exploitation effectuent
plusieurs vérifications lors de l’initialisation du système pour déterminer si le TSC est approprié comme base
pour QPC . Toutefois, à des fins de référence, vous pouvez déterminer si votre processeur a un TSC invariant en
utilisant l’une des opérations suivantes :
utilitaire Coreinfo.exe de Windows Sysinternals
vérification des valeurs retournées par l’instruction CPUID concernant les caractéristiques TSC
documentation du fabricant du processeur
l’exemple suivant montre les informations d’invariant TSC fournies par l’utilitaire Windows Sysinternals
Coreinfo.exe utility (www.sysinternals.com). Un astérisque signifie « true ».
> Coreinfo.exe
Coreinfo v3.2 - Dump information on system CPU and memory topology

Copyright (C) 2008-2012 Mark Russinovich
Sysinternals - www.sysinternals.com
<unrelated text removed>
RDTSCP * Supports RDTSCP instruction

TSC * Supports RDTSC instruction
TSC-DEADLINE - Local APIC supports one-shot deadline timer
TSC-INVARIANT * TSC runs at constant rate
QPC fonctionne-t-il de façon fiable sur les plateformes matérielles PC Windows RT ?

Oui
Quelle est la fréquence de l’annulation de QPC ?
Au moins 100 ans du démarrage système le plus récent, et potentiellement plus longtemps en fonction du
minuteur matériel sous-jacent utilisé. Pour la plupart des applications, la substitution n’est pas un problème.
Quel est le coût de calcul de l’appel de QPC ?
Le coût d’appel de calcul de QPC est déterminé principalement par la plateforme matérielle sous-jacente. Si le
registre TSC est utilisé comme base pour QPC, le coût de calcul est déterminé principalement par la durée de
traitement d’une instruction RDTSC par le processeur. Cette période est comprise entre 10 et 10 cycles de
processeur, en fonction du processeur utilisé. Si le TSC ne peut pas être utilisé, le système sélectionnera une
autre durée du matériel. Étant donné que ces bases de temps se trouvent sur la carte mère (par exemple, sur le
pont Sud PCI ou PCH), le coût de calcul par appel est plus élevé que le TSC, et est fréquemment situé à proximité
de 0,8 à 1,0 microsecondes, en fonction de la vitesse du processeur et d’autres facteurs matériels. Ce coût est
dominé par le temps nécessaire pour accéder au périphérique matériel sur la carte mère.
QPC requier t-t-il une transition de noyau (appel système) ?
Une transition de noyau n’est pas nécessaire si le système peut utiliser le registre TSC comme base pour QPC . Si
le système doit utiliser une autre base de temps, telle que la minuterie HPET ou PM, un appel système est
nécessaire.
Le compteur de performances est-il monotone (non décroissant) ?
Oui
Le compteur de performances peut-il être utilisé pour ordonner les événements dans le temps ?
Oui. Toutefois, lors de la comparaison des résultats des compteurs de performance obtenus à partir de différents
threads, les valeurs qui diffèrent par une graduation de ± 1 ont un ordre ambigu comme si elles avaient un
horodatage identique.
Quel est le degré de précision du compteur de performances ?
La réponse dépend de plusieurs facteurs. Pour plus d’informations, consultez caractéristiques de l' horloge
matérielle de bas niveau.
FAQ sur la programmation avec QPC et TSC

Voici des réponses aux questions fréquemment posées sur la programmation avec QPC et TSCs.
Je dois conver tir la sor tie QPC en millisecondes. Comment puis-je éviter la per te de précision lors
de la conversion en double ou float ?
Il y a plusieurs choses à garder à l’esprit lors de l’exécution de calculs sur des compteurs de performances
d’entiers :
La Division d’entiers perd le reste. Cela peut entraîner une perte de précision dans certains cas.
La conversion entre des entiers 64 bits et une virgule flottante (double) peut entraîner une perte de précision,
car la mantisse à virgule flottante ne peut pas représenter toutes les valeurs intégrales possibles.
La multiplication des entiers 64 bits peut entraîner un dépassement sur les entiers.
En règle générale, retardez ces calculs et conversions autant que possible pour éviter d’aggraver les erreurs
introduites.
Comment puis-je conver tir QPC en graduations de 100 nanosecondes afin de pouvoir l’ajouter à
un FILETIME ?
Une heure de fichier est une valeur 64 bits qui représente le nombre d’intervalles de 100 nanosecondes qui se
sont écoulés depuis 12:00 h 00. Le 1er janvier 1601 temps universel coordonné (UTC). Les heures de fichier sont
utilisées par les appels d’API Win32 qui renvoient l’heure du jour, par exemple GetSystemTimeAsFileTime et
GetSystemTimePreciseAsFileTime . En revanche, Quer yPerformanceCounter retourne des valeurs qui
représentent le temps en unités de 1/(fréquence du compteur de performance obtenu à partir de
Quer yPerformanceFrequency ). La conversion entre les deux requiert le calcul du rapport entre l’intervalle
QPC et les intervalles de 100 nanosecondes. Veillez à éviter la perte de précision, car les valeurs peuvent être
petites (0,0000001/0,000000340).
Pourquoi l’horodatage renvoyé par QPC est-il un entier signé ?
Les calculs qui impliquent des horodatages QPC peuvent impliquer la soustraction. En utilisant une valeur
signée, vous pouvez gérer des calculs qui peuvent produire des valeurs négatives.
Comment puis-je obtenir des horodatages haute résolution à par tir du code managé ?
Appelez la méthode chronomètre. getTimestamp à partir de la classe System. Diagnostics. chronomètre
. Pour obtenir un exemple d’utilisation de chronomètre. getTimestamp , consultez acquisition d’horodatages
haute résolution à partir du code managé.
Dans quelles circonstances Quer yPerformanceFrequency retourne FALSe ou
Quer yPerformanceCounter retourne zéro ?
cela ne se produit pas sur les systèmes qui exécutent Windows XP ou version ultérieure.
Ai-je besoin de définir l’affinité de thread sur un seul cœur pour utiliser QPC ?
Non. Pour plus d’informations, consultez conseils pour l’acquisition d’horodatages. Ce scénario n’est ni
nécessaire ni souhaitable. L’exécution de ce scénario peut nuire aux performances de votre application en
restreignant le traitement à un seul cœur ou en créant un goulot d’étranglement sur un seul cœur si plusieurs
threads définissent leur affinité sur le même noyau lors de l’appel de Quer yPerformanceCounter .
Caractéristiques de l’horloge matérielle de bas niveau

Ces sections présentent les caractéristiques de l’horloge matérielle de bas niveau.
Horloges absolues et horloges de différence
Les horloges absolues fournissent des lectures temporelles précises. Elles sont généralement basées sur le
temps universel coordonné (UTC, Universal Time Coordinated) et, par conséquent, leur précision dépend en
partie de la façon dont elles sont synchronisées avec une référence horaire externe. Les horloges de différence
mesurent les intervalles de temps et ne sont généralement pas basées sur une époque de temps externe. QPC
est une horloge de différence et n’est pas synchronisée avec une époque ou référence de temps externe. Lorsque
vous utilisez QPC pour les mesures de l’intervalle de temps, vous obtiendrez généralement une meilleure
précision que si vous obteniez des horodatages dérivés d’une horloge absolue. Cela est dû au fait que le
processus de synchronisation de l’heure d’une horloge absolue peut introduire des décalages de phase et de
fréquence qui augmentent l’incertitude des mesures de l’intervalle de temps à long terme.
Résolution, précision, précision et stabilité
QPC utilise un compteur matériel comme base. Les minuteurs matériels se composent de trois parties : un
générateur de graduations, un compteur qui compte les graduations et un moyen de récupérer la valeur de
compteur. Les caractéristiques de ces trois composants déterminent la résolution, la précision, la précision et la
stabilité des QPC .
Si un générateur de matériel fournit des graduations à une vitesse constante, les intervalles de temps peuvent
être mesurés en comptant simplement ces graduations. La vitesse à laquelle les battements sont générées est
appelée fréquence et exprimée en Hertz (Hz). La réciproque de la fréquence est appelée intervalle de période ou
de cycle et est exprimée dans un système international approprié d’unités de temps (SI) (par exemple, seconde,
milliseconde, microseconde ou nanoseconde).
La résolution de la minuterie est égale à la période. La résolution détermine la possibilité de faire la distinction
entre deux horodatages et place une limite inférieure sur les intervalles de temps les plus petits qui peuvent être
mesurés. C’est ce que l’on appelle parfois la résolution de graduation.
La mesure numérique du temps introduit une incertitude de mesure de ± 1 cycle, car le compteur numérique
avance en étapes discrètes, tandis que le temps progresse continuellement. Cette incertitude est appelée une
erreur de quantification. Pour les mesures d’intervalle de temps classiques, cet effet peut souvent être ignoré car
l’erreur de quantification est bien plus petite que l’intervalle de temps mesuré.
Toutefois, si la période mesurée est faible et s’approche de la résolution de la minuterie, vous devez tenir compte
de cette erreur de quantification. La taille de l’erreur introduite est celle d’une période d’horloge.
Les deux diagrammes suivants illustrent l’impact de l’incertitude du battement ± 1 à l’aide d’un minuteur avec
une résolution de 1 unité de temps.
Quer yPerformanceFrequency retourne la fréquence de QPC , et la période et la résolution sont égales à la
réciproque de cette valeur. La fréquence des compteurs de performance renvoyée par
Quer yPerformanceFrequency est déterminée lors de l’initialisation du système et ne change pas pendant
l’exécution du système.
NOTE
Il existe des cas où Quer yPerformanceFrequency ne retourne pas la fréquence réelle du générateur de cycles
matériels. Par exemple, dans de nombreux cas, Quer yPerformanceFrequency retourne la fréquence TSC divisée par
1024 ; et sur Hyper-V, la fréquence du compteur de performance est toujours de 10 MHz lorsque l’ordinateur virtuel
invité s’exécute sous un hyperviseur qui implémente l’interface de l' hyperviseur version 1,0. Par conséquent, ne supposez
pas que Quer yPerformanceFrequency retourne la fréquence TSC précise.
Quer yPerformanceCounter lit le compteur de performance et retourne le nombre total de cycles qui se sont
produits depuis le démarrage du système d’exploitation Windows, y compris l’heure à laquelle l’ordinateur se
trouvait dans un état de veille tel que en veille, en veille prolongée ou en veille connectée.
Ces exemples montrent comment calculer l’intervalle de graduation et la résolution et comment convertir le
nombre de graduations en valeur d’heure.
Exemple 1
Quer yPerformanceFrequency retourne la valeur 3 125 000 sur un ordinateur particulier. Quel est l’intervalle
de graduation et la résolution des mesures de QPC sur cet ordinateur ? L’intervalle de graduation, ou point, est
la réciproque de 3 125 000, qui est 0,000000320 (320 nanosecondes). Par conséquent, chaque battement
représente le passage de nanosecondes de 320. Les intervalles de temps inférieurs à 320 nanosecondes ne
peuvent pas être mesurés sur cet ordinateur.
Intervalle de graduation = 1/(fréquence de performance)
Intervalle de graduation = 1/3125000 = 320 NS
Exemple 2
Sur le même ordinateur que l’exemple précédent, la différence entre les valeurs retournées par deux appels
successifs à QPC est de 5. Combien de temps s’est écoulé entre les deux appels ? 5 battements multiplié par 320
nanosecondes génèrent 1,6 microsecondes.
ElapsedTime = intervalle de * graduations
ElapsedTime = 5 * 320 NS = 1,6 μs
L’accès (lecture) du compteur du logiciel prend du temps, et ce temps d’accès peut réduire la précision de la
mesure du temps. Cela est dû au fait que la durée minimale de l’intervalle (l’intervalle de temps le plus court
pouvant être mesuré) est la plus grande de la résolution et du temps d’accès.
Précision = [ résolution maximale, AccessTime]
Par exemple, considérez un minuteur matériel hypothétique avec une résolution de 100 nanosecondes et un
temps d’accès de 800 nanoseconde. Cela peut être le cas si la minuterie de la plateforme a été utilisée à la place
du Registre TSC comme base de QPC . Par conséquent, la précision est de 800 nanosecondes non 100
nanosecondes, comme indiqué dans ce calcul.
Précision = MAX [ 800 NS, 100 NS ] = 800 NS
Ces deux figures illustrent cet effet.
Si le temps d’accès est supérieur à la résolution, ne tentez pas d’améliorer la précision en devinant. En d’autres
termes, il s’agit d’une erreur qui consiste à supposer que l’horodatage est pris précisément au milieu, ou au
début ou à la fin de l’appel.
En revanche, prenons l’exemple suivant dans lequel l’heure d’accès QPC est uniquement de 20 nanosecondes et
la résolution de l’horloge matérielle est de 100 nanosecondes. Cela peut être le cas si le registre TSC a été utilisé
comme base pour QPC . Ici, la précision est limitée par la résolution de l’horloge.
Dans la pratique, vous pouvez rechercher les sources de temps pour lesquelles le temps nécessaire pour lire le
compteur est plus grand ou plus petit que la résolution. Dans les deux cas, la précision est la plus grande des
deux.
Ce tableau fournit des informations sur la résolution approximative, le temps d’accès et la précision d’une
variété d’horloges. Notez que certaines valeurs varient selon les processeurs, les plateformes matérielles et les
vitesses de processeur.
F RÉQ UEN C E
SO URC E DE D’H O RLO GE RÉSO L UT IO N DE T EM P S D’A C C ÈS ( PA R
L’H O RLO GE N O M IN A L E L’H O RLO GE DÉFA UT ) P RÉC ISIO N
ORDINATEUR RTC 64 Hz 15,625 millisecondes N/A N/A
Compteur de 3 MHz 333 nanosecondes 30 nanosecondes 333 nanosecondes

performances de
requête utilisant TSC
avec une horloge de
processeur de 3 GHz
Instruction de 3 GHz 333 picoseconds 30 nanosecondes 30 nanosecondes

machine RDTSC sur
un système avec une
durée de cycle de 3
GHz
Comme QPC utilise un compteur matériel, lorsque vous comprenez certaines caractéristiques de base des
compteurs matériels, vous vous familiarisez avec les fonctionnalités et les limitations de QPC .
Le générateur de cycles matériels le plus couramment utilisé est un oscillateur à cristal. Le cristal est un petit
morceau de quartz ou autre matériau céramique qui présente des caractéristiques piézoélectriques qui
fournissent une référence de fréquence peu coûteuse avec une stabilité et une précision excellentes. Cette
fréquence est utilisée pour générer les graduations comptées par l’horloge.
La précision d’un minuteur fait référence au degré de conformité à une valeur true ou standard. Cela dépend
principalement de la capacité de l’oscillateur Crystal à fournir des graduations à la fréquence spécifiée. Si la
fréquence d’oscillation est trop élevée, l’horloge est « exécutée rapidement » et les intervalles mesurés
s’affichent plus longtemps qu’ils ne le sont vraiment. en outre, si la fréquence est trop faible, l’horloge s’exécute
lentement et les intervalles mesurés sont plus courts qu’ils ne le sont vraiment.
Pour les mesures d’intervalle de temps standard pour une durée brève (par exemple, les mesures de temps de
réponse, les mesures de latence réseau, etc.), la précision de l’oscillateur matériel est généralement suffisante.
Toutefois, pour certaines mesures, la précision de la fréquence de l’oscillateur devient importante, en particulier
pour les intervalles de temps longs ou lorsque vous souhaitez comparer les mesures effectuées sur des
ordinateurs différents. Le reste de cette section explore les effets de la précision de l’oscillateur.
La fréquence d’oscillation des cristaux est définie pendant le processus de fabrication et est spécifiée par le
fabricant en termes de fréquence spécifiée plus ou moins une tolérance de fabrication exprimée en « parties par
million » (ppm), appelée décalage de fréquence maximale. Un cristal avec une fréquence spécifiée de 1 million
Hz et un décalage de fréquence maximal de ± 10 ppm se trouve dans les limites de spécifications si sa
fréquence réelle est comprise entre 999 990 Hz et 1 000 010 Hz.
En remplaçant les parties de l’expression par million de microsecondes par seconde, nous pouvons appliquer
cette erreur de décalage de fréquence aux mesures de l’intervalle de temps. Un oscillateur avec un décalage de
+ 10 ppm a une erreur de 10 microsecondes par seconde. En conséquence, lorsque vous mesurez un intervalle
de 1 seconde, il s’exécute rapidement et mesure un intervalle de 1 seconde comme 0,999990 secondes.
Une référence pratique est qu’une erreur de fréquence de 100 ppm provoque une erreur de 8,64 secondes
après 24 heures. Ce tableau présente l’incertitude de mesure en raison de l’erreur accumulée pendant des
intervalles de temps plus longs.
IN C ERT IT UDE DE M ESURE DUE À UN E ERREUR A C C UM UL ÉE

DURÉE DE L’IN T ERVA L L E DE T EM P S AVEC UN E TO L ÉRA N C E DE F RÉQ UEN C E DE +/ - 10 P P M
1 microseconde ± 10 picoseconds (10-12)

IN C ERT IT UDE DE M ESURE DUE À UN E ERREUR A C C UM UL ÉE
DURÉE DE L’IN T ERVA L L E DE T EM P S AVEC UN E TO L ÉRA N C E DE F RÉQ UEN C E DE +/ - 10 P P M
1 milliseconde ± 10 nanosecondes (10-9)
1 seconde ± 10 microsecondes
1 heure ± 60 microsecondes
1 jour ± 0,86 secondes
1 semaine ± 6,08 secondes
Le tableau ci-dessus montre que pour les intervalles de temps réduits, l’erreur de décalage de fréquence peut
souvent être ignorée. Toutefois, pour des intervalles de temps longs, même un décalage de fréquence réduit
peut entraîner une incertitude significative de la mesure.
Les oscillateurs Crystal utilisés dans les ordinateurs personnels et les serveurs sont généralement fabriqués
avec une tolérance de fréquence de ± 30 à 50 pièces par million et, rarement, les cristaux peuvent être
désactivés jusqu’à 500 ppm. Bien que les cristaux avec des tolérances de décalage de fréquence beaucoup plus
étroites soient disponibles, ils sont plus onéreux et ne sont donc pas utilisés dans la plupart des ordinateurs.
pour réduire les effets indésirables de cette erreur de décalage de fréquence, les versions récentes de Windows,
en particulier Windows 8, utilisent plusieurs minuteries matérielles pour détecter le décalage de fréquence et
compenser le décalage dans la mesure du possible. ce processus d’étalonnage est effectué au démarrage de
Windows.
Comme le montrent les exemples suivants, l’erreur de décalage de fréquence d’une horloge matérielle influence
la précision obtenue et la résolution de l’horloge peut être moins importante.
Exemple 1
Supposons que vous exécutiez des mesures d’intervalle de temps à l’aide d’un oscillateur de 1 MHz, qui a une
résolution de 1 microseconde et une erreur de décalage de fréquence maximale de ± 50 ppm. Nous supposons
à présent que le décalage soit exactement + 50 ppm. Cela signifie que la fréquence réelle est de 1 000 050 Hz. Si
nous avons mesuré un intervalle de temps de 24 heures, notre mesure serait de 4,3 secondes trop courtes
(23:59:55.700000 mesuré par rapport à 24:00:00.000000 réel).
Secondes dans une journée = 86400
Erreur de décalage de fréquence = 50 ppm = 0,00005
86 400 secondes * 0,00005 = 4,3 secondes
Exemple 2
Supposons que l’horloge TSC du processeur est contrôlée par un oscillateur cristallin et que la fréquence
spécifiée est de 3 GHz. Cela signifie que la résolution est de 1/3000000000 ou d’environ 333 picoseconds.
Supposons que le cristal utilisé pour contrôler l’horloge du processeur a une tolérance de fréquence de ± 50
ppm et qu’elle est en fait de + 50 ppm. Malgré la haute résolution, une mesure de l’intervalle de temps de 24
heures sera toujours de 4,3 secondes. (23:59:55.7000000000 mesuré par rapport à 24:00:00.0000000000 réel).
Erreur de décalage de fréquence = 50 ppm = 0,00005
86 400 secondes * 0,00005 = 4,3 secondes
Cela montre qu’une horloge TSC haute résolution ne fournit pas nécessairement des mesures plus précises
qu’une horloge de résolution inférieure.
Exemple 3
Envisagez d’utiliser deux ordinateurs différents pour mesurer le même intervalle de 24 heures. Les deux
ordinateurs ont un oscillateur avec un décalage de fréquence maximal de ± 50 ppm. À quelle distance la mesure
du même intervalle de temps sur ces deux systèmes peut-elle être ? Comme dans les exemples précédents, ± 50
ppm génère une erreur maximale de ± 4,3 secondes après 24 heures. Si un système exécute 4,3 secondes
rapidement et que les autres 4,3 secondes sont lentes, l’erreur maximale au bout de 24 heures peut être de 8,6
secondes.
Erreur de décalage de fréquence = ± 50 ppm = ± 0,00005
± (86 400 secondes * 0,00005) = ± 4,3 secondes
Décalage maximal entre les deux systèmes = 8,6 secondes
En résumé, l’erreur de décalage de fréquence devient de plus en plus importante lorsque vous mesurez des
intervalles de temps longs et que vous comparez des mesures entre différents systèmes.
La stabilité d’un minuteur indique si la fréquence des graduations change au fil du temps, par exemple suite à
des modifications de températures. Les cristaux de quartz utilisés comme générateurs de battements sur les
ordinateurs présentent de petites modifications de fréquence en tant que fonction de température. L’erreur
provoquée par la dérive thermique est généralement faible par rapport à l’erreur de décalage de fréquence pour
les plages de température courantes. Toutefois, les concepteurs de logiciels pour les équipements portables ou
les équipements soumis à des fluctuations de température importante peuvent avoir à prendre en compte cet
effet.
Informations sur la minuterie matérielle

Registre TSC
Certains processeurs Intel et AMD contiennent un registre TSC qui est un registre 64 bits qui augmente à un
taux élevé, généralement égal à l’horloge du processeur. La valeur de ce compteur peut être lue à l’aide des
instructions de l’ordinateur RDTSC ou rdtscp, , ce qui permet de réduire le temps d’accès et le coût de calcul
dans l’ordre des dizaines ou des centaines de cycles de machine, en fonction du processeur.
Bien que le registre TSC ressemble à un mécanisme d’horodatage idéal, voici quelques circonstances dans
lesquelles il ne peut pas fonctionner de manière fiable à des fins de minuterie :
Tous les processeurs n’ont pas de registres TSC. par conséquent, l’utilisation du Registre TSC dans le logiciel
crée directement un problème de portabilité. (Windows sélectionnera une autre source de temps pour QPC
dans ce cas, ce qui évite le problème de portabilité.)
Certains processeurs peuvent varier la fréquence de l’horloge TSC ou arrêter l’avancement du Registre TSC,
ce qui rend le TSC inadapté à des fins de synchronisation sur ces processeurs. Ces processeurs sont appelés
registres TSC non invariants. (Windows détecte automatiquement cela et sélectionne une autre source de
temps pour QPC ).
Sur les systèmes multiprocesseurs ou multicœurs, certains processeurs et systèmes ne peuvent pas
synchroniser les horloges de chaque cœur avec la même valeur. (Windows détecte automatiquement cela et
sélectionne une autre source de temps pour QPC ).
Sur certains systèmes multiprocesseurs volumineux, vous ne pourrez peut-être pas synchroniser les
horloges du processeur avec la même valeur même si le processeur a un TSC invariant. (Windows détecte
automatiquement cela et sélectionne une autre source de temps pour QPC ).
Certains processeurs exécutent des instructions dans le désordre. Cela peut entraîner des nombres de cycles
incorrects lorsque RDTSC est utilisé pour les séquences d’instructions Time, car l’instruction RDTSC peut
être exécutée à une heure différente de celle spécifiée dans votre programme. L’instruction rdtscp, a été
introduite sur certains processeurs en réponse à ce problème.
Comme les autres minuteries, le TSC est basé sur un oscillateur à quartz dont la fréquence exacte n’est pas
connue à l’avance et qui a une erreur de décalage de fréquence. Ainsi, avant de pouvoir être utilisé, il doit être
étalonné à l’aide d’une autre référence de minutage.
lors de l’initialisation du système, Windows vérifie si le TSC est adapté à des fins de synchronisation et effectue
l’étalonnage et la synchronisation de base de la fréquence nécessaires.
Heure PM
Le minuteur ACPI, également appelé horloge PM, a été ajouté à l’architecture système pour fournir des
horodatages fiables indépendamment de la vitesse des processeurs. Comme il s’agissait du seul objectif de ce
minuteur, il fournit un horodatage en un seul cycle d’horloge, mais il ne fournit pas d’autres fonctionnalités.
Minuteur HPET
Le High Precision Event Timer (HPET) a été développé conjointement par Intel et Microsoft afin de répondre aux
exigences de synchronisation du multimédia et d’autres applications de temps. la prise en charge de HPET a été
Windows depuis Windows Vista, et Windows 7 et Windows 8 certification de Logo matériel nécessite la prise en
charge de HPET dans la plateforme matérielle.
Les éléments suivants sont utilisés avec Time.

Fonctions d’heure
Messages de temps
Fonctions d’heure
Les fonctions suivantes sont utilisées avec l’heure système.
GetSystemTime Récupère la date et l’heure système actuelles au format UTC.
GetSystemTimeAdjustment Détermine si le système applique des ajustements de temps

périodiques à son horloge.
GetTimeFormat Met en forme une heure système sous la forme d’une chaîne
d’heure pour les paramètres régionaux spécifiés.
NtQuer ySystemTime Retourne l’heure système.
RtlLocalTimeToSystemTime Convertit l’heure locale spécifiée en heure système.
RtlTimeToSecondsSince1970 Convertit l’heure système spécifiée en nombre de secondes

depuis la première seconde du 1er janvier 1970.
SetSystemTime Définit la date et l’heure système actuelles.
SetSystemTimeAdjustment Active ou désactive les ajustements de temps périodiques de

l’horloge du système.
SystemTimeToFileTime Convertit une heure système en heure de fichier.
SystemTimeToTzSpecificLocalTime Convertit une heure UTC en heure locale correspondante

d’un fuseau horaire spécifié.
TzSpecificLocalTimeToSystemTime Convertit une heure locale en heure UTC.
Les fonctions suivantes sont utilisées avec l’heure locale.
EnumDynamicTimeZoneInformation Énumère les entrées d’informations d’heure d’été

dynamiques stockées dans le registre.
FileTimeToLocalFileTime Convertit l’heure UTC d’un fichier en heure locale.
GetDynamicTimeZoneInformation Récupère les paramètres du fuseau horaire actuel et de

l’heure d’été dynamique.
GetDynamicTimeZoneInformationEffectiveYears Récupère une plage, exprimée en années, pour laquelle les _

_ _ informations relatives aux fuseaux horaires
dynamiques comportent des entrées valides.
GetLocalTime Récupère la date et l’heure locales actuelles.

GetTimeZoneInformation Récupère les paramètres de fuseau horaire en cours.
GetTimeZoneInformationForYear Récupère les paramètres de fuseau horaire pour l’année et le

fuseau horaire spécifiés.
RtlLocalTimeToSystemTime Convertit l’heure locale spécifiée en heure système.
SetDynamicTimeZoneInformation Définit les paramètres du fuseau horaire actuel et de l’heure

d’été dynamique.
SetLocalTime Définit la date et l’heure locales actuelles.
SetTimeZoneInformation Définit les paramètres du fuseau horaire actuel.
SystemTimeToTzSpecificLocalTime Convertit une heure UTC en heure locale correspondante

d’un fuseau horaire spécifié.
SystemTimeToTzSpecificLocalTimeEx Convertit une heure UTC avec les paramètres d’heure d’été
dynamiques en l’heure locale correspondante d’un fuseau
horaire spécifié.
TzSpecificLocalTimeToSystemTime Convertit une heure locale en heure UTC.
TzSpecificLocalTimeToSystemTimeEx Convertit une heure locale avec les paramètres d’heure d’été
dynamiques en heure UTC.
Les fonctions suivantes sont utilisées avec l’heure de fichier.
CompareFileTime Compare deux heures de fichier.
FileTimeToLocalFileTime Convertit l’heure UTC d’un fichier en heure locale.
FileTimeToSystemTime Convertit une heure de fichier au format d’heure système.
GetFileTime Récupère la date et l’heure de création, du dernier accès et

de la dernière modification du fichier ou du répertoire
spécifié.
GetSystemTimeAsFileTime Récupère la date et l’heure système actuelles au format UTC.
LocalFileTimeToFileTime Convertit une heure de fichier local en heure de fichier en

fonction de l’heure UTC.
SetFileTime Définit la date et l’heure de création du fichier ou du

répertoire spécifié, du dernier accès ou de la dernière
modification.
SystemTimeToFileTime Convertit une heure système en heure de fichier.
Les fonctions suivantes sont utilisées avec la date et l’heure MS-DOS.

DosDateTimeToFileTime Convertit les valeurs de date et d’heure MS-DOS en une

heure de fichier.
FileTimeToDosDateTime Convertit une heure de fichier en valeurs de date et d’heure

MS-DOS.
Les fonctions suivantes sont utilisées avec l’heure Windows.
GetSystemTimes Récupère les informations de minutage du système.
GetTickCount Récupère le nombre de millisecondes qui se sont écoulées

depuis le démarrage du système, jusqu’à 49,7 jours.
GetTickCount64 Récupère le nombre de millisecondes qui se sont écoulées

depuis le démarrage du système.
Les fonctions suivantes sont utilisées avec les compteurs de performance haute résolution.
Quer yPerformanceCounter Récupère la valeur actuelle du compteur de performance

haute résolution.
Quer yPerformanceFrequency Récupère la fréquence du compteur de performance haute

résolution.
Les fonctions suivantes sont utilisées avec le compteur de performances auxiliaire.
Quer yAuxiliar yCounterFrequency Interroge la fréquence des compteurs auxiliaires.
Conver tAuxiliar yCounterToPerformanceCounter Convertit la valeur de compteur auxiliaire spécifiée en valeur

de compteur de performance correspondante ; fournit
éventuellement l’erreur de conversion estimée en
nanosecondes en raison de la latence et de la dérive
maximale possible.
Conver tPerformanceCounterToAuxiliar yCounter Convertit la valeur du compteur de performance spécifiée en

valeur de compteur auxiliaire correspondante ; fournit
éventuellement l’erreur de conversion estimée en
nanosecondes en raison de la latence et de la dérive
maximale possible.
La fonction suivante est utilisée avec le temps d’interruption.
Quer yInterruptTime Obtient le nombre d’interruptions actuel.

Quer yInterruptTimePrecise Obtient le nombre actuel d’interruptions, dans une forme

plus précise que Quer yInterruptTime .
Quer yUnbiasedInterruptTime Obtient le nombre actuel d’interruptions non biaisées. Le

nombre de temps d’interruption non biaisé n’inclut pas le
temps passé par le système en mode veille ou veille
prolongée.
Quer yUnbiasedInterruptTimePrecise Obtient le nombre actuel d’interruptions non biaisées, dans

une forme plus précise que
Quer yUnbiasedInterruptTime . Le nombre de temps
d’interruption non biaisé n’inclut pas le temps passé par le
système en mode veille ou veille prolongée.
Les structures suivantes sont utilisées avec le temps.

_ _ informations sur les fuseaux horaires dynamiques _
FILETIME
SYSTEMTIME
_informations sur les fuseaux horaires _
Messages de temps
Le message suivant est utilisé avec Time.

_TIMECHANGE WM
_Message WM TIMECHANGE
Message envoyé chaque fois qu’une modification est apportée à l’heure système.
Une fenêtre reçoit ce message par le biais de sa fonction WindowProc .
LRESULT CALLBACK WindowProc(

HWND hwnd, // handle to window
UINT uMsg, // message identifier
WPARAM wParam, // not used; must be zero
LPARAM lParam // not used; must be zero
);
Paramètres
HWND
Handle de fenêtre.
uMsg
WM _ Identificateur TIMECHANGE .
wParam
Non utilisé ; doit être égal à zéro.
lParam
Non utilisé ; doit être égal à zéro.
Valeur retournée
Une application doit retourner zéro si elle traite ce message.
Notes
Une application ne doit pas diffuser ce message, car le système diffuse ce message lorsque l’application modifie
l’heure système.
Client minimal pris en charge Windows 2000 Professionnel - [Applications de bureau

uniquement]
Serveur minimal pris en charge Windows 2000 Server - [Applications de bureau

uniquement]
En-tête
Winuser. h (inclure Windows. h)
Voir aussi
SendMessage
Fournisseur de temps
le système d’exploitation Microsoft Windows prend en charge un large éventail de périphériques matériels et de
protocoles de temps réseau à l’aide de l’architecture du fournisseur de temps . Les fournisseurs de temps
d’entrée récupèrent des horodatages précis à partir du matériel ou du réseau, et les fournisseurs de temps de
sortie fournissent des horodateurs à d’autres clients sur le réseau.
Les fournisseurs de temps sont gérés par le Gestionnaire du fournisseur de temps. Il est responsable du
chargement, du démarrage et de l’arrêt des fournisseurs de temps comme indiqué par le gestionnaire de
contrôle des services. Cette interface rend l’écriture d’un fournisseur de temps plus facile que l’écriture d’un
service complet.
Rubriques connexes
Service de temps Windows
Un fournisseur de temps est implémenté en tant que DLL. Chaque DLL peut prendre en charge plusieurs
fournisseurs de temps. Chaque fournisseur est responsable de sa propre configuration et de sa propre
synchronisation.
Les fournisseurs de temps doivent implémenter les fonctions de rappel suivantes :
TimeProvClose
TimeProvCommand
TimeProvOpen
Une fois la DLL du fournisseur chargée, le gestionnaire de fournisseurs de temps appelle TimeProvOpen , en
passant le nom du fournisseur et les pointeurs aux fonctions suivantes :
Aler tSamplesAvailFunc
GetTimeSysInfoFunc
LogTimeProvEventFunc
Ces fonctions sont utilisées par le fournisseur de temps. Le fournisseur de temps utilise TimeProvOpen pour
retourner un handle de fournisseur que le gestionnaire de fournisseurs de temps utilise lors de l’envoi de
commandes au fournisseur de temps. La valeur de handle est définie par le fournisseur de temps et est utilisée
principalement pour faire la distinction entre les différents fournisseurs implémentés dans la même DLL. Le
fournisseur de temps peut consigner des événements importants à l’aide de LogTimeProvEventFunc .
Le gestionnaire de fournisseurs de temps utilise TimeProvCommand pour envoyer des commandes au
fournisseur de temps. Lorsque le fournisseur de temps doit informer le gestionnaire de fournisseurs de temps
qu’il dispose d’exemples de temps disponibles, il appelle Aler tSamplesAvailFunc . Le gestionnaire de
fournisseurs de temps appelle ensuite TimeProvCommand avec la _ commande TPC getSamples pour
récupérer les échantillons d’heure. Il peut falloir jusqu’à 16 secondes pour que le gestionnaire de fournisseurs
de temps demande l’exemple. Par conséquent, l’application ne doit pas attendre la demande.
Pour garantir la précision, le fournisseur de temps doit récupérer toutes les informations relatives au temps à
l’aide de GetTimeSysInfoFunc .
Lorsqu’il est temps d’arrêter le fournisseur de temps, le gestionnaire de fournisseurs de temps appelle
TimeProvClose .
Le système charge un fournisseur de temps en fonction de ses informations de configuration stockées dans le
registre. Chaque fournisseur de temps doit créer la clé de Registre suivante :
HKEY _ _ \ Système d’ordinateur local services de \ CurrentControlSet \ \ \ TimeProviders \
providerName
Le tableau suivant décrit les valeurs qui doivent exister dans la clé de chaque fournisseur.
VA L EUR DESC RIP T IO N
DllName Nom de la DLL qui contient le fournisseur. Cette valeur est

du type reg _ SZ .
Activé Indique si le fournisseur doit être démarré. Si la valeur est 1,

le fournisseur est démarré. Dans le cas contraire, le
fournisseur n’est pas démarré. Cette valeur est de type reg _
DWORD .
InputProvider Indique si le fournisseur est un fournisseur d’entrée ou un

fournisseur de sortie. Si la valeur est 1, le fournisseur est un
fournisseur d’entrée. Dans le cas contraire, le fournisseur est
un fournisseur de sortie. Cette valeur est de type reg _
DWORD .
Le gestionnaire de fournisseurs de temps énumère les clés sous la clé TimeProviders et démarre chaque
fournisseur activé. Les fournisseurs sont démarrés au démarrage du système et chaque fois qu’il y a des
modifications de paramètres.
Chaque fournisseur de temps peut également stocker des informations de configuration spécifiques à
l’application dans le registre.
L’exemple suivant montre comment structurer un fournisseur de temps. Dans cet exemple, la DLL prend en
charge deux fournisseurs de temps matériel.
#include "timeprov.h"
// Global variables.
TimeProvSysCallbacks sc;
WCHAR ProviderName1[] = L"MyCompanyMyAppProvider1";
WCHAR ProviderName2[] = L"MyCompanyMyAppProvider2";
const TimeProvHandle htp1 = (TimeProvHandle)1;
const TimeProvHandle htp2 = (TimeProvHandle)2;
// Stores the current set of best samples.

TpcGetSamplesArgs Samples;
// Stores the polling interval the system requires to maintain clock

// stability. The provider need not poll more often.
DWORD dwPollInterval;
HRESULT CALLBACK TimeProvOpen(

WCHAR *wszName,
TimeProvSysCallbacks *pSysCallback,
TimeProvHandle *phTimeProv)
{
// Spawn a thread to read configuration information from the
// registry.
;
// Copy the system callback pointers to a buffer.

CopyMemory(&sc, (PVOID)pSysCallback, sizeof(TimeProvSysCallbacks));
// Return the handle to the appropriate time provider.

if ( lstrcmp(wszName, ProviderName1) == 0 )
*phTimeProv = htp1;
else *phTimeProv = htp2;
return S_OK;
}
HRESULT CALLBACK TimeProvCommand(

TimeProvHandle hTimeProv,
TimeProvCmd eCmd,
PVOID pvArgs)
{
switch( eCmd )
{
case TPC_GetSamples:
// Return the Samples structure in pvArgs.
CopyMemory(pvArgs, &Samples, sizeof(TpcGetSamplesArgs));
break;
case TPC_PollIntervalChanged:
// Retrieve the new value.
sc.pfnGetTimeSysInfo( TSI_PollInterval, &dwPollInterval );
break;
case TPC_TimeJumped:
// Discard samples saved in the Samples structure.
ZeroMemory(&Samples, sizeof(TpcGetSamplesArgs));
break;
break;
case TPC_UpdateConfig:
// Read the configuration information from the registry.
break;
}
return S_OK;
}
HRESULT CALLBACK TimeProvClose(

TimeProvHandle hTimeProv)
{
if( hTimeProv == htp1 )
{
// Terminate MyCompanyMyAppProvider1, performing any cleanup.
;
}
else
{
// Terminate MyCompanyMyAppProvider2, performing any cleanup.
;
}
return S_OK;
}
Référence du fournisseur de temps
Les éléments suivants sont utilisés par les fournisseurs de temps :

Les fonctions suivantes sont utilisées par les fournisseurs de temps.
Aler tSamplesAvailFunc Informe le système que de nouveaux exemples sont

disponibles.
GetTimeSysInfoFunc Récupère les informations sur l’état de l’heure système.
LogTimeProvEventFunc Journalise un événement de fournisseur de temps dans le

journal des événements.
SetProviderStatusFunc Définit les informations d’État du fournisseur de temps.
SetProviderStatusInfoFreeFunc Libère une structure SetProviderStatusInfo .
TimeProvClose Fonction de rappel qui est appelée par le gestionnaire de

fournisseurs de temps pour arrêter le fournisseur de temps.
TimeProvCommand Fonction de rappel qui est appelée par le gestionnaire du

fournisseur de temps pour envoyer des commandes au
fournisseur de temps.
TimeProvOpen Fonction de rappel qui est appelée par le gestionnaire de

fournisseur de temps lors du chargement de la DLL du
fournisseur de temps.
Les structures suivantes sont utilisées avec les fournisseurs de temps :

SetProviderStatusInfo
TimeProvSysCallbacks
TimeSample
TpcGetSamplesArgs
Plateforme d’évaluation WaaS
la plateforme d’évaluation des mises à jour WaaS (Windows as a Service) fournit des informations sur les mises
à jour de Windows d’un appareil.
Cette documentation contient les rubriques suivantes :
La rubrique suivante décrit le fonctionnement de l’API de plateforme d’évaluation Windows As a service (WaaS).
L’API d’évaluation de WaaS offre à l’appelant les informations suivantes :
Si un appareil se trouve sur les dernières mises à jour Microsoft.
Si l’appareil a atteint la fin du support.
Heures de publication des dernières mises à jour applicables pour l’appareil.
Évaluation de la raison pour laquelle un appareil n’est pas à jour et l’impact potentiel qu’il peut avoir sur
l’appareil.
La plateforme d’évaluation WaaS utilise le modèle d’API COM et s’exécute automatiquement au moins une fois
par jour. Ce cycle intercepte les informations de version applicables. Pendant la période mise en cache, les
évaluations sont effectuées par rapport aux informations de version mises en cache. Si un appel est effectué en
dehors de la fenêtre d’expiration du cache, un nouvel appel et une nouvelle évaluation sont effectués, mis en
cache et retournés. Lorsqu’un appel est effectué, le client d’évaluation de WaaS contacte le service d’évaluation
WaaS avec les attributs de l’appareil et reçoit un dossier d’informations qui s’applique à l’appareil. Le client
utilise ensuite ces informations par rapport aux informations recueillies sur l’appareil pour effectuer l’évaluation.
NOTE
Votre code doit disposer de privilèges d’administrateur pour appeler l’API d’évaluation WAAS. Pour plus d’informations sur
le développement d’applications qui requièrent des privilèges d’administrateur, consultez cet article.
Pour utiliser l’API de la plateforme d’évaluation de WaaS, créez une instance de l’interface IWaaSAssessor , puis
appelez la méthode GetOSUpdateAssessment . En cas de réussite, le paramètre de résultat génère un objet
OSUpdateAssessment , qui contient les informations pertinentes.
L’exemple de code suivant montre comment récupérer une évaluation du système d’exploitation à partir de
votre système local, à l’aide de la méthode IWaaSAssessor. GetOSUpdateAssessment.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
#include <tchar.h>
#include <oaidl.h>
#include <atlbase.h>
#include <iostream>
#include <WaaSAPI.h>
#include <WaaSAPITypes.h>
using namespace std;
void __cdecl main(int argc, char** argv)

{
HRESULT hr = S_OK;
CComPtr<IWaaSAssessor> assessment;
OSUpdateAssessment result;
hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(
__uuidof(WaaSAssessor), // rclsid
NULL, // pUnkOuter
CLSCTX_INPROC_SERVER, // dwClsContext
__uuidof(IWaaSAssessor), // riid
(LPVOID*)&assessment); // ppv
if (SUCCEEDED(hr))
{
hr = assessment->GetOSUpdateAssessment(&result);
if (SUCCEEDED(hr))
{
wcout << L"End of Support:" << result.isEndOfSupport << endl;
wcout << L"Up to date:" << result.assessmentForUpToDate.status << endl;
wcout << L"Current:" << result.assessmentForCurrent.status << endl;
wcout << L"Up to Date Days Behind:" << result.assessmentForUpToDate.daysOutOfDate << endl;
wcout << L"Current Days Behind:" << result.assessmentForCurrent.daysOutOfDate << endl;
wcout << L"Up to Date Impact:" << result.assessmentForUpToDate.impact << endl;
wcout << L"Current Impact:" << result.assessmentForCurrent.impact << endl;
}
else
{
wcout << L"Assessment Failed hr = " << hr << endl;
}
}
else
{
wcout << L"CoCreateInstance Failed hr = " << hr << endl;
}
}
else
{
wcout << L"CoInitialize Failed hr = " << hr << endl;
}
}
Les objets suivants sont utilisés dans l’API de plateforme d’évaluation WaaS :
Structures d’évaluation de WaaS
Énumérations d’évaluation de WaaS
Interfaces d’évaluation de WaaS
Mettre à jour les structures d’évaluateur
Les fonctions suivantes sont utilisées par le fournisseur d’accesseurs de mise à jour.
OSUpdateAssessment Définit le mode de mise à jour du système d’exploitation sur

un appareil ciblé.
UpdateAssessment Contient des informations qui évaluent la manière dont un

système d’exploitation installé est à jour.
Mettre à jour les énumérations de l’évaluateur
Les énumérations suivantes sont utilisées par le fournisseur d’accesseurs de mise à jour.
UpdateAssessmentStatus Décrit comment mettre à jour le système d’exploitation sur

un appareil.
UpdateImpactLevel Indique un impact élevé, moyen ou faible sur un appareil

exécutant un système d’exploitation obsolète.
Énumération UpdateAssessmentStatus
Décrit comment mettre à jour le système d’exploitation sur un appareil. UpdateAssessmentStatus est utilisé
par les structures UpdateAssessment et OSUpdateAssessment , dans les membres
assessmentForCurrent , assessmentForUpToDate et securityStatus . Une seule constante est retournée.
Syntaxe
typedef enum TagUpdateAssessmentStatus {
UpdateAssessmentStatus_Latest = 0,
UpdateAssessmentStatus_NotLatestSoftRestriction = 1,
UpdateAssessmentStatus_NotLatestHardRestriction = 2,
UpdateAssessmentStatus_NotLatestEndOfSupport = 3,
UpdateAssessmentStatus_NotLatestServicingTrain = 4,
UpdateAssessmentStatus_NotLatestDeferredFeature = 5,
UpdateAssessmentStatus_NotLatestDeferredQuality = 6,
UpdateAssessmentStatus_NotLatestPausedFeature = 7,
UpdateAssessmentStatus_NotLatestPausedQuality = 8,
UpdateAssessmentStatus_NotLatestManaged = 9,
UpdateAssessmentStatus_NotLatestUnknown = 10,
UpdateAssessmentStatus_NotLatestTargetedVersion = 11
} UpdateAssessmentStatus;
Constantes
UpdateAssessmentStatus _ Dernière version
Ce résultat dans assessmentForCurrent implique que l’appareil se trouve sur les dernières mises à jour de
fonctionnalités et mise à jour de qualité disponibles pour cet appareil. Dans assessmentForUpToDate , ce
résultat implique que l’appareil se trouve sur la dernière mise à jour de qualité pour la version de Windows qu’il
est en cours d’exécution.
UpdateAssessmentStatus _ NotLatestSoftRestriction
La dernière mise à jour de la fonctionnalité n’a pas été installée en raison d’une restriction logicielle. Lorsqu’une
restriction logicielle a été placée sur une mise à jour, la mise à jour n’est pas installée automatiquement. un
utilisateur doit lancer automatiquement le téléchargement au sein de l’expérience utilisateur de la mise à jour.
Cet État s’applique uniquement à assessmentForCurrent .
UpdateAssessmentStatus _ NotLatestHardRestriction
La dernière mise à jour de la fonctionnalité n’a pas été installée en raison d’une restriction matérielle.
Lorsqu’une restriction matérielle a été placée sur une mise à jour, la mise à jour n’est pas applicable à l’appareil.
Cet État s’applique uniquement à assessmentForCurrent .
UpdateAssessmentStatus _ NotLatestEndOfSuppor t
L’appareil n’est pas dans la dernière mise à jour, car la mise à jour des fonctionnalités de l’appareil n’est plus
prise en charge par Microsoft. Lorsque Microsoft arrête de prendre en charge une version de fonctionnalité, cet
État est renvoyé pour assessmentForCurrent et assessmentForUpToDate .
NOTE
Lorsque UpdateAssessmentStatus _ NotLatestEndOfSuppor t est retourné, le UpdateImpactLevel de l’évaluation
est toujours UpdateImpactLevel _ élevé .
UpdateAssessmentStatus _ NotLatestSer vicingTrain

L’appareil n’est pas sur la dernière mise à jour des fonctionnalités, car le train de maintenance de l’appareil limite
la mise à jour de l’appareil à la dernière mise à jour de la fonctionnalité. Par exemple : si un appareil se trouve
sur Current Branch for Business (CBB) et qu’une nouvelle mise à jour de fonctionnalité a été publiée pour
Current Branch (CB), cette opération est retournée. Cet État s’applique uniquement à assessmentForCurrent .
UpdateAssessmentStatus _ NotLatestDeferredFeature
la dernière mise à jour de la fonctionnalité n’a pas été installée en raison de la stratégie de report des mises à
jour Windows Update pour les fonctionnalités d’entreprise de l’appareil. La détermination des daysOutOfDate
prend en compte les stratégies de report. daysOutOfDate ne commence pas à s’incrémenter tant que la
période de report n’a pas expiré. Cet État s’applique uniquement à assessmentForCurrent .
UpdateAssessmentStatus _ NotLatestDeferredQuality
l’appareil n’est pas sur la dernière mise à jour de qualité en raison de la Windows Update de l’appareil pour la
stratégie de report de mise à jour de qualité professionnelle. La détermination des daysOutOfDate prend en
compte les stratégies de report. daysOutOfDate ne commence pas à s’incrémenter tant que la période de
report n’a pas expiré.
UpdateAssessmentStatus _ NotLatestPausedFeature
L’appareil n’est pas sur la dernière mise à jour des fonctionnalités, car l’appareil a des mises à jour de
fonctionnalités suspendues. Le fait qu’un appareil soit mis en pause n’est pas pris en compte dans le calcul de
daysOutOfDate . Cet État s’applique uniquement à assessmentForCurrent .
UpdateAssessmentStatus _ NotLatestPausedQuality
L’appareil n’est pas sur la dernière mise à jour de qualité, car l’appareil a des mises à jour qualité suspendues. Le
fait qu’un appareil soit mis en pause n’est pas pris en compte dans le calcul de daysOutOfDate .
daysOutOfDate ne détermine pas si un appareil est mis en pause dans son calcul.
UpdateAssessmentStatus _ NotLatestManaged
l’appareil n’est pas sur la dernière mise à jour, car l’approbation des mises à jour n’est pas effectuée par le biais
de Windows Update.
UpdateAssessmentStatus _ NotLatestUnknown
L’appareil n’est pas sur la dernière mise à jour en raison d’une raison qui ne peut pas être déterminée par
l’évaluation.
UpdateAssessmentStatus _ NotLatestTargetedVersion
l’appareil n’est pas sur la dernière mise à jour des fonctionnalités en raison de la stratégie de Version cible de
l’Windows Update de l’appareil. Cette stratégie conserve l’appareil sur la version de la fonctionnalité ciblée.
Remarques
Cette énumération est utilisée le plus souvent avec les structures UpdateAssessment et
OSUpdateAssessment , qui sont utilisées à leur tour avec la méthode GetOSUpdateAssessment pour
IWaaSAssessor .
Client minimal pris en charge Windows 10, les applications de bureau version 1703 [
uniquement]
Serveur minimal pris en charge Windows Server 2016 [ applications de bureau uniquement]
MIDL
WaaSAPI. idl
Énumération UpdateImpactLevel
Indique un impact élevé, moyen ou faible sur un appareil exécutant un système d’exploitation obsolète. Cette
énumération est généralement utilisée par les structures UpdateAssessment , qui sont à son tour imbriquées
dans le OSUpdateAssessment retourné à partir de GetOSUpdateAssessment .
Syntaxe
typedef enum TagUpdateImpactLevel {
UpdateImpactLevel_None = 0,
UpdateImpactLevel_Low = 1,
UpdateImpactLevel_Medium = 2,
UpdateImpactLevel_High = 3
} UpdateImpactLevel;
Constantes
UpdateImpactLevel _ Aucun
Il n’y a aucun impact prévisible sur votre appareil. Cela peut être dû au fait que l’appareil est à jour ou qu’il n’est
pas à jour, car l’appareil respecte ses Windows Update pour les périodes de report d’entreprise, ou est obsolète,
mais n’a pas encore atteint le seuil daysOutOfDate pour atteindre un niveau d’impact plus élevé.
UpdateImpactLevel _ bas
L’appareil n’exécute pas le système d’exploitation le plus récent, mais dispose d’une mise à jour récente.
UpdateImpactLevel _ Moyenne
L’appareil exécute le système d’exploitation le plus récent, mais une mise à jour est modérément récente.
UpdateImpactLevel _ élevé
L’appareil n’est plus à jour pendant une longue période. Ce périphérique peut présenter des failles de sécurité et
il manque peut-être des correctifs importants qui permettent à Windows de s’exécuter mieux. Quand un appareil
exécute une version de Windows qui n’est plus prise en charge, UpdateImpactLevel _ High est toujours
retourné.
Notes
Quand GetOSUpdateAssessment est appelé, une structure OSUpdateAssessment est retournée. Au sein de
la structure se trouve un assessmentForCurrent et assessmentForUpToDate . Il s’agit de structures
UpdateAssessment . Les deux membres ont une énumération UpdateImpactLevel , qui indique un impact
élevé, moyen, faible ou non pour un appareil exécutant un système d’exploitation obsolète. Ces niveaux sont
déterminés par la valeur de daysOutOfDate .
Client minimal pris en charge Applications de bureau Windows 10, version 1703 [
uniquement]
Serveur minimal pris en charge Applications de bureau Windows Server 2016 [ uniquement]
MIDL
WaaSAPI. idl
Mettre à jour les interfaces d’évaluateur
Les interfaces suivantes sont utilisées par le fournisseur d’accesseurs de mise à jour.
IWaaSAssessor Obtient l’évaluation des mises à jour du système

d’exploitation en comparant la build la plus récente de
Microsoft à la build en cours d’exécution sur l’appareil actuel.

Registre Microsoft Ref

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Registre Microsoft Ref

Transféré par

Droits d'auteur :

Formats disponibles

Contents

Windows System Information

VUE D’EN SEM B L E DESC RIP T IO N

Registre Base de données définie par le système dans laquelle les

Informations système Récupère ou définit la configuration système, les paramètres,

Time Récupère ou définit l’heure système.

Fournisseur de temps Récupère des horodatages précis à partir du matériel ou du

Windows fournit des fonctions qui effectuent les tâches suivantes :

O B JET UT IL ISAT EUR VUE D’EN SEM B L E

Table d’accélérateurs Raccourcis clavier

Signe insertion Signes

Conversation DDE Bibliothèque de gestion des échange dynamique de données

Position de la fenêtre Windows

O B JET GDI VUE D’EN SEM B L E

Bitmap Images bitmap

Métafichier amélioré Métafichiers

Police Polices et texte

Mémoire DC Contextes de périphérique

Stylet et stylet étendu Stylets

O B JET DE N O YA U VUE D’EN SEM B L E

Access token (Jeton d’accès) Contrôle d’accès

Notification de modification Notifications de modification de répertoire

Appareil de communication Communications

Entrée de la console Applications en mode caractère

Mémoire tampon d’écran de la console Applications en mode caractère

Journal des événements Journalisation des événements

Fichier Fichiers et clusters

Mappage de fichiers Mappage de fichiers

Segment de mémoire (heap) Gestion de la mémoire

Travail Objets de traitement

Module Bibliothèques de liens dynamiques

Process Processus et threads

Prise Windows Sockets 2

Thread Processus et threads

File d’attente du minuteur Synchronisation

Minuteur-minuteur de file d’attente Synchronisation

Mettre à jour une ressource Ressources

Station Windows Stations Windows

Handles vers des objets utilisateur

Gestion des objets utilisateur

Table d’accélérateurs CreateAcceleratorTable DestroyAcceleratorTable

Signe insertion CreateCaret DestroyCaret

Curseur CreateCursor , LoadCursor , DestroyCursor

Conversation DDE DdeConnect , DdeConnectList DdeDisconnect ,

Hook SetWindowsHookEx UnhookWindowsHookEx

Icône CreateIconIndirect , LoadIcon , DestroyIcon

Menu CreateMenu , CreatePopupMenu , DestroyMenu

Fenêtre CreateWindow , CreateWindowEx, DestroyWindow

Position de la fenêtre BeginDeferWindowPos EndDeferWindowPos

Gestion des objets GDI

O B JET GDI C REATO R, F O N C T IO N F O N C T IO N DEST RO Y

Bitmap CreateBitmap , DeleteObject

Brush CreateBrushIndirect , DeleteObject

DC CreateDC DeleteDC , ReleaseDC

Métafichier amélioré CreateEnhMetaFile DeleteEnhMetaFile

Enhanced-Metafile DC CreateEnhMetaFile CloseEnhMetaFile

Police CreateFont , CreateFontIndirect DeleteObject

Mémoire DC CreateCompatibleDC DeleteDC

Métafichiers CreateMetaFile DeleteMetaFile

DC de métafichier CreateMetaFile CloseMetaFile

Palette CreatePalette DeleteObject

Stylet et stylet étendu CreatePen , CreatePenIndirect , DeleteObject

Région CombineRgn , CreateEllipticRgn , DeleteObject