Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
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 os conteúdos dos objetos de 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 ticks 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 ao enviar 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.