Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. 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 se iniciou
O exemplo de código a seguir demonstra como determinar se o aplicativo ou o .NET Framework está terminando no momento. Isso é útil para acessar elementos estáticos no .NET Framework porque, durante o desligamento, essas construções são finalizadas pelo sistema e não podem ser usadas de forma confiável. Ao verificar a HasShutdownStarted propriedade 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 está sendo executado como um processo de serviço ou de dentro de um aplicativo Web, caso em que 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 CurrentUser chave para ler dados do registro do Windows. Primeiro, as subchaves são enumeradas usando o GetSubKeyNames método e, em seguida, a subchave Identities é aberta usando o OpenSubKey método. Como as chaves raiz, cada subchave é representada pela RegistryKey classe. Finalmente, o novo RegistryKey objeto é 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;
}
Observações
A Registry classe é meramente um contêiner para instâncias estáticas de RegistryKey. Cada instância representa um nó de registro raiz. As instâncias são ClassesRoot, CurrentConfig, CurrentUser, LocalMachine, e Users.
Além de serem estáticos, os objetos dentro da Registry classe são somente leitura. Além disso, instâncias da classe RegistryKey que são criadas para aceder ao conteúdo dos objetos do registo também são apenas de leitura. Para obter um exemplo de como substituir esse comportamento, consulte Como gravar dados no Registro do Windows (C++/CLI).
Há dois objetos adicionais na Registry classe: DynData e PerformanceData. Ambos são instâncias da RegistryKey classe. O DynData objeto contém informações de registro dinâmico, que só é suportado no Windows 98 e Windows Me. O PerformanceData objeto pode ser usado para acessar informações do contador de desempenho para aplicativos que usam o Sistema de Monitoramento de Desempenho do Windows. O PerformanceData nó representa informações que não são realmente armazenadas no registro e, portanto, não podem ser visualizadas 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 PerformanceCounterCategory classes e PerformanceCounter , que residem no System.Diagnostics namespace.
O exemplo de código a seguir usa essas classes para recuperar e exibir um contador que é atualizado pelo Windows para indicar a porcentagem de tempo que o processador está ocupado.
Observação
Este exemplo requer 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;
}
Recuperar 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. Esta interface pode então 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 UserName cadeia de caracteres, que é definida no Environment namespace.
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 atualmente instalado com a Version propriedade, que é um ponteiro para um Version objeto 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 da máquina local (o nome do computador como ele aparece em uma rede). Você pode fazer isso obtendo a MachineName cadeia de caracteres, que é definida no Environment namespace.
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 e consistem em System.Environment.OSVersion uma enumeração que descreve a versão do Windows em termos amplos e um Version objeto que contém a compilação exata 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 System.Environment.TickCount membro 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 seguinte Clipboard usa o objeto System.Windows.Forms definido no namespace para armazenar uma string. Este objeto fornece duas funções de 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 CurrentUser chave para criar uma instância gravável da RegistryKey classe correspondente à chave Software . O CreateSubKey método é então usado para criar uma nova chave e adicionar aos 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;
}
Observações
Você pode usar o .NET Framework para aceder ao registo com as classes Registry e RegistryKey, que são ambas definidas no espaço de nomes Microsoft.Win32. A classe Registry é um contêiner para instâncias estáticas da RegistryKey classe. Cada instância representa um nó de registro raiz. As instâncias são ClassesRoot, CurrentConfig, CurrentUser, LocalMachine, e Users.