Operacje związane z systemem Windows (C++/CLI)

Artykuł
08/08/2022
Czas czytania: 7 min

Demonstruje różne Windows zadań przy użyciu zestawu WINDOWS SDK.

W poniższych tematach przedstawiono różne Windows operacji wykonywanych za pomocą zestawu SDK Windows przy użyciu Visual C++.

Ustalanie, czy rozpoczęto zamykanie

Poniższy przykład kodu pokazuje, jak określić, czy aplikacja lub .NET Framework obecnie kończy. Jest to przydatne w przypadku uzyskiwania dostępu do elementów statycznych w .NET Framework, ponieważ podczas zamykania te konstrukcje są finalizowane przez system i nie mogą być niezawodnie używane. Sprawdzając najpierw HasShutdownStarted właściwość, można uniknąć potencjalnych błędów, nie mając dostępu do 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 interaktywnego użytkownika

Poniższy przykład kodu pokazuje, jak określić, czy kod jest uruchamiany w kontekście interaktywnym użytkownika. Jeśli UserInteractive wartość to false, kod jest uruchomiony jako proces usługi lub wewnątrz aplikacji internetowej. W takim przypadku nie należy próbować wchodzić w interakcje 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 Windows rejestru

W poniższym przykładzie kodu klucz CurrentUser jest używany do odczytywania danych Windows rejestru. Najpierw podklucze są wyliczane przy GetSubKeyNames użyciu metody , a następnie podklucz Tożsamości jest otwierany przy użyciu OpenSubKey metody . Podobnie jak klucze główne, każdy podklucz jest reprezentowany przez klasę RegistryKey . Na koniec nowy obiekt RegistryKey jest używany 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ń klasy RegistryKey. Każde wystąpienie reprezentuje główny węzeł rejestru. Wystąpienia to ClassesRoot, , CurrentConfig CurrentUser, LocalMachine, i Users.

Oprócz statyczności obiekty w klasie Registry są tylko do odczytu. Ponadto wystąpienia klasy RegistryKey tworzone w celu uzyskania dostępu do zawartości obiektów rejestru są również tylko do odczytu. Aby uzyskać przykład sposobu zastępowania tego zachowania, zobacz How to: Write Data to the Windows Registry (C++/CLI).

Klasa ma dwa dodatkowe obiekty Registry : DynData i PerformanceData. Oba są wystąpieniami RegistryKey klasy . Obiekt DynData zawiera dynamiczne informacje rejestru, które są obsługiwane tylko w Windows 98 i Windows Mnie. Obiekt PerformanceData może służyć do uzyskiwania dostępu do informacji o liczniku wydajności dla aplikacji, które korzystają Windows systemu monitorowania wydajności. Węzeł PerformanceData reprezentuje informacje, które nie są w rzeczywistości przechowywane w rejestrze i dlatego nie mogą być przeglądane przy użyciu Regedit.exe.

Odczytywanie Windows wydajności

Niektóre aplikacje i Windows uwidoczniają dane wydajności za pośrednictwem Windows wydajności. Te liczniki są dostępne przy użyciu klas PerformanceCounterCategory i PerformanceCounter , które znajdują się w przestrzeni System.Diagnostics nazw .

W poniższym przykładzie kodu te klasy są używane do pobierania i wyświetlania licznika, który jest aktualizowany przez Windows, aby wskazać wartość procentową czasu zajętego procesora.

Uwaga

Ten przykład wymaga uprawnień administracyjnych do uruchomienia na 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

W poniższym przykładzie kodu użyto funkcji GetDataObject członkowskiej , aby zwrócić wskaźnik do IDataObject interfejsu. Ten interfejs może być następnie zapytanie o format danych i używany do pobierania 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 (nazwy użytkownika zalogowanego do Windows). Nazwa jest przechowywana w ciągu UserName , który jest zdefiniowany w przestrzeni nazw Environment .

Przykład

// username.cpp
// compile with: /clr
using namespace System;

int main()
{
   Console::WriteLine("\nCurrent user: {0}", Environment::UserName);
   return 0;
}

Pobieranie .NET Framework wersji

W poniższym przykładzie kodu Version pokazano, jak określić wersję aktualnie zainstalowanego .NET Framework za pomocą właściwości , Version która jest wskaźnikiem do obiektu, który zawiera 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). W tym celu można uzyskać ciąg MachineName , który jest zdefiniowany w przestrzeni Environment nazw .

Przykład

// machine_name.cpp
// compile with: /clr
using namespace System;

int main()
{
   Console::WriteLine("\nMachineName: {0}", Environment::MachineName);
   return 0;
}

Pobieranie Windows wersji

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 obejmują wyliczenie opisujące ogólnie wersję programu Windows Version oraz obiekt, który zawiera 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

W poniższym przykładzie kodu pokazano, jak określić liczbę znaczników lub liczbę milisekund, które upłynęły od Windows startu. Ta wartość jest przechowywana w System.Environment.TickCount składowej i, ponieważ jest to wartość 32-bitowa, jest resetowana do zera co około 24,9 dnia.

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 Clipboard w przestrzeni nazw System.Windows.Forms do przechowywania ciągu. Ten obiekt zawiera dwie funkcje członkowskie: SetDataObject i GetDataObject. Dane są przechowywane w schowku przez wysłanie dowolnego obiektu pochodnego z klasy do Object klasy 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;
}

Zapis danych w Windows rejestru

W poniższym przykładzie kodu klucz CurrentUser jest używany RegistryKey do tworzenia zapisywalnych wystąpień klasy odpowiadających kluczowi oprogramowania. Następnie CreateSubKey metoda jest używana do utworzenia nowego klucza i dodania go 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

Aby uzyskać dostęp do .NET Framework Registry z klasami i RegistryKey , które są zdefiniowane w przestrzeni nazw Microsoft.Win32 , można użyć klucza . Klasa Registry jest kontenerem dla statycznych wystąpień RegistryKey klasy . Każde wystąpienie reprezentuje główny węzeł rejestru. Wystąpienia to ClassesRoot, , CurrentConfig CurrentUser, LocalMachine, i Users.

Environment

Zobacz też

Programowanie .NET w języku C++/interfejsie wiersza polecenia (Visual C++)

Operacje związane z systemem Windows (C++/CLI)

Ustalanie, czy rozpoczęto zamykanie

Przykład

Określanie stanu interaktywnego użytkownika

Przykład

Odczytywanie danych z Windows rejestru

Przykład

Uwagi

Odczytywanie Windows wydajności

Przykład

Pobieranie tekstu ze schowka

Przykład

Pobieranie bieżącej nazwy użytkownika

Przykład

Pobieranie .NET Framework wersji

Przykład

Pobieranie nazwy komputera lokalnego

Przykład

Pobieranie Windows wersji

Przykład

Pobieranie czasu, który upłynął od uruchomienia

Przykład

Przechowywanie tekstu w schowku

Przykład

Zapis danych w Windows rejestru

Przykład

Uwagi

Sekcje pokrewne

Zobacz też