Detaillierte Einführung in 10 praktische Codefragmente, die häufig von C#-Programmierern verwendet werden

10 praktische Codefragmente, die häufig von C#-Programmierern verwendet werden, werden im Detail vorgestellt:

1 Lesen Sie die Version des Betriebssystems und der CLR

OperatingSystem os = System.Environment.OSVersion;
Console.WriteLine(“Platform: {0}”, os.Platform);
Console.WriteLine(“Service Pack: {0}”, os.ServicePack);
Console.WriteLine(“Version: {0}”, os.Version);
Console.WriteLine(“VersionString: {0}”, os.VersionString);
Console.WriteLine(“CLR Version: {0}”, System.Environment.Version);

​In meinem Windows 7-System werden folgende Informationen ausgegeben

Plattform: Win32NT
Servicepaket:
Version: 6.1.7600.0
VersionString: Microsoft Windows NT 6.1.7600.0
CLR-Version: 4.0.21006.1

​2 Lesen Sie die Anzahl der CPUs und die Speicherkapazität ab

Die erforderlichen Informationen können über die von Windows Management Instrumentation (WMI) bereitgestellte Schnittstelle ausgelesen werden.

private static UInt32 CountPhysicalProcessors()
{
     ManagementObjectSearcher objects = new ManagementObjectSearcher(
        “SELECT * FROM Win32_ComputerSystem”);
     ManagementObjectCollection coll = objects.Get();
     foreach(ManagementObject obj in coll)
    {
        return (UInt32)obj[“NumberOfProcessors”];
    } 
    return 0;
}
private static UInt64 CountPhysicalMemory()
{
   ManagementObjectSearcher objects =new ManagementObjectSearcher(
      “SELECT * FROM Win32_PhysicalMemory”);
   ManagementObjectCollection coll = objects.Get();
   UInt64 total = 0;
   foreach (ManagementObject obj in coll)
   {
       total += (UInt64)obj[“Capacity”];
    }
    return total;
}

Bitte fügen Sie einen Verweis auf die Assembly System.Management hinzu, um sicherzustellen, dass der Code korrekt kompiliert werden kann.

Console.WriteLine(“Machine: {0}”, Environment.MachineName);
Console.WriteLine(“# of processors (logical): {0}”, Environment.ProcessorCount);
Console.WriteLine(“# of processors (physical): {0}”  CountPhysicalProcessors());
Console.WriteLine(“RAM installed: {0:N0} bytes”,  CountPhysicalMemory());
Console.WriteLine(“Is OS 64-bit? {0}”,   Environment.Is64BitOperatingSystem);
Console.WriteLine(“Is process 64-bit? {0}”,  Environment.Is64BitProcess);
Console.WriteLine(“Little-endian: {0}”, BitConverter.IsLittleEndian);
foreach (Screen screen in  System.Windows.Forms.Screen.AllScreens)
{
     Console.WriteLine(“Screen {0}”, screen.DeviceName);
     Console.WriteLine(“\tPrimary {0}”, screen.Primary);
     Console.WriteLine(“\tBounds: {0}”, screen.Bounds);
     Console.WriteLine(“\tWorking Area: {0}”,screen.WorkingArea);
     Console.WriteLine(“\tBitsPerPixel: {0}”,screen.BitsPerPixel);
}

3. Lesen Sie das Schlüssel-Wert-Paar der Registrierung

using (RegistryKey keyRun = Registry.LocalMachine.OpenSubKey(@”Software\Microsoft\Windows\CurrentVersion\Run”))
{
    foreach (string valueName in keyRun.GetValueNames())
    {
     Console.WriteLine(“Name: {0}\tValue: {1}”, valueName, keyRun.GetValue(valueName));
    }
}

Bitte fügen Sie den Namespace Microsoft.Win32 hinzu, um sicherzustellen, dass der obige Code kompiliert werden kann.

4 Windows-Dienste starten und stoppen

Die praktischen Funktionen dieser API werden häufig zur Verwaltung von Diensten in Anwendungen genutzt, ohne dass dazu die Verwaltungsdienste im Control Panel aufgerufen werden müssen.

<p style="margin-bottom: 7px;">ServiceController controller = new ServiceController(“e-M-POWER”);      <br/>controller.Start();      <br/>if (controller.CanPauseAndContinue)      <br/>{      <br/>    controller.Pause();      <br/>    controller.Continue();      <br/>}      <br/>controller.Stop();<br/></p>

In der von .net bereitgestellten API können Sie Dienste in einem Satz installieren und deinstallieren

 if (args[0] == "/i")
 {
       ManagedInstallerClass.InstallHelper(new string[] { Assembly.GetExecutingAssembly().Location });
 }
 else if (args[0] == "/u")
 {
   ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location });
 }

Übergeben Sie, wie im Code gezeigt, den Parameter i oder u an die Anwendung, um anzugeben, ob das Programm deinstalliert oder installiert werden soll.

5. Überprüfen Sie, ob das Programm einen starken Namen hat (P/Invoke)

Um beispielsweise in einem Programm zu überprüfen, ob die Assembly signiert ist, kann die folgende Methode aufgerufen werden:

[DllImport("mscoree.dll", CharSet=CharSet.Unicode)]
static extern bool StrongNameSignatureVerificationEx(string wszFilePath, bool fForceVerification, ref bool  pfWasVerified);

bool notForced = false;
bool verified = StrongNameSignatureVerificationEx(assembly, false, ref notForced);
Console.WriteLine("Verified: {0}\nForced: {1}", verified, !notForced);

Diese Funktion wird häufig in Softwareschutzmethoden verwendet und kann zur Überprüfung signierter Komponenten verwendet werden. Selbst wenn Ihre Signatur entfernt wird oder die Signaturen aller Assemblys entfernt werden, kann die Ausführung des Programms gestoppt werden, solange dieser aufrufende Code im Programm vorhanden ist.

6. Reagieren Sie auf Änderungen in Systemkonfigurationselementen

Wenn QQ beispielsweise nach dem Sperren des Systems nicht beendet wird, wird der Status „Beschäftigt“ angezeigt.

Bitte fügen Sie den Namespace Microsoft.Win32 hinzu und registrieren Sie dann die folgenden Ereignisse.

. DisplaySettingsChanged (einschließlich Änderung) Anzeigeeinstellungen
. InstalledFontsChanged Schriftartänderungen
.PaletteChanged
. PowerModeGeänderter Energiestatus
.SessionEnded (Der Benutzer meldet sich ab oder die Sitzung wurde beendet)
.SessionSwitch (Aktuellen Benutzer ändern)
. TimeChanged Zeit geändert
. UserPreferenceChanged (Benutzerpräferenznummer beinhaltet Changing)

Unser ERP-System überwacht, ob sich die Systemzeit außerhalb des Bereichs der ERP-Lizenzdatei geändert hat, die ERP-Software ist nicht mehr verfügbar.

7. Nutzen Sie die neuen Funktionen von Windows 7

Das Windows 7-System führt einige neue Funktionen ein, z. B. das Dialogfeld „Datei öffnen“ und die Statusleiste kann den Fortschritt der aktuellen Aufgabe anzeigen.

Microsoft.WindowsAPICodePack.Dialogs.CommonOpenFileDialog ofd = new  Microsoft.WindowsAPICodePack.Dialogs.CommonOpenFileDialog();
ofd.AddToMostRecentlyUsedList = true;
ofd.IsFolderPicker = true;
ofd.AllowNonFileSystemItems = true;
ofd.ShowDialog();

Die Verwendung dieser Methode zum Öffnen eines Dialogfelds hat mehr Funktionen als OpenFileDialog in der BCL-eigenen Klassenbibliothek. Es ist jedoch auf Windows 7-Systeme beschränkt. Um diesen Code aufzurufen, müssen Sie außerdem überprüfen, ob die Version des Betriebssystems größer als 6 ist, und einen Verweis auf das Assembly-Windows-API-Codepaket für Microsoft®.NET Framework hinzufügen. Bitte gehen Sie zu dieser Adresse, um http://www.php.cn/

herunterzuladen 8 Überprüfen Sie den Speicherverbrauch des Programms

Verwenden Sie die folgende Methode, um die von .NET dem Programm zugewiesene Speichermenge zu überprüfen

long available = GC.GetTotalMemory(false);
Console.WriteLine(“Before allocations: {0:N0}”, available);
int allocSize = 40000000;
byte[] bigArray = new byte[allocSize];
available = GC.GetTotalMemory(false);
Console.WriteLine(“After allocations: {0:N0}”, available);

​In meinem System ist das Ergebnis seiner Operation wie folgt

Before allocations: 651,064
After allocations: 40,690,080

Verwenden Sie die folgende Methode, um den von der aktuellen Anwendung belegten Speicher zu überprüfen

Process proc = Process.GetCurrentProcess();
Console.WriteLine(“Process Info: “+Environment.NewLine+

 “Private Memory Size: {0:N0}”+Environment.NewLine +
“Virtual Memory Size: {1:N0}” + Environment.NewLine +

“Working Set Size: {2:N0}” + Environment.NewLine +
“Paged Memory Size: {3:N0}” + Environment.NewLine +
“Paged System Memory Size: {4:N0}” + Environment.NewLine +

  “Non-paged System Memory Size: {5:N0}” + Environment.NewLine,
proc.PrivateMemorySize64,   proc.VirtualMemorySize64,  proc.WorkingSet64,  
proc.PagedMemorySize64, proc.PagedSystemMemorySize64,  proc.NonpagedSystemMemorySize64 );

9. Überprüfen Sie die Programmlaufzeit mit einer Stoppuhr

Wenn Sie befürchten, dass ein Code sehr zeitaufwändig ist, können Sie StopWatch verwenden, um die von diesem Code verbrauchte Zeit zu überprüfen, wie im folgenden Code gezeigt

System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
timer.Start();
Decimal total = 0;
int limit = 1000000;
for (int i = 0; i < limit; ++i)
{
      total = total + (Decimal)Math.Sqrt(i);
}
timer.Stop();
Console.WriteLine(“Sum of sqrts: {0}”,total);
Console.WriteLine(“Elapsed milliseconds: {0}”,
timer.ElapsedMilliseconds);
Console.WriteLine(“Elapsed time: {0}”, timer.Elapsed);

Jetzt gibt es spezielle Tools zur Erkennung der Laufzeit des Programms, die auf jede Methode verfeinert werden können, beispielsweise die Software dotNetPerformance.

Am Beispiel des obigen Codes müssen Sie den Quellcode direkt ändern, was etwas unpraktisch ist, wenn er zum Testen des Programms verwendet wird. Bitte beachten Sie das folgende Beispiel.

class AutoStopwatch : System.Diagnostics.Stopwatch, IDisposable
{
   public AutoStopwatch()
   { 
       Start();
   }
   public void Dispose()
   {
       Stop();
       Console.WriteLine(“Elapsed: {0}”, this.Elapsed);
   }
}

Mithilfe der Syntax, wie im folgenden Code gezeigt, können Sie die Laufzeit eines Codeabschnitts überprüfen und auf der Konsole ausdrucken.

using (new AutoStopwatch())
{
    Decimal total2 = 0;
    int limit2 = 1000000;
    for (int i = 0; i < limit2; ++i)
    {
       total2 = total2 + (Decimal)Math.Sqrt(i);
    }
}

10 Verwenden Sie den Cursor

Wenn das Programm im Hintergrund einen Speicher- oder Löschvorgang ausführt, sollte der Cursorstatus in „Beschäftigt“ geändert werden. Nutzen Sie die folgenden Tipps.

class AutoWaitCursor : IDisposable
{
private Control _target;
private Cursor _prevCursor = Cursors.Default;
public AutoWaitCursor(Control control)
{
   if (control == null)
   {
     throw new ArgumentNullException(“control”);
   }
   _target = control;
   _prevCursor = _target.Cursor;
   _target.Cursor = Cursors.WaitCursor;
}
public void Dispose()
{
   _target.Cursor = _prevCursor;
}
}

Die Verwendung ist wie folgt. Diese Schreibweise besteht darin, zu antizipieren, dass das Programm möglicherweise eine Ausnahme auslöst

using (new AutoWaitCursor(this))
{
...
throw new Exception();
}

Wie im Code gezeigt, kann der Cursor auch dann in den vorherigen Zustand zurückversetzt werden, wenn eine Ausnahme ausgelöst wird.

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in 10 praktische Codefragmente, die häufig von C#-Programmierern verwendet werden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!