Operacje związane z systemem Windows (C++/CLI)
Demonstruje różne zadania specyficzne dla systemu Windows przy użyciu zestawu Windows SDK.
W poniższych tematach przedstawiono różne operacje systemu Windows wykonywane za pomocą zestawu Windows SDK przy użyciu języka Visual C++.
Ustal, czy zamknięcie zostało uruchomione
W poniższym przykładzie kodu pokazano, jak określić, czy aplikacja, czy program .NET Framework jest obecnie przerywany. Jest to przydatne w przypadku uzyskiwania dostępu do elementów statycznych w programie .NET Framework, ponieważ podczas zamykania te konstrukcje są finalizowane przez system i nie mogą być niezawodnie używane. Najpierw sprawdzając HasShutdownStarted właściwość, można uniknąć potencjalnych awarii, nie korzystając z tych elementów.
Przykład
// 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;
}
Określanie stanu interakcyjnego użytkownika
W poniższym przykładzie kodu pokazano, jak określić, czy kod jest uruchamiany w kontekście interakcyjnym użytkownika. Jeśli UserInteractive jest to fałsz, kod jest uruchamiany jako proces usługi lub z wewnątrz aplikacji internetowej, w tym przypadku nie należy próbować wchodzić w interakcję z użytkownikiem.
Przykład
// user_interactive.cpp
// compile with: /clr
using namespace System;
int main()
{
if ( Environment::UserInteractive )
Console::WriteLine("User interactive");
else
Console::WriteLine("Noninteractive");
return 0;
}
Odczytywanie danych z rejestru systemu Windows
Poniższy przykład kodu używa CurrentUser klucza do odczytywania danych z rejestru systemu Windows. Najpierw podklucze GetSubKeyNames są wyliczane przy użyciu metody , a następnie podklucz OpenSubKey Tożsamości jest otwierany przy użyciu metody . Podobnie jak klucze główne, każdy podklucz jest reprezentowany przez klasę RegistryKey . Na koniec nowy RegistryKey obiekt służy do wyliczania par klucz/wartość.
Przykład
// 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;
}
Uwagi
Klasa Registry jest tylko kontenerem dla statycznych wystąpień RegistryKeyklasy . Każde wystąpienie reprezentuje węzeł rejestru głównego. Wystąpienia to ClassesRoot, , CurrentConfigCurrentUser, , LocalMachinei Users.
Poza statycznym obiektami w Registry klasie są tylko do odczytu. Ponadto wystąpienia RegistryKey klasy, które są tworzone w celu uzyskania dostępu do zawartości obiektów rejestru, są również tylko do odczytu. Aby zapoznać się z przykładem zastępowania tego zachowania, zobacz How to: Write Data to the Windows Registry (C++/CLI) (Instrukcje: zapisywanie danych w rejestrze systemu Windows (C++/CLI).
W klasie znajdują się dwa dodatkowe obiekty Registry : DynData i PerformanceData. Oba są wystąpieniami RegistryKey klasy . Obiekt DynData zawiera informacje o rejestrze dynamicznym, które są obsługiwane tylko w systemach Windows 98 i Windows Me. Obiekt może służyć do uzyskiwania PerformanceData dostępu do informacji licznika wydajności dla aplikacji korzystających z systemu Windows monitor wydajności ing System. Węzeł PerformanceData reprezentuje informacje, które nie są rzeczywiście przechowywane w rejestrze i dlatego nie można go wyświetlić przy użyciu pliku Regedit.exe.
Odczytywanie liczników wydajności systemu Windows
Niektóre aplikacje i podsystemy systemu Windows uwidaczniają dane dotyczące wydajności w systemie wydajności systemu Windows. Dostęp do tych liczników można uzyskać przy użyciu PerformanceCounterCategory klas i PerformanceCounter , które znajdują się w System.Diagnostics przestrzeni nazw.
Poniższy przykład kodu używa tych klas do pobierania i wyświetlania licznika zaktualizowanego przez system Windows w celu wskazania procentu czasu zajętego procesora.
Uwaga
W tym przykładzie wymagane są uprawnienia administracyjne do uruchamiania w systemie Windows Vista.
Przykład
// 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;
}
Pobieranie tekstu ze Schowka
Poniższy przykład kodu używa funkcji składowej GetDataObject , aby zwrócić wskaźnik do interfejsu IDataObject . Następnie można wykonać zapytanie o format danych i użyć go do pobrania rzeczywistych danych.
Przykład
// 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;
}
Pobieranie bieżącej nazwy użytkownika
W poniższym przykładzie kodu pokazano pobieranie bieżącej nazwy użytkownika (nazwa zalogowanego użytkownika do systemu Windows). Nazwa jest przechowywana w UserName ciągu zdefiniowanym Environment w przestrzeni nazw.
Przykład
// username.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nCurrent user: {0}", Environment::UserName);
return 0;
}
Pobieranie wersji programu .NET Framework
Poniższy przykład kodu pokazuje, jak określić wersję aktualnie zainstalowanego programu .NET Framework z Version właściwością, która jest wskaźnikiem do Version obiektu zawierającego informacje o wersji.
Przykład
// 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;
}
Pobieranie nazwy komputera lokalnego
W poniższym przykładzie kodu pokazano pobieranie nazwy komputera lokalnego (nazwa komputera wyświetlana w sieci). Można to zrobić, uzyskując MachineName ciąg zdefiniowany w Environment przestrzeni nazw.
Przykład
// machine_name.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nMachineName: {0}", Environment::MachineName);
return 0;
}
Pobieranie wersji systemu Windows
Poniższy przykład kodu przedstawia sposób pobierania informacji o platformie i wersji bieżącego systemu operacyjnego. Te informacje są przechowywane we System.Environment.OSVersion właściwości i składają się z wyliczenia opisującego wersję systemu Windows w szerokim zakresie i Version obiekt zawierający dokładną kompilację systemu operacyjnego.
Przykład
// 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;
}
Pobieranie czasu, który upłynął od uruchomienia
Poniższy przykład kodu pokazuje, jak określić liczbę znaczników lub liczbę milisekund, które upłynęły od czasu uruchomienia systemu Windows. Ta wartość jest przechowywana w elemencie System.Environment.TickCount członkowskim i, ponieważ jest to wartość 32-bitowa, resetuje się do zera około co 24,9 dni.
Przykład
// 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;
}
Przechowywanie tekstu w Schowku
Poniższy przykład kodu używa obiektu zdefiniowanego ClipboardSystem.Windows.Forms w przestrzeni nazw do przechowywania ciągu. Ten obiekt udostępnia dwie funkcje składowe: SetDataObject i GetDataObject. Dane są przechowywane w Schowku przez wysłanie dowolnego obiektu pochodzącego z Object do SetDataObject.
Przykład
// 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;
}
Zapisywanie danych w rejestrze systemu Windows
Poniższy przykład kodu używa CurrentUser klucza do utworzenia zapisywalnego wystąpienia RegistryKey klasy odpowiadającej kluczowi oprogramowania . Metoda CreateSubKey jest następnie używana do tworzenia nowego klucza i dodawania do par klucz/wartość.
Przykład
// 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;
}
Uwagi
Możesz użyć programu .NET Framework, aby uzyskać dostęp do rejestru za pomocą Registry klas i RegistryKey , które są zdefiniowane w Microsoft.Win32 przestrzeni nazw. Klasa Registry jest kontenerem dla statycznych wystąpień RegistryKey klasy. Każde wystąpienie reprezentuje węzeł rejestru głównego. Wystąpienia to ClassesRoot, , CurrentConfigCurrentUser, , LocalMachinei Users.
Sekcje pokrewne
Zobacz też
Programowanie .NET w języku C++/interfejsie wiersza polecenia (Visual C++)
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla