Anteckning
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Visar olika Windows-specifika uppgifter med hjälp av Windows SDK.
Följande avsnitt visar olika Windows-åtgärder som utförs med Windows SDK med hjälp av Visual C++.
Kontrollera om avstängningen har startat
Följande kodexempel visar hur du avgör om programmet eller .NET Framework för närvarande avslutas. Detta är användbart för att komma åt statiska element i .NET Framework eftersom konstruktionerna under avstängningen slutförs av systemet och inte kan användas på ett tillförlitligt sätt. Genom att HasShutdownStarted kontrollera egenskapen först kan du undvika potentiella fel genom att inte komma åt dessa element.
Exempel
// 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;
}
Fastställa användarens interaktiva tillstånd
Följande kodexempel visar hur du avgör om kod körs i en användarinter interaktiv kontext. Om UserInteractive är falskt körs koden som en tjänstprocess eller inifrån ett webbprogram, i vilket fall du inte ska försöka interagera med användaren.
Exempel
// user_interactive.cpp
// compile with: /clr
using namespace System;
int main()
{
if ( Environment::UserInteractive )
Console::WriteLine("User interactive");
else
Console::WriteLine("Noninteractive");
return 0;
}
Läsa data från Windows-registret
I följande kodexempel används CurrentUser nyckeln för att läsa data från Windows-registret. Först räknas undernycklarna upp med hjälp av GetSubKeyNames metoden och sedan öppnas undernyckeln Identiteter med hjälp av OpenSubKey metoden. Precis som rotnycklarna representeras varje undernyckel av RegistryKey klassen. Slutligen används det nya RegistryKey objektet för att räkna upp nyckel/värde-paren.
Exempel
// 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;
}
Anmärkningar
Klassen Registry är bara en container för statiska instanser av RegistryKey. Varje instans representerar en rotregisternod. Instanserna är ClassesRoot, CurrentConfig, CurrentUser, LocalMachineoch Users.
Förutom att de är statiska är objekten i Registry klassen skrivskyddade. Dessutom är även instanser av RegistryKey klassen som skapas för att komma åt innehållet i registerobjekten skrivskyddade. Ett exempel på hur du åsidosätter det här beteendet finns i Så här skriver du data till Windows-registret (C++/CLI).
Det finns ytterligare två objekt i Registry klassen: DynData och PerformanceData. Båda är instanser av RegistryKey klassen. Objektet DynData innehåller dynamisk registerinformation, som endast stöds i Windows 98 och Windows Me. Objektet PerformanceData kan användas för att komma åt prestandaräknarinformation för program som använder Windows prestandaövervakningssystem. Noden PerformanceData representerar information som faktiskt inte lagras i registret och därför inte kan visas med hjälp av Regedit.exe.
Läs Prestandaräknare för Windows
Vissa program och Windows-undersystem exponerar prestandadata via Windows-prestandasystemet. Dessa räknare kan nås med hjälp av PerformanceCounterCategory klasserna och PerformanceCounter som finns i System.Diagnostics namnområdet.
I följande kodexempel används dessa klasser för att hämta och visa en räknare som uppdateras av Windows för att ange den procentandel av tiden som processorn är upptagen.
Anmärkning
Det här exemplet kräver administratörsbehörighet för att köras i Windows Vista.
Exempel
// 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;
}
Hämta text från Urklipp
I följande kodexempel används GetDataObject medlemsfunktionen för att returnera en pekare till IDataObject gränssnittet. Det här gränssnittet kan sedan frågas efter dataformatet och användas för att hämta faktiska data.
Exempel
// 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;
}
Hämta aktuellt användarnamn
I följande kodexempel visas hämtningen av det aktuella användarnamnet (namnet på den användare som är inloggad i Windows). Namnet lagras i strängen UserName , som definieras i Environment namnområdet.
Exempel
// username.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nCurrent user: {0}", Environment::UserName);
return 0;
}
Hämta .NET Framework-versionen
Följande kodexempel visar hur du fastställer vilken version av det för närvarande installerade .NET Framework med Version egenskapen, som är en pekare till ett Version objekt som innehåller versionsinformationen.
Exempel
// 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;
}
Hämta namnet på den lokala datorn
I följande kodexempel visas hämtningen av namnet på den lokala datorn (namnet på datorn som visas i ett nätverk). Du kan göra detta genom att hämta strängen MachineName , som definieras i Environment namnområdet.
Exempel
// machine_name.cpp
// compile with: /clr
using namespace System;
int main()
{
Console::WriteLine("\nMachineName: {0}", Environment::MachineName);
return 0;
}
Hämta Windows-versionen
Följande kodexempel visar hur du hämtar plattforms- och versionsinformationen för det aktuella operativsystemet. Den här informationen lagras i System.Environment.OSVersion egenskapen och består av en uppräkning som beskriver versionen av Windows i breda termer och ett Version objekt som innehåller den exakta versionen av operativsystemet.
Exempel
// 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;
}
Hämta tid som gått sedan starten
Följande kodexempel visar hur du fastställer tickräknaren, eller antalet millisekunder som har förflutit sedan Windows startades. Det här värdet lagras i System.Environment.TickCount medlemmen och, eftersom det är ett 32-bitars värde, återställs till noll ungefär var 24,9:e dag.
Exempel
// 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;
}
Lagra text i Urklipp
I följande kodexempel används objektet Clipboard som definierats i System.Windows.Forms namnområdet för att lagra en sträng. Det här objektet innehåller två medlemsfunktioner: SetDataObject och GetDataObject. Data lagras i Urklipp genom att skicka alla objekt som härleds från Object till SetDataObject.
Exempel
// 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;
}
Skriva data till Windows-registret
I följande kodexempel används CurrentUser nyckeln för att skapa en skrivbar instans av RegistryKey klassen som motsvarar programvarunyckeln . Metoden CreateSubKey används sedan för att skapa en ny nyckel och lägga till i nyckel/värde-par.
Exempel
// 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;
}
Anmärkningar
Du kan använda .NET Framework för att komma åt registret med klasserna Registry och RegistryKey som båda definieras i Microsoft.Win32 namnområdet. Klassen Registry är en container för statiska instanser av RegistryKey klassen. Varje instans representerar en rotregisternod. Instanserna är ClassesRoot, CurrentConfig, CurrentUser, LocalMachineoch Users.