Opérations Windows (C++/CLI)
Illustre différentes tâches spécifiques à Windows à l’aide du Kit de développement logiciel (SDK) Windows.
Les rubriques suivantes illustrent différentes opérations Windows effectuées avec le Kit de développement logiciel (SDK) Windows à l’aide de Visual C++.
Déterminer si l’arrêt a démarré
L’exemple de code suivant montre comment déterminer si l’application ou le .NET Framework se termine actuellement. Cela est utile pour accéder aux éléments statiques dans .NET Framework, car, pendant l’arrêt, ces constructions sont finalisées par le système et ne peuvent pas être utilisées de manière fiable. En case activée la HasShutdownStarted propriété en premier, vous pouvez éviter les défaillances potentielles en n’accédant pas à ces éléments.
Exemple
// check_shutdown.cpp
// compile with: /clr
using namespace System;
int main()
{
if (Environment::HasShutdownStarted)
Console::WriteLine("Shutting down.");
else
Console::WriteLine("Not shutting down.");
return 0;
}
Déterminer l’état interactif de l’utilisateur
L’exemple de code suivant montre comment déterminer si le code est exécuté dans un contexte interactif utilisateur. Si UserInteractive la valeur est false, le code s’exécute en tant que processus de service ou à partir d’une application web, auquel cas vous ne devez pas tenter d’interagir avec l’utilisateur.
Exemple
// user_interactive.cpp
// compile with: /clr
using namespace System;
int main()
{
if ( Environment::UserInteractive )
Console::WriteLine("User interactive");
else
Console::WriteLine("Noninteractive");
return 0;
}
Lire des données à partir du Registre Windows
L’exemple de code suivant utilise la CurrentUser clé pour lire des données à partir du Registre Windows. Tout d’abord, les sous-clés sont énumérées à l’aide de la GetSubKeyNames méthode, puis la sous-clé Identités est ouverte à l’aide de la OpenSubKey méthode. Comme les clés racine, chaque sous-clé est représentée par la RegistryKey classe. Enfin, le nouvel RegistryKey objet est utilisé pour énumérer les paires clé/valeur.
Exemple
// registry_read.cpp
// compile with: /clr
using namespace System;
using namespace Microsoft::Win32;
int main( )
{
array<String^>^ key = Registry::CurrentUser->GetSubKeyNames( );
Console::WriteLine("Subkeys within CurrentUser root key:");
for (int i=0; i<key->Length; i++)
{
Console::WriteLine(" {0}", key[i]);
}
Console::WriteLine("Opening subkey 'Identities'...");
RegistryKey^ rk = nullptr;
rk = Registry::CurrentUser->OpenSubKey("Identities");
if (rk==nullptr)
{
Console::WriteLine("Registry key not found - aborting");
return -1;
}
Console::WriteLine("Key/value pairs within 'Identities' key:");
array<String^>^ name = rk->GetValueNames( );
for (int i=0; i<name->Length; i++)
{
String^ value = rk->GetValue(name[i])->ToString();
Console::WriteLine(" {0} = {1}", name[i], value);
}
return 0;
}
Notes
La Registry classe est simplement un conteneur pour les instances statiques de RegistryKey. Chaque instance représente un nœud de Registre racine. Les instances sont ClassesRoot, , CurrentUserCurrentConfig, LocalMachine, et Users.
En plus d’être statiques, les objets de la Registry classe sont en lecture seule. En outre, les instances de la RegistryKey classe créées pour accéder au contenu des objets de Registre sont également en lecture seule. Pour obtenir un exemple de remplacement de ce comportement, consultez Guide pratique pour écrire des données dans le Registre Windows (C++/CLI).
Il existe deux objets supplémentaires dans la Registry classe : DynData et PerformanceData. Les deux sont des instances de la RegistryKey classe. L’objet DynData contient des informations de Registre dynamiques, qui sont uniquement prises en charge dans Windows 98 et Windows Me. L’objet PerformanceData peut être utilisé pour accéder aux informations du compteur de performances pour les applications qui utilisent le système windows Analyseur de performances ing. Le PerformanceData nœud représente des informations qui ne sont pas réellement stockées dans le Registre et ne peuvent donc pas être consultées à l’aide de Regedit.exe.
Lire les compteurs de performances Windows
Certaines applications et sous-systèmes Windows exposent des données de performances via le système de performances Windows. Ces compteurs sont accessibles à l’aide des classes et PerformanceCounter des PerformanceCounterCategory classes qui résident dans l’espace System.Diagnostics de noms.
L’exemple de code suivant utilise ces classes pour récupérer et afficher un compteur mis à jour par Windows pour indiquer le pourcentage de temps occupé par le processeur.
Remarque
L’exécution de cet exemple sur Windows Vista nécessite des privilèges d’administrateur.
Exemple
// processor_timer.cpp
// compile with: /clr
#using <system.dll>
using namespace System;
using namespace System::Threading;
using namespace System::Diagnostics;
using namespace System::Timers;
ref struct TimerObject
{
public:
static String^ m_instanceName;
static PerformanceCounter^ m_theCounter;
public:
static void OnTimer(Object^ source, ElapsedEventArgs^ e)
{
try
{
Console::WriteLine("CPU time used: {0,6} ",
m_theCounter->NextValue( ).ToString("f"));
}
catch(Exception^ e)
{
if (dynamic_cast<InvalidOperationException^>(e))
{
Console::WriteLine("Instance '{0}' does not exist",
m_instanceName);
return;
}
else
{
Console::WriteLine("Unknown exception... ('q' to quit)");
return;
}
}
}
};
int main()
{
String^ objectName = "Processor";
String^ counterName = "% Processor Time";
String^ instanceName = "_Total";
try
{
if ( !PerformanceCounterCategory::Exists(objectName) )
{
Console::WriteLine("Object {0} does not exist", objectName);
return -1;
}
}
catch (UnauthorizedAccessException ^ex)
{
Console::WriteLine("You are not authorized to access this information.");
Console::Write("If you are using Windows Vista, run the application with ");
Console::WriteLine("administrative privileges.");
Console::WriteLine(ex->Message);
return -1;
}
if ( !PerformanceCounterCategory::CounterExists(
counterName, objectName) )
{
Console::WriteLine("Counter {0} does not exist", counterName);
return -1;
}
TimerObject::m_instanceName = instanceName;
TimerObject::m_theCounter = gcnew PerformanceCounter(
objectName, counterName, instanceName);
System::Timers::Timer^ aTimer = gcnew System::Timers::Timer();
aTimer->Elapsed += gcnew ElapsedEventHandler(&TimerObject::OnTimer);
aTimer->Interval = 1000;
aTimer->Enabled = true;
aTimer->AutoReset = true;
Console::WriteLine("reporting CPU usage for the next 10 seconds");
Thread::Sleep(10000);
return 0;
}
Récupérer du texte à partir du Presse-papiers
L’exemple de code suivant utilise la GetDataObject fonction membre pour retourner un pointeur vers l’interface IDataObject . Cette interface peut ensuite être interrogée pour le format des données et utilisée pour récupérer les données réelles.
Exemple
// read_clipboard.cpp
// compile with: /clr
#using <system.dll>
#using <system.Drawing.dll>
#using <system.windows.forms.dll>
using namespace System;
using namespace System::Windows::Forms;
[STAThread] int main( )
{
IDataObject^ data = Clipboard::GetDataObject( );
if (data)
{
if (data->GetDataPresent(DataFormats::Text))
{
String^ text = static_cast<String^>
(data->GetData(DataFormats::Text));
Console::WriteLine(text);
}
else
Console::WriteLine("Nontext data is in the Clipboard.");
}
else
{
Console::WriteLine("No data was found in the Clipboard.");
}
return 0;
}
Récupérer le nom d’utilisateur actuel
L’exemple de code suivant illustre la récupération du nom d’utilisateur actuel (le nom de l’utilisateur connecté à Windows). Le nom est stocké dans la UserName chaîne, qui est définie dans l’espace Environment de noms.
Exemple
// username.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nCurrent user: {0}", Environment::UserName);
return 0;
}
Récupérer la version du .NET Framework
L’exemple de code suivant montre comment déterminer la version du .NET Framework actuellement installé avec la Version propriété, qui est un pointeur vers un Version objet qui contient les informations de version.
Exemple
// dotnet_ver.cpp
// compile with: /clr
using namespace System;
int main()
{
Version^ version = Environment::Version;
if (version)
{
int build = version->Build;
int major = version->Major;
int minor = version->Minor;
int revision = Environment::Version->Revision;
Console::Write(".NET Framework version: ");
Console::WriteLine("{0}.{1}.{2}.{3}",
build, major, minor, revision);
}
return 0;
}
Récupérer le nom de l’ordinateur local
L’exemple de code suivant illustre la récupération du nom de l’ordinateur local (nom de l’ordinateur tel qu’il apparaît sur un réseau). Pour ce faire, vous pouvez obtenir la MachineName chaîne, qui est définie dans l’espace Environment de noms.
Exemple
// machine_name.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nMachineName: {0}", Environment::MachineName);
return 0;
}
Récupérer la version de Windows
L’exemple de code suivant montre comment récupérer les informations de plateforme et de version du système d’exploitation actuel. Ces informations sont stockées dans la System.Environment.OSVersion propriété et se composent d’une énumération qui décrit la version de Windows en termes généraux et un Version objet qui contient la build exacte du système d’exploitation.
Exemple
// os_ver.cpp
// compile with: /clr
using namespace System;
int main()
{
OperatingSystem^ osv = Environment::OSVersion;
PlatformID id = osv->Platform;
Console::Write("Operating system: ");
if (id == PlatformID::Win32NT)
Console::WriteLine("Win32NT");
else if (id == PlatformID::Win32S)
Console::WriteLine("Win32S");
else if (id == PlatformID::Win32Windows)
Console::WriteLine("Win32Windows");
else
Console::WriteLine("WinCE");
Version^ version = osv->Version;
if (version)
{
int build = version->Build;
int major = version->Major;
int minor = version->Minor;
int revision = Environment::Version->Revision;
Console::Write("OS Version: ");
Console::WriteLine("{0}.{1}.{2}.{3}",
build, major, minor, revision);
}
return 0;
}
Récupérer le temps écoulé depuis le démarrage
L’exemple de code suivant montre comment déterminer le nombre de graduations ou le nombre de millisecondes écoulées depuis le démarrage de Windows. Cette valeur est stockée dans le System.Environment.TickCount membre et, comme il s’agit d’une valeur 32 bits, est réinitialisée à zéro toutes les 24,9 jours environ.
Exemple
// startup_time.cpp
// compile with: /clr
using namespace System;
int main( )
{
Int32 tc = Environment::TickCount;
Int32 seconds = tc / 1000;
Int32 minutes = seconds / 60;
float hours = static_cast<float>(minutes) / 60;
float days = hours / 24;
Console::WriteLine("Milliseconds since startup: {0}", tc);
Console::WriteLine("Seconds since startup: {0}", seconds);
Console::WriteLine("Minutes since startup: {0}", minutes);
Console::WriteLine("Hours since startup: {0}", hours);
Console::WriteLine("Days since startup: {0}", days);
return 0;
}
Stocker du texte dans le Presse-papiers
L’exemple de code suivant utilise l’objet Clipboard défini dans l’espace System.Windows.Forms de noms pour stocker une chaîne. Cet objet fournit deux fonctions membres : SetDataObject et GetDataObject. Les données sont stockées dans le Presse-papiers en envoyant tout objet dérivé de Object .SetDataObject
Exemple
// store_clipboard.cpp
// compile with: /clr
#using <System.dll>
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::Windows::Forms;
[STAThread] int main()
{
String^ str = "This text is copied into the Clipboard.";
// Use 'true' as the second argument if
// the data is to remain in the clipboard
// after the program terminates.
Clipboard::SetDataObject(str, true);
Console::WriteLine("Added text to the Clipboard.");
return 0;
}
Écrire des données dans le Registre Windows
L’exemple de code suivant utilise la CurrentUser clé pour créer une instance accessible en écriture de la RegistryKey classe correspondant à la clé logicielle . La CreateSubKey méthode est ensuite utilisée pour créer une clé et ajouter à des paires clé/valeur.
Exemple
// registry_write.cpp
// compile with: /clr
using namespace System;
using namespace Microsoft::Win32;
int main()
{
// The second OpenSubKey argument indicates that
// the subkey should be writable.
RegistryKey^ rk;
rk = Registry::CurrentUser->OpenSubKey("Software", true);
if (!rk)
{
Console::WriteLine("Failed to open CurrentUser/Software key");
return -1;
}
RegistryKey^ nk = rk->CreateSubKey("NewRegKey");
if (!nk)
{
Console::WriteLine("Failed to create 'NewRegKey'");
return -1;
}
String^ newValue = "NewValue";
try
{
nk->SetValue("NewKey", newValue);
nk->SetValue("NewKey2", 44);
}
catch (Exception^)
{
Console::WriteLine("Failed to set new values in 'NewRegKey'");
return -1;
}
Console::WriteLine("New key created.");
Console::Write("Use REGEDIT.EXE to verify ");
Console::WriteLine("'CURRENTUSER/Software/NewRegKey'\n");
return 0;
}
Notes
Vous pouvez utiliser .NET Framework pour accéder au Registre avec les classes et RegistryKey les Registry classes définies dans l’espace Microsoft.Win32 de noms. La classe Registry est un conteneur pour les instances statiques de la RegistryKey classe. Chaque instance représente un nœud de Registre racine. Les instances sont ClassesRoot, , CurrentUserCurrentConfig, LocalMachine, et Users.
Sections connexes
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour