Introduction détaillée à 10 extraits de code pratiques fréquemment utilisés par les programmeurs C#

10 extraits de code pratiques fréquemment utilisés par les programmeurs C# sont présentés en détail :

1 Lire la version du système d'exploitation et du 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);

​Dans mon système Windows 7, les informations suivantes sont affichées

Plateforme : Win32NT
Pack de services :
Version : 6.1.7600.0
VersionString : Microsoft Windows NT 6.1.7600.0
Version CLR : 4.0.21006.1

2. Lisez le nombre de processeurs et la capacité de mémoire

Les informations requises peuvent être lues via l'interface fournie par Windows Management Instrumentation (WMI).

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

Veuillez ajouter une référence à l'assembly System.Management pour garantir que le code peut être compilé correctement.

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. Lisez la paire clé-valeur du registre

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

Veuillez ajouter l'espace de noms Microsoft.Win32 pour vous assurer que le code ci-dessus peut être compilé.

4 Démarrez et arrêtez les services Windows

Les fonctions pratiques fournies par cette API sont souvent utilisées pour gérer des services dans des applications sans avoir à passer par les services de gestion dans le panneau de configuration.

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

Dans l'API fournie par .net, vous pouvez installer et désinstaller des services en une seule phrase

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

Comme indiqué dans le code, transmettez le paramètre i ou u à l'application pour indiquer s'il faut désinstaller ou installer le programme.

5. Vérifiez si le programme a un nom fort (P/Invoke)

Par exemple, dans un programme, afin de vérifier si l'assembly est signé, la méthode suivante peut être appelée

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

Cette fonction est couramment utilisée dans les méthodes de protection logicielle et peut être utilisée pour vérifier les composants signés. Même si votre signature est supprimée ou si les signatures de tous les assemblys sont supprimées, tant qu'il y a ce code d'appel dans le programme, l'exécution du programme peut être arrêtée.

6. Répondre aux modifications apportées aux éléments de configuration du système

Par exemple, après avoir verrouillé le système, si QQ ne se ferme pas, il affichera un statut occupé.

Veuillez ajouter l'espace de noms Microsoft.Win32, puis enregistrer les événements suivants.

. DisplaySettingsChanged (y compris la modification) des paramètres d'affichage
. . Modifications de police InstalledFontsChanged
. .PaletteChanged
. PowerModeModification de l'état d'alimentation
. .SessionEnded (L'utilisateur se déconnecte ou la session est terminée)
.SessionSwitch (Changer l'utilisateur actuel)
. TimeChanged L'heure a changé
. UserPreferenceChanged (le numéro de préférence utilisateur inclut le changement)

. Notre système ERP surveillera si l'heure du système a changé. Si l'heure est ajustée en dehors de la plage du fichier de licence ERP, le logiciel ERP deviendra indisponible.

7. Utilisez les nouvelles fonctionnalités de Windows 7

Le système Windows 7 introduit de nouvelles fonctionnalités, telles que la boîte de dialogue Ouvrir un fichier, et la barre d'état peut afficher la progression de la tâche en cours.

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

L'utilisation de cette méthode pour ouvrir une boîte de dialogue a plus de fonctions que OpenFileDialog dans la propre bibliothèque de classes de BCL. Cependant, il est limité aux systèmes Windows 7, donc pour appeler ce code, vous devez également vérifier que la version du système d'exploitation est supérieure à 6, et ajouter une référence à l'assembly Windows API Code Pack pour Microsoft®.NET Framework. Veuillez vous rendre à cette adresse pour télécharger http ://www.php.cn/

8 Vérifiez la consommation mémoire du programme

Utilisez la méthode suivante pour vérifier la quantité de mémoire allouée par .NET au programme

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

​Dans mon système, le résultat de son fonctionnement est le suivant

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

Utilisez la méthode suivante pour vérifier la mémoire occupée par l'application actuelle

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. Utilisez un chronomètre pour vérifier la durée du programme

Si vous craignez qu'un code prenne beaucoup de temps, vous pouvez utiliser StopWatch pour vérifier le temps consommé par ce code, comme indiqué dans le code suivant

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

Il existe désormais des outils spéciaux pour détecter la durée d'exécution du programme, qui peuvent être affinés pour chaque méthode, comme le logiciel dotNetPerformance.

En prenant le code ci-dessus comme exemple, vous devez modifier directement le code source, ce qui est quelque peu gênant s'il est utilisé pour tester le programme. Veuillez vous référer à l'exemple ci-dessous.

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

À l'aide de la syntaxe, comme indiqué dans le code suivant, vous pouvez vérifier le temps d'exécution d'un morceau de code et l'imprimer sur la console.

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

10 Utilisez le curseur

Lorsque le programme exécute une opération de sauvegarde ou de suppression en arrière-plan, l'état du curseur doit être modifié en occupé. Utilisez les conseils suivants.

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

L'utilisation est la suivante. Cette façon d'écrire est d'anticiper que le programme puisse lever une exception

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

Comme le montre le code, même si une exception est levée, le curseur peut être restauré à son état précédent.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!