Developpez.com

Une très vaste base de connaissances en informatique avec
plus de 100 FAQ et 10 000 réponses à vos questions

FAQ C#Consultez toutes les FAQ

Nombre d'auteurs : 39, nombre de questions : 272, dernière mise à jour : 24 mai 2015  Ajouter une question

 

Cette FAQ a été réalisée pour répondre aux questions les plus fréquemment posées concernant C# sur le forum Développement DotNET

Je tiens à souligner qu'elle ne garantit en aucun cas que les informations qu'elle contient sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.

Commentez cette FAQ : Commentez


SommaireSystème (26)
précédent sommaire suivant
 

On utilise la propriété Version de la classe System.Environment.

Code c# : Sélectionner tout
1
2
3
// Version du framework 
Version ver = Environment.Version; 
Console.WriteLine("Version Framework = {0}", ver);

Mis à jour le 2 novembre 2004 abelman

Grâce à la propriété OSVersion de la classe Environment, il est possible de connaître la version de l'OS qui exécute l'application :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
switch (Environment.OSVersion.Platform) 
{ 
    case PlatformID.Win32NT:  
        if (Environment.OSVersion.Version.Major == 5) 
        { 
            if (Environment.OSVersion.Version.Minor == 1) 
                Console.WriteLine("Windows XP"); 
            else if (Environment.OSVersion.Version.Minor == 0) 
                Console.WriteLine("Windows 2000"); 
            else 
                Console.WriteLine("Windows ???"); 
        } 
        else 
            Console.WriteLine("Windows NT"); 
        break; 
    case PlatformID.Win32Windows: 
        Console.WriteLine("Windows 98 ou Me"); 
        break; 
    case PlatformID.WinCE: 
        Console.WriteLine("Windows Mobile"); 
        break; 
    case PlatformID.Unix:  
        // ... Oui oui Unix :) 
        Console.WriteLine("Windows Unix"); 
        break; 
    default: 
        Console.WriteLine("Autre..."); 
        break; 
}

Mis à jour le 20 mars 2007 Jérôme Lambert

On utilise la propriété ProcessorCount de la classe System.Environment :

Code c# : Sélectionner tout
1
2
3
// Nombre de processeurs de la machine 
int countProc = Environment.ProcessorCount; 
Console.WriteLine("Nombre processeurs = {0}", countProc);

Mis à jour le 2 janvier 2007 Jérôme Lambert

On utilise la propriété BootMode de la classe SystemInformation. On obtient une des valeurs de l'énumération BootMode : FailSafe, FaileSafeWithNetwork ou Normal.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
// Mode de démarrage de la machine 
switch (SystemInformation.BootMode) 
{  
    case BootMode.Normal: Console.WriteLine("Tout est ok !"); break; 
    case BootMode.FailSafe: Console.WriteLine("Attention, on est en mode sans echec !"); break; 
    case BootMode.FailSafeWithNetwork: Console.WriteLine("Attention, on est en mode sans échec mais on a accès au réseau !"); break; 
}

Mis à jour le 2 janvier 2007 Jérôme Lambert

On utilise la propriété SystemDirectory de la classe Environment

Code c# : Sélectionner tout
1
2
// Répertoire système 
Console.WriteLine("Répertoire système = {0}", Environment.SystemDirectory);

Mis à jour le 2 novembre 2004 abelman

On utilise la fonction GetFolderPath de la classe Environment avec l'énumération Environment.SpecialFolder

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
static void PrintSpecFolder() 
{ 
    // Répertoire spéciaux 
    Console.WriteLine("Répertoire spéciaux"); 
    Environment.SpecialFolder[] sfe = (Environment.SpecialFolder[]) 
    Enum.GetValues(typeof(Environment.SpecialFolder)); 
    for (int i = 0; i < sfe.Length; i++) 
        Console.WriteLine(Environment.GetFolderPath(sfe[i])); 
}

Mis à jour le 2 novembre 2004 abelman

On utilisera la méthode IsInRole de la classe WindowsPrincipal afin de déterminer si l'utilisateur courant fait bien partie ou pas d'un groupe x du domaine auquel il est rattaché :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
// Vérification si un utilisateur appartient à un groupe de domaine donné 
WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent()); 
  
if (wp.IsInRole("Developpez\\Moderateur") == true) 
    Console.WriteLine("L'utilisateur fait bien partie du groupe Developpez\\Moderateur"); 
else 
    Console.WriteLine("L'utilisateur ne fait pas partie du groupe Developpez\\Moderateur");

Mis à jour le 2 janvier 2007 Jérôme Lambert

On utilise la propriété MachineName de la classe System.Environment :

Code c# : Sélectionner tout
1
2
3
// Nom de la machine 
string MachineName = Environment.MachineName; 
Console.WriteLine("Nom de la machine = {0}", MachineName);

Mis à jour le 2 janvier 2007 Jérôme Lambert

On utilise la propriété UserName de la classe Environment

Code c# : Sélectionner tout
Console.WriteLine("Nom utilisateur = {0}", Environment.UserName);

Mis à jour le 2 novembre 2004 abelman

On utilise la propriété WorkingSet de la classe Environment

Code c# : Sélectionner tout
1
2
Console.WriteLine("Mémoire allouée au process en cours = {0} octets", 
Evironment.WorkingSet);

Mis à jour le 2 novembre 2004 abelman

On utilise la fonction GetLogicalDrives de la classe Environment

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
static void PrintLogicalDrives() 
{ 
    // Lecteurs logiques 
    Console.WriteLine("Lecteurs logiques"); 
    string[] drives = Environment.GetLogicalDrives(); 
    for (int i = 0; i < drives.Length; i++) 
        Console.WriteLine(drives[i]); 
}

Mis à jour le 2 novembre 2004 abelman

La classe DriveInfo (pouvant représenter un disque dur si sa propriété DriveType est à Fixed) possède la propriété DriveFormat pour connaître le format de fichiers du disque en question :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
System.IO.DriveInfo[] mesDrives = System.IO.DriveInfo.GetDrives(); 
  
foreach (DriveInfo Drive in mesDrives) 
{ 
    if (Drive.DriveType == DriveType.Fixed) 
        Console.WriteLine("Format du Drive {0} : {1}", Drive.Name, Drive.DriveFormat.ToString()); 
}

Mis à jour le 27 mars 2007 Jérôme Lambert

La classe DriveInfo peut nous donner les informations nécessaires afin de calculer le pourcentage d'espace libre de chaque disque dur :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
// Parcours de la liste des disques durs 
foreach (DriveInfo CurrentDrive in DriveInfo.GetDrives()) 
{ 
    // Vérification qu'on a bien affaire à un disque dur de l'ordinateur 
    if (CurrentDrive.DriveType == DriveType.Fixed) 
    { 
        // Calcul du pourcentage d'espace disque libre 
        Double pourcentageLibre = ((Double)CurrentDrive.AvailableFreeSpace / CurrentDrive.TotalSize) * 100; 
  
        Console.WriteLine("Espace libre de {0} >> {1}%", CurrentDrive.Name, Convert.ToInt16(pourcentageLibre)); 
    } 
}

Mis à jour le 2 janvier 2007 Jérôme Lambert

La classe DriveInfo possède la propriété VolumeLabel en lecture et écriture afin de modifier le nom du disque dur en question :

Code c# : Sélectionner tout
1
2
DriveInfo monDrive = new DriveInfo(@"C:\"); 
monDrive.VolumeLabel = "Mon Drive";
Attention, cette opération requiert les privilèges d'administrateur. Si l'application s'exécute sous Windows Vista ou Seven sans les privilèges d'administrateur, cette opération lèvera une exception.

Mis à jour le 27 mars 2007 Jérôme Lambert tomlev

On utilise la classe DriveInfo qui fournit des informations concernant entre autres des informations concernant les lecteurs CD/DVD :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
String monDrive = "D:/"; 
  
try 
{ 
    DriveInfo monDriveInfo = new DriveInfo(monDrive); 
  
    // Vérification qu'on a bien affaire à un lecteur CD/DVD 
    if (monDriveInfo.DriveType == DriveType.CDRom) 
    { 
        // Vérification si il y a un cd dans le lecteur 
        if (monDriveInfo.IsReady == true) 
        { 
            Console.WriteLine("Lecteur identifié avec CD : {0}", monDriveInfo.VolumeLabel); 
        } 
        else 
        { 
            Console.WriteLine("Lecteur identifié sans CD : {0}", monDriveInfo.Name); 
        } 
    } 
    else 
    { 
        Console.WriteLine("Ce lecteur n'est pas un lecteur CD/DVD !"); 
    } 
} 
catch (Exception) 
{ 
    Console.WriteLine("Ceci n'est pas un lecteur !"); 
}

Mis à jour le 20 mars 2007 Jérôme Lambert

Pour obtenir des informations détaillées sur un disque, il faut utiliser WMI (Windows Management Instrumentation). Il faudra tout d'abord ajouter une référence à l'assembly System.Management. Pour récupérer une valeur, il faudra utiliser la méthode GetPropertyValue associée à un nom de propriété. L'exemple suivant commence par lister toutes les propriétés existantes puis récupère la valeur de la propriété VolumeSerialNumber.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System.Management; 
// ... 
  
// Récupère le disque C: 
ManagementObject disque = new ManagementObject("win32_logicaldisk.deviceid=\"c:\""); 
disque.Get(); 
  
//Afficher toutes les propriétés du disque 
string strProp = ""; 
foreach (PropertyData d in disque.Properties) 
{ 
    strProp += string.Format("{0} : {1}\n", d.Name, disque.GetPropertyValue(d.Name)); 
} 
MessageBox.Show(strProp); 
  
//Obtenir une propriété en particulier 
strProp = disque.GetPropertyValue("VolumeSerialNumber").ToString(); 
MessageBox.Show("n° série volume : " + strProp);

Mis à jour le 22 août 2006 Merlin tomlev

La commande defrag c: -a permet de lancer l'analyse sur le disque dur C. Il suffit donc d'exécuter cette commande avec la classe Process et de récupérer la sortie standard.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Process p = null; 
try 
{ 
    p = new Process(); 
    p.StartInfo.UseShellExecute = false; 
    p.StartInfo.RedirectStandardOutput = true; 
    p.StartInfo.FileName = "defrag"; 
    p.StartInfo.Arguments = "c: -a"; 
    p.Start(); 
    if (p.WaitForExit(60 * 1000)) 
    { 
        MessageBox.Show(p.StandardOutput.ReadToEnd(), "StandardOutput"); 
        p.Dispose(); 
        p = null; 
    } 
} 
catch (Exception exc) 
{ 
    MessageBox.Show(exc.Message, "Exception"); 
} 
finally 
{ 
    if (p != null) 
    { 
        if (p.HasExited) 
        p.Kill(); 
  
        p.Dispose(); 
        p = null; 
    } 
}

Mis à jour le 20 mars 2007 clopes Jérôme Lambert

Le .NET Framework ne fournit pas de méthode permettant de récupérer la description d'un type de fichier. Il est cependant possible d'utiliser l'API Win32 SHGetFileInfo pour récupérer cette information :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
using System.Runtime.InteropServices; 
  
// ... 
  
[DllImport("shell32")] 
private static extern IntPtr SHGetFileInfo(string pszPath, uint dwFileAttributes, out SHFILEINFO psfi, uint cbFileInfo, uint flags); 
  
[StructLayout(LayoutKind.Sequential)] 
private struct SHFILEINFO 
{ 
    public IntPtr hIcon; 
    public int iIcon; 
    public uint dwAttributes; 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] 
    public string szDisplayName; 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)] 
    public string szTypeName; 
} 
  
private const uint FILE_ATTRIBUTE_NORMAL = 0x00000080; 
private const uint SHGFI_TYPENAME = 0x000000400; 
private const uint SHGFI_USEFILEATTRIBUTES = 0x000000010; 
  
public static string GetFileTypeDescription(string fileNameOrExtension) 
{ 
    SHFILEINFO shfi; 
    if (IntPtr.Zero != SHGetFileInfo( 
                        fileNameOrExtension, 
                        FILE_ATTRIBUTE_NORMAL, 
                        out shfi, 
                        (uint)Marshal.SizeOf(typeof(SHFILEINFO)), 
                        SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME)) 
    { 
        return shfi.szTypeName; 
    } 
    return null; 
} 
  
private void button1_Click(object sender, EventArgs e) 
{ 
    MessageBox.Show(GetFileTypeDescription("toto.exe")); 
    MessageBox.Show(GetFileTypeDescription("titi.jpg")); 
    MessageBox.Show(GetFileTypeDescription(".dat")); 
    MessageBox.Show(GetFileTypeDescription(".iso")); 
    MessageBox.Show(GetFileTypeDescription(".bmp")); 
}

Mis à jour le 28 mai 2008 smyley

Pour lancer un processus depuis notre application, on utilise la classe System.Diagnostics.Process
Exemple : lancer une instance de internet explorer qui ouvre www.developpez.com

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
void StartProcess() 
{ 
    // Instance de la classe Process 
    System.Diagnostics.Process proc = new System.Diagnostics.Process(); 
    // Nom de l'executable à lancer 
    proc.StartInfo.FileName = "iexplore.exe"; 
    // Arguments à passer à l'exécutable à lancer 
    proc.StartInfo.Arguments = "http://www.developpez.com"; 
    // Démarrage du processus 
    proc.Start(); 
    // On libère les ressources dont on n'a plus besoin. 
    proc.Close(); // Attention Close ne met pas fin au processus. 
}

Mis à jour le 2 novembre 2004 abelman freegreg

On peut ouvrir des documents dont l'extension est connue du shell windows comme les .txt ou les .doc avec
la classe System.Diagnostics.Process
Exemple : Ouverture d'un fichier texte .txt.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
void StartProcess() 
{ 
    // Instance de la classe Process 
    System.Diagnostics.Process proc = new System.Diagnostics.Process(); 
    // Nom du fichier dont l'extension est connue du shell à ouvrir 
    proc.StartInfo.FileName = "monfichier.txt"; 
    // Démarrage du processus. 
    // Notepad, si il est associé aux fichiers .txt, 
    // sera lancé et ouvrira le fichier monfichier.txt 
    proc.Start(); 
    // On libère les ressources dont on a plus besoin. 
    proc.Close(); // Attention Close ne met pas fin au processus. 
}

Mis à jour le 2 novembre 2004 abelman

Il est possible de rediriger la sortie standard d'un processus pour effectuer un traitement dessus où l'afficher. Il faut pour cela utiliser la propriété RedirectStandardOutput.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
static void RedirectStdOutput() 
{ 
    System.Diagnostics.Process proc = new System.Diagnostics.Process(); 
    // On désactive le shell 
    proc.StartInfo.UseShellExecute = false; 
    // On redirige la sortie standard 
    proc.StartInfo.RedirectStandardOutput = true; 
    // On définit la commande 
    proc.StartInfo.FileName = "mem.exe"; 
    // Démarrage de la commande 
    proc.Start(); 
    // Lecture de la sortie de la commande 
    string output = proc.StandardOutput.ReadToEnd(); 
    Console.WriteLine(output); 
    // Attente de la fin de la commande 
    proc.WaitForExit(); 
    // Libération des ressources 
    proc.Close(); 
}

Mis à jour le 2 novembre 2004 abelman tomlev

Pour lister les processus en cours on utilise la fonction

Code c# : Sélectionner tout
1
2
3
4
5
6
7
using System.Diagnostics; 
//... 
  
// Pour tous les processus en cours sur l'ordinateur local 
Process[] prc  = Process.GetProcesses(); 
// Pour tous les processus notepad en cours sur l'ordinateur local 
Process[] prc = Process.GetProcessesByName("notepad");

Mis à jour le 2 novembre 2004 abelman

Pour arrêter un processus, il faut disposer d'un objet System.Diagnostics.Process qui représente le processus.

Code c# : Sélectionner tout
1
2
3
4
// Pour les applications consoles 
proc.Kill(); 
// Libération des ressources 
proc.Close();
Pour les applications WinForm il est préférable d'utiliser CloseMainWindow afin que l'application
reçoive le message de fermeture et se ferme correctement.

Code c# : Sélectionner tout
1
2
3
4
5
// Pour les applications avec une interface graphique (et donc une pompe de messages) 
// Si l'appel échoue, on peut alors forcer la fermeture avec Kill. 
proc.CloseMainWindow(); 
// Libération des ressources 
proc.Close();

Mis à jour le 2 novembre 2004 abelman

Tout simplement en utilisant les fonctionnalités offertes par l'espace de noms System.Diagnostics, notamment la classe EventLog et sa méthode WriteEntry qui dispose d'une dizaine de surcharges.

Il faut tout d'abord créer une instance de EventLog, et la source d'évènement associée si elle n'existe pas :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
using System.Diagnostics; 
  
// ... 
if (!EventLog.SourceExists("MaSource")) 
{ 
    EventLog.CreateEventSource("MaSource", "MonJournal"); 
} 
EventLog monJournal = new EventLog(); 
monJournal.Source = "MaSource";
Notez que la méthode CreateEventSource requiert les privilèges d'administrateur, il est donc préférable de créer le source d'évènement lors de l'installation.

On peut ensuite utiliser notre EventLog pour logger une exception, par exemple :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
try 
{ 
    // instructions à exécuter 
} 
catch(Exception ex) 
{ 
    // écrire l'erreur 
    monJournal.WriteEntry(ex.Message, EventLogEntryType.Error); 
}

Mis à jour le 22 août 2006 neguib neo.51 tomlev

Pour émettre un bip avec le haut-parleur de la machine, il suffit d'utiliser la méthode Beep de la classe Console :

Code c# : Sélectionner tout
1
2
3
4
5
6
// Emet un simple bip 
Console.Beep(); 
  
// Emet un bip à la fréquence 15000Hz pendant 2 secondes 
// À noter que la gamme audible de l'oreille humaine va de 16 à 20000Hz 
Console.Beep(15000, 2000);

Mis à jour le 2 janvier 2007 Jérôme Lambert

WMI est utilisé pour accomplir différentes tâches d'administration système au travers de scripts ou requêtes WQL.

L'outil WMICodeCreator permet de générer le code source pour :

  • l'accès à une classe WMI ou à une de ses propriétés ;
  • l'exécution de méthodes d'une classe WMI ;
  • la réception d'évènements synchrones ou asynchrones issus d'un provider WMI.

Cet outil permet également de récupérer les détails d'une classe WMI : la liste des propriétés, méthodes et qualificateurs et pour certaines une description succincte de la classe.

Le code source généré peut l'être pour les langages C#, VB .NET ou encore VBScript.

Sous .NET reportez-vous aux espaces de noms System.Management et System.Management.Instrumentation.

Télécharger l'outil gratuit

Mis à jour le 10 avril 2006 Laurent Dardenne

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Microsoft DotNET : Hinault Romaric -