Windows-Vorgänge (C++/CLI)
Veranschaulicht verschiedene Windows-spezifische Aufgaben mithilfe des Windows SDK.
Die folgenden Themen veranschaulichen verschiedene Windows-Vorgänge, die mit dem Windows SDK mit Visual C++ ausgeführt werden.
Ermitteln, ob das Herunterfahren gestartet wurde
Im folgenden Codebeispiel wird veranschaulicht, wie sie bestimmen können, ob die Anwendung oder das .NET Framework derzeit beendet wird. Dies ist nützlich für den Zugriff auf statische Elemente im .NET Framework, da diese Konstrukte während des Herunterfahrens vom System abgeschlossen und nicht zuverlässig verwendet werden können. Indem Sie die HasShutdownStarted Eigenschaft zuerst überprüfen, können Sie potenzielle Fehler vermeiden, indem Sie nicht auf diese Elemente zugreifen.
Beispiel
// 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;
}
Bestimmen des interaktiven Benutzerstatus
Im folgenden Codebeispiel wird veranschaulicht, wie Sie bestimmen können, ob Code in einem interaktiven Kontext ausgeführt wird. Ist UserInteractive "false", wird der Code als Dienstprozess oder in einer Webanwendung ausgeführt, in diesem Fall sollten Sie nicht versuchen, mit dem Benutzer zu interagieren.
Beispiel
// user_interactive.cpp
// compile with: /clr
using namespace System;
int main()
{
if ( Environment::UserInteractive )
Console::WriteLine("User interactive");
else
Console::WriteLine("Noninteractive");
return 0;
}
Lesen von Daten aus der Windows-Registrierung
Im folgenden Codebeispiel wird der CurrentUser-Schlüssel verwendet, um Daten aus der Windows-Registrierung zu lesen. Zuerst werden die Unterschlüssel mithilfe der GetSubKeyNames Methode aufgezählt, und dann wird der Unterschlüssel "Identitäten" mit der OpenSubKey Methode geöffnet. Jeder Unterschlüssel wird wie ein Stammschlüssel durch die RegistryKey-Klasse dargestellt. Schließlich werden mit dem neuen RegistryKey-Objekt die Schlüssel/Wert-Paare aufgelistet.
Beispiel
// 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;
}
Hinweise
Die Registry-Klasse ist lediglich ein Container für statische Instanzen von RegistryKey. Jede Instanz stellt einen Stammregistrierungsknoten dar. Die Instanzen sind ClassesRoot, CurrentConfig, CurrentUser, LocalMachine und Users.
Die Objekte innerhalb der Registry-Klasse sind nicht nur statisch, sondern auch schreibgeschützt. Darüber hinaus sind Instanzen der RegistryKey-Klasse, die für den Zugriff auf den Inhalt der Registrierungsobjekte erstellt wurden, ebenfalls schreibgeschützt. Ein Beispiel zum Überschreiben dieses Verhaltens finden Sie unter How to: Write Data to the Windows Registry (C++/CLI).
In der Registry-Klasse stehen zwei weitere Objekte zur Verfügung: DynData und PerformanceData. Bei beiden Objekten handelt es sich um Instanzen der RegistryKey-Klasse. Das DynData Objekt enthält dynamische Registrierungsinformationen, die nur in Windows 98 und Windows Me unterstützt werden. Das PerformanceData-Objekt dient dem Zugriff auf Informationen zu Leistungsindikatoren für Anwendungen, die das Leistungsüberwachungssystem von Windows verwenden. Der PerformanceData Knoten stellt Informationen dar, die nicht tatsächlich in der Registrierung gespeichert sind und daher nicht mit Regedit.exe angezeigt werden können.
Lesen von Windows-Leistungsindikatoren
Einige Anwendungen und Windows-Subsysteme machen Leistungsdaten über das Windows-Leistungssystem verfügbar. Auf diese Leistungsindikatoren kann mithilfe der PerformanceCounterCategory Klassen zugegriffen PerformanceCounter werden, die System.Diagnostics sich im Namespace befinden.
Im folgenden Codebeispiel werden diese Klassen verwendet, um einen Zähler abzurufen und anzuzeigen, der von Windows aktualisiert wird, um den Prozentsatz der Zeit anzugeben, in der der Prozessor ausgelastet ist.
Hinweis
Für dieses Beispiel benötigen Sie Administratorrechte, um es unter Windows Vista auszuführen.
Beispiel
// 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;
}
Abrufen von Text aus der Zwischenablage
Im folgenden Codebeispiel wird die GetDataObject Memberfunktion verwendet, um einen Zeiger auf die IDataObject Schnittstelle zurückzugeben. Diese Schnittstelle kann dann für das Format der Daten abgefragt und zum Abrufen der tatsächlichen Daten verwendet werden.
Beispiel
// 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;
}
Abrufen des aktuellen Benutzernamens
Im folgenden Codebeispiel wird der Abruf des aktuellen Benutzernamens (der Name des bei Windows angemeldeten Benutzers) veranschaulicht. Der Name wird in der UserName Zeichenfolge gespeichert, die Environment im Namespace definiert ist.
Beispiel
// username.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nCurrent user: {0}", Environment::UserName);
return 0;
}
Abrufen der .NET Framework-Version
Im folgenden Codebeispiel wird veranschaulicht, wie Sie die Version der aktuell installierten .NET Framework-Eigenschaft ermitteln, bei der Version es sich um einen Zeiger auf ein Version Objekt handelt, das die Versionsinformationen enthält.
Beispiel
// 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;
}
Abrufen des Lokalen Computernamens
Im folgenden Codebeispiel wird der Abruf des lokalen Computernamens (der Name des Computers, wie er in einem Netzwerk angezeigt wird) veranschaulicht. Sie können dies erreichen, indem Sie die MachineName Zeichenfolge abrufen, die Environment im Namespace definiert ist.
Beispiel
// machine_name.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nMachineName: {0}", Environment::MachineName);
return 0;
}
Abrufen der Windows-Version
Im folgenden Codebeispiel wird veranschaulicht, wie die Plattform- und Versionsinformationen des aktuellen Betriebssystems abgerufen werden. Diese Informationen werden in der System.Environment.OSVersion Eigenschaft gespeichert und bestehen aus einer Aufzählung, die die Version von Windows allgemein und ein Version Objekt beschreibt, das den genauen Build des Betriebssystems enthält.
Beispiel
// 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;
}
Seit dem Start verstrichene Zeit abrufen
Im folgenden Codebeispiel wird veranschaulicht, wie die Anzahl der Teilstriche oder die Anzahl von Millisekunden ermittelt wird, die seit dem Start von Windows verstrichen sind. Dieser Wert wird im System.Environment.TickCount Element gespeichert, und da es sich um einen 32-Bit-Wert handelt, wird ungefähr alle 24,9 Tage auf Null zurückgesetzt.
Beispiel
// 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;
}
Speichern von Text in der Zwischenablage
Im folgenden Codebeispiel wird das Clipboard im System.Windows.Forms Namespace definierte Objekt verwendet, um eine Zeichenfolge zu speichern. Dieses Objekt stellt zwei Memberfunktionen bereit: SetDataObject und GetDataObject. Daten werden in der Zwischenablage gespeichert, indem jedes objekt gesendet wird, das von Object diesem SetDataObjectabgeleitet wird.
Beispiel
// 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;
}
Schreiben von Daten in die Windows-Registrierung
Im folgenden Codebeispiel wird der CurrentUser Schlüssel verwendet, um eine schreibbare Instanz der Klasse zu erstellen, die RegistryKey dem Softwareschlüssel entspricht. Anschließend wird die CreateSubKey-Methode verwendet, um einen neuen Schlüssel zu erstellen und Schlüssel/Wert-Paare hinzuzufügen.
Beispiel
// 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;
}
Hinweise
Sie können .NET Framework verwenden, um auf die Registrierung mit den klassen RegistryKey zuzugreifen, die Registry beide im Microsoft.Win32 Namespace definiert sind. Die Registrierungsklasse ist ein Container für statische Instanzen der RegistryKey Klasse. Jede Instanz stellt einen Stammregistrierungsknoten dar. Die Instanzen sind ClassesRoot, CurrentConfig, CurrentUser, LocalMachine und Users.
Verwandte Abschnitte
Siehe auch
.NET Programming with C++/CLI (Visual C++) (.NET-Programmierung mit C++/CLI (Visual C++))