10 praktische Codefragmente, die häufig von C#-Programmierern verwendet werden

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);

Geben Sie in meinem Windows 7-System die folgenden Informationen aus

Plattform: Win32NT
Service Pack:
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

Sie können Windows verwenden Management Instrumentation (WMI) bietet eine Schnittstelle zum Lesen der erforderlichen Informationen.

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 Starten und Stoppen von Windows-Diensten

Die praktischen Funktionen dieser API werden häufig verwendet, um Dienste in Anwendungen zu verwalten, ohne zu den Verwaltungsdiensten des Control Panels gehen zu müssen.

ServiceController controller = new ServiceController(“e-M-POWER”);      
controller.Start();      
if (controller.CanPauseAndContinue)      
{      
    controller.Pause();      
    controller.Continue();      
}      
controller.Stop();

In der von .net bereitgestellten API können Sie Ein-Satz-Installations- und Deinstallationsdienste implementieren.

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 i- oder u-Parameter an Die zu repräsentierende Anwendung dient dazu, das Programm zu deinstallieren oder zu installieren.

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

Um beispielsweise im Programm zu überprüfen, ob die Assembly eine Signatur hat, können Sie die folgende Methode aufrufen

[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 ein Beschäftigt-Status angezeigt.

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

. DisplaySettingsChanged (einschließlich Changing) Anzeigeeinstellungen
. PowerModeChanged Power status
. > . SessionSwitch (Aktuellen Benutzer ändern)
, Der Bereich außerhalb der ERP-Lizenzdatei führt dazu, dass die ERP-Software nicht verfügbar ist.

7 Nutzen Sie die neuen Funktionen von Windows 7

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

Die Verwendung dieser Methode zum Öffnen eines Dialogfelds hat mehr Funktionen als OpenFileDialog in der BCL-eigenen Klassenbibliothek. Allerdings ist es auf Windows 7-Systeme beschränkt. Um diesen Code aufzurufen, müssen Sie außerdem überprüfen, ob die Betriebssystemversion größer als 6 ist, und einen Verweis auf die Assembly hinzufügen. Windows API Code Pack für Microsoft®.NET Framework Bitte herunterladen es unter dieser Adresse http://code.msdn.microsoft.com/WindowsAPICodePack

　8 Überprüfen Sie den Speicherverbrauch des Programms

Mit der folgenden Methode können Sie die Menge des zugewiesenen Speichers überprüfen von .NET zum Programm

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

　In meinem System ist das Ergebnis seiner Operation wie folgt

　Mit der folgenden Methode können Sie den vom Strom belegten Speicher überprüfen Anwendung

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);

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

9 Verwenden Sie eine Stoppuhr, um die Laufzeit des Programms zu überprüfen

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

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

“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 );

Jetzt gibt es spezielle Tools zum Erkennen der Laufzeit des Programms, die auf jede Methode verfeinert werden können. wie die dotNetPerformance-Software.

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.

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);

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

　10 Verwendung des Cursors

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

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

　　用法如下所示，这个写法，是为了预料到程序可能会抛出异常

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

　　如代码所示，即使抛出异常，光标也可以恢复到之间的状态。