Operações do Windows (C++/CLI)

Artigo
04/03/2023

Demonstra várias tarefas específicas do Windows usando o SDK do Windows.

Os tópicos a seguir demonstram várias operações do Windows executadas com o SDK do Windows usando o Visual C++.

Determinar se o desligamento foi iniciado

O exemplo de código a seguir demonstra como determinar se o aplicativo ou o .NET Framework está sendo encerrado no momento. Isso é útil para acessar elementos estáticos no .NET Framework porque, durante o desligamento, esses constructos são finalizados pelo sistema e não podem ser usadas de maneira confiável. Ao verificar a propriedade HasShutdownStarted primeiro, você pode evitar possíveis falhas ao não acessar esses elementos.

Exemplo

// 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;
}

Determinar o estado interativo do usuário

O exemplo de código a seguir demonstra como determinar se o código está sendo executado em um contexto interativo do usuário. Se UserInteractive for falso, o código será executado como um processo de serviço ou de dentro de um aplicativo Web, nesse caso, você não deve tentar interagir com o usuário.

Exemplo

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

int main()
{
   if ( Environment::UserInteractive )
      Console::WriteLine("User interactive");
   else
      Console::WriteLine("Noninteractive");
   return 0;
}

Ler dados do Registro do Windows

O exemplo de código a seguir usa a chave CurrentUser para ler dados do Registro do Windows. Primeiro, as subchaves são enumeradas usando o método GetSubKeyNames e, em seguida, a subchave Identidades é aberta usando o método OpenSubKey. Assim como as chaves raiz, cada subchave é representada pela classe RegistryKey. Por fim, o novo objeto RegistryKey é usado para enumerar os pares chave/valor.

Exemplo

// 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;
}

Comentários

A classe Registry é apenas um contêiner para instâncias estáticas de RegistryKey. Cada instância representa um nó raiz do Registro. As instâncias são ClassesRoot, CurrentConfig, CurrentUser, LocalMachine e Users.

Além de serem estáticos, os objetos dentro da classe Registry são somente leitura. Além disso, as instâncias da classe RegistryKey criadas para acessar o conteúdo dos objetos do Registro também são somente leitura. Para obter um exemplo de como substituir esse comportamento, confira Como gravar dados no Registro do Windows (C++/CLI).

Há dois objetos adicionais na classe Registry: DynData e PerformanceData. Ambos são instâncias da classe RegistryKey. O objeto DynData, que contém informações dinâmicas do Registro, só é compatível com o Windows 98 e o Windows Me. O objeto PerformanceData pode ser usado para acessar informações do contador de desempenho para aplicativos que usam o Sistema de Monitoramento de Desempenho do Windows. O nó PerformanceData representa informações que não são realmente armazenadas no registro e, portanto, não podem ser exibidas usando Regedit.exe.

Ler contadores de desempenho do Windows

Alguns aplicativos e subsistemas do Windows expõem dados de desempenho por meio do sistema de desempenho do Windows. Esses contadores podem ser acessados usando as classes PerformanceCounterCategory e PerformanceCounter, que residem no namespace System.Diagnostics.

O exemplo de código a seguir usa essas classes para recuperar e exibir um contador atualizado pelo Windows para indicar a porcentagem de tempo que o processador está ocupado.

Observação

Esse exemplo exige privilégios administrativos para ser executado no Windows Vista.

Exemplo

// 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;
}

Recupera texto da área de transferência

O exemplo de código a seguir usa a função membro GetDataObject para retornar um ponteiro para a interface IDataObject. Essa interface pode ser consultada para o formato dos dados e usada para recuperar os dados reais.

Exemplo

// 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;
}

Recuperar o nome de usuário atual

O exemplo de código a seguir demonstra a recuperação do nome de usuário atual (o nome do usuário conectado ao Windows). O nome é armazenado na cadeia de caracteres UserName, que é definida no namespace Environment.

Exemplo

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

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

Recuperar a versão do .NET Framework

O exemplo de código a seguir demonstra como determinar a versão do .NET Framework instalada no momento com a propriedade Version, que é um ponteiro para um objeto Version que contém as informações de versão.

Exemplo

// 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;
}

Recuperar o nome do computador local

O exemplo de código a seguir demonstra a recuperação do nome do computador local (o nome do computador como ele aparece em uma rede). Você pode fazer isso obtendo a cadeia de caracteres MachineName, que é definida no namespace Environment.

Exemplo

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

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

Recuperar a versão do Windows

O exemplo de código a seguir demonstra como recuperar as informações de plataforma e versão do sistema operacional atual. Essas informações são armazenadas na propriedade System.Environment.OSVersion e consistem em uma enumeração que descreve a versão do Windows em termos amplos e em um objeto Version que contém o build exato do sistema operacional.

Exemplo

// 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;
}

Recuperar o tempo decorrido desde a inicialização

O exemplo de código a seguir demonstra como determinar a contagem de tiques ou o número de milissegundos decorridos desde que o Windows foi iniciado. Esse valor é armazenado no membro System.Environment.TickCount e, por ser um valor de 32 bits, é redefinido para zero aproximadamente a cada 24,9 dias.

Exemplo

// 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;
}

Armazenar texto na Área de Transferência

O exemplo de código a seguir usa o objeto Clipboard definido no namespace System.Windows.Forms para armazenar uma cadeia de caracteres. Este objeto fornece duas funções membro: SetDataObject e GetDataObject. Os dados são armazenados na Área de Transferência enviando qualquer objeto derivado de Object para SetDataObject.

Exemplo

// 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;
}

Gravar dados no Registro do Windows

O exemplo de código a seguir usa a chave CurrentUser para criar uma instância gravável da classe RegistryKey correspondente à chave de software. Depois, o método CreateSubKey é usado para criar uma chave e adicionar a pares chave/valor.

Exemplo

// 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;
}

Comentários

Você pode usar o .NET Framework para acessar o registro com as classes Registry e RegistryKey, que são definidas no namespace Microsoft.Win32. A classe Registry é um contêiner para instâncias estáticas da classe RegistryKey. Cada instância representa um nó raiz do Registro. As instâncias são ClassesRoot, CurrentConfig, CurrentUser, LocalMachine e Users.

Environment

Confira também

Programação do .NET com C++/CLI (Visual C++)

Compartilhar via

Operações do Windows (C++/CLI)

Determinar se o desligamento foi iniciado

Exemplo

Determinar o estado interativo do usuário

Exemplo

Ler dados do Registro do Windows

Exemplo

Comentários

Ler contadores de desempenho do Windows

Exemplo

Recupera texto da área de transferência

Exemplo

Recuperar o nome de usuário atual

Exemplo

Recuperar a versão do .NET Framework

Exemplo

Recuperar o nome do computador local

Exemplo

Recuperar a versão do Windows

Exemplo

Recuperar o tempo decorrido desde a inicialização

Exemplo

Armazenar texto na Área de Transferência

Exemplo

Gravar dados no Registro do Windows

Exemplo

Comentários

Confira também

Comentários

Recursos adicionais

Compartilhar via

Operações do Windows (C++/CLI)

Determinar se o desligamento foi iniciado

Exemplo

Determinar o estado interativo do usuário

Exemplo

Ler dados do Registro do Windows

Exemplo

Comentários

Ler contadores de desempenho do Windows

Exemplo

Recupera texto da área de transferência

Exemplo

Recuperar o nome de usuário atual

Exemplo

Recuperar a versão do .NET Framework

Exemplo

Recuperar o nome do computador local

Exemplo

Recuperar a versão do Windows

Exemplo

Recuperar o tempo decorrido desde a inicialização

Exemplo

Armazenar texto na Área de Transferência

Exemplo

Gravar dados no Registro do Windows

Exemplo

Comentários

Seções relacionadas

Confira também

Comentários

Recursos adicionais