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


SommaireFichiers et donnéesFichiers (23)
précédent sommaire suivant
 

Pour créer, copier, déplacer ou supprimer un fichier, on utilise la classe System.IO.File

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
using System.IO; 
using System; 
//... 
  
public static void FileTests() 
{ 
    try 
    { 
        //Création d'un fichier vide. 
        FileStream fs = File.Create("myfile.txt"); 
  
        fs.Close(); 
        Console.WriteLine("fichier myfile.txt créé"); 
  
        // Copie de fichier 
        File.Copy("myfile.txt", "copyofmyfile.txt"); 
        Console.WriteLine("fichier myfile.txt copié vers copyofmyfile.txt"); 
  
        // Déplacement de fichier 
        File.Move("copyofmyfile.txt", @"c:\copyofmyfile.txt"); 
        Console.WriteLine(@"fichier copyofmyfile.txt déplacé vers c:\copyofmyfile.txt"); 
  
        // Suppression de fichier 
        File.Delete(@"c:\copyofmyfile.txt"); 
        Console.WriteLine(@"Fichier c:\copyofmyfile.txt supprimé"); 
    } 
    catch (Exception e) 
    { 
        Debug.WriteLine(ex.ToString()); 
        Console.WriteLine(ex.Message); 
    } 
}

Mis à jour le 2 novembre 2004 abelman

On utilise la méthode GetAttributes de la classe System.IO.File

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
using System.IO; 
//... 
  
static void GetFileAttributes(string sFilename) 
{ 
  
    FileAttributes flagAttr = File.GetAttributes(sFilename); 
  
    // Date de création 
    Console.WriteLine("Créé le {0} à {1}", 
    File.GetCreationTime(sFilename).ToShortDateString(), 
    File.GetCreationTime(sFilename).ToShortTimeString()); 
  
    // Date de la dernière modification 
    Console.WriteLine("Modifié le {0} à {1}", 
    File.GetLastWriteTime(sFilename).ToShortDateString(), 
    File.GetLastWriteTime(sFilename).ToShortTimeString()); 
  
    // Date du dernier accès 
    Console.WriteLine("Dernier accès le {0} à {1}", 
    File.GetLastAccessTime(sFilename).ToShortDateString(), 
    File.GetLastAccessTime(sFilename).ToShortTimeString()); 
  
    Console.WriteLine("Attributs de {0}", sFilename); 
  
    // Attribut Archive 
    if ((flagAttr & FileAttributes.Archive) == FileAttributes.Archive) 
        Console.WriteLine(FileAttributes.Archive.ToString()); 
  
    // Attribut Compressé 
    if ((flagAttr & FileAttributes.Compressed) == FileAttributes.Compressed) 
        Console.WriteLine(FileAttributes.Compressed.ToString()); 
  
    // Attribut Device 
    if ((flagAttr & FileAttributes.Device) == FileAttributes.Device) 
        Console.WriteLine(FileAttributes.Device.ToString()); 
  
    if ((flagAttr & FileAttributes.Directory) == FileAttributes.Directory) 
        Console.WriteLine(FileAttributes.Directory.ToString()); 
  
    if ((flagAttr & FileAttributes.Encrypted) == FileAttributes.Encrypted) 
        Console.WriteLine(FileAttributes.Encrypted.ToString()); 
  
    // Attribut caché 
    if ((flagAttr & FileAttributes.Hidden) == FileAttributes.Hidden) 
        Console.WriteLine(FileAttributes.Hidden.ToString()); 
  
    // Attribut Normal 
    if ((flagAttr & FileAttributes.Normal) == FileAttributes.Normal) 
        Console.WriteLine(FileAttributes.Normal.ToString()); 
  
    // Attibut non indexé 
    if ((flagAttr & FileAttributes.NotContentIndexed) == FileAttributes.NotContentIndexed) 
        Console.WriteLine(FileAttributes.NotContentIndexed.ToString()); 
  
    // Attribut Offline 
    if ((flagAttr & FileAttributes.Offline) == FileAttributes.Offline) 
        Console.WriteLine(FileAttributes.Offline.ToString()); 
  
    // Attribut ReadOnly 
    if ((flagAttr & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) 
        Console.WriteLine(FileAttributes.ReadOnly.ToString()); 
  
    // Attribut ReparsePoint 
    if ((flagAttr & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint) 
        Console.WriteLine(FileAttributes.ReparsePoint.ToString()); 
  
    // Attribut SparseFile 
    if ((flagAttr & FileAttributes.SparseFile) == FileAttributes.SparseFile) 
        Console.WriteLine(FileAttributes.SparseFile.ToString()); 
  
    // Attribut System 
    if ((flagAttr & FileAttributes.System) == FileAttributes.System) 
        Console.WriteLine(FileAttributes.System.ToString()); 
  
    // Attribut Temporary 
    if ((flagAttr & FileAttributes.Temporary) == FileAttributes.Temporary) 
        Console.WriteLine(FileAttributes.Temporary.ToString()); 
}

Mis à jour le 2 novembre 2004 abelman

On utilise la fonction GetFileSystemEntries de la classe System.IO.Directory

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System.IO; 
using System; 
  
static void Dir(string directory) 
{ 
    string[] files; 
  
    // pour avoir les noms des fichiers et sous-répertoires 
    files = Directory.GetFileSystemEntries(directory); 
  
    int filecount = files.GetUpperBound(0) + 1; 
    for (int i = 0; i < filecount; i++) 
        Console.WriteLine(files[i]); 
}
Pour avoir juste les noms des fichiers et pas les sous-répertoires d'un répertoire, on utilise
Code c# : Sélectionner tout
System.IO.Directory.GetFiles()

Mis à jour le 2 novembre 2004 abelman

Nous allons ouvrir un fichier texte et le remplir s'il n'existe pas encore.
Nous afficherons ensuite son contenu à l'écran.
On utilise pour cela les classes System.IO.StreamReader pour la lecture et System.IO.StreamWriter pour l'écriture

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
using System; 
using System.IO 
  
void FichierTexte(string nomFichier) 
{ 
    StreamReader sr = null; 
    StreamWriter sw = null; 
    string line; 
  
    try 
    { 
        if (!File.Exists(nomFichier)) 
        { 
            // Le fichier n'existe pas. On le crée. 
            sw = new StreamWriter(nomFichier); 
            sw.WriteLine("Bonjour. Nous sommes le {0} et il est {1} ", 
            DateTime.Now.ToLongDateString(), 
            DateTime.Now.ToLongTimeString()); 
            sw.Close(); 
            sw = null; 
            // Remarque : On peut utiliser sw = File.AppendText(NomFichier) pour ajouter 
            // du texte à un fichier existant 
        } 
  
        // Ouverture du fichier et écriture du contenu du fichier sur la console 
        sr = new StreamReader(nomFichier); 
        Console.WriteLine("Début du fichier"); 
        line = sr.ReadLine(); 
        while (line != null) 
        { 
            Console.WriteLine(line); 
            line = sr.ReadLine(); 
        } 
        Console.WriteLine("Fin du fichier"); 
    } 
    finally 
    { 
        // Fermeture streamreader 
        if (sr != null) sr.Close(); 
        // Fermeture streamwriter 
        if (sw != null) sw.Close(); 
    } 
}

Mis à jour le 2 novembre 2004 abelman

Nous allons ouvrir un fichier binaire et le remplir (d'entiers) s'il n'existe pas encore.
Nous afficherons son contenu à l'écran.
On utilise pour cela les classes System.IO.BinaryReader pour la lecture et System.IO.BinaryWriter pour l'écriture.

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
using System.IO; 
using System; 
  
void FichierBinaire(string NomFichier) 
{ 
    BinaryReader br = null; 
    BinaryWriter bw = null; 
    FileStream fs = null; 
    try 
    { 
        if (!File.Exists(NomFichier)) 
        { 
            // Le fichier n'existe pas. On le crée 
            bw = new BinaryWriter(File.Create(NomFichier)); 
            for (int i = 0; i < 10; i++) 
                bw.Write(i); 
            bw.Close(); 
        } 
        // Ouverture du contenu du fichier et écriture sur la console 
        fs = File.Open(NomFichier, FileMode.Open); 
        br = new BinaryReader(fs); 
        while (fs.Position < fs.Length) 
            Console.Write(br.ReadInt32()); 
        Console.WriteLine("\nFin du fichier"); 
    } 
    finally 
    { 
        if (br != null) br.Close(); 
        if (bw != null) bw.Close(); 
    } 
}

Mis à jour le 2 novembre 2004 abelman

Windows envoie des notifications qui permettent de surveiller les modifications apportées au système de fichier.
Cela se fait de la manière suivante en utilisant la classe System.IO.FileSystemWatcher.

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
void Watch(string path, string filter) 
{ 
    // On peut utiliser les '*' avec filter 
  
    // Création de l'objet watcher 
    FileSystemWatcher fw = new FileSystemWatcher(path, filter); 
  
    // On ajoute les handlers pour surveiller les évènements qu'on souhaite. 
    fw.Changed += new FileSystemEventHandler(OnChanged); 
    fw.Renamed += new RenamedEventHandler(OnRenamed); 
    fw.Created += new FileSystemEventHandler(OnChanged); 
    fw.Deleted += new FileSystemEventHandler(OnChanged); 
    fw.Error += new ErrorEventHandler(OnError); 
  
    // On surveillera aussi les sous-répertoires 
    fw.IncludeSubdirectories = true; 
  
    // Mettre EnableRaisingEvents à true démarre la surveillance des modifications. 
    // Mettre à false l'arrête. 
    fw.EnableRaisingEvents = true; 
} 
  
  
void OnChanged(Object source, FileSystemEventArgs e) 
{ 
    Console.WriteLine("Fichier {0} {1}", e.FullPath, e.ChangeType); 
} 
  
void OnRenamed(Object source, RenamedEventArgs e) 
{ 
    Console.WriteLine("Fichier {0} renommé en {1}", e.OldFullPath, e.FullPath); 
} 
  
void OnError(Object source, ErrorEventArgs e) 
{ 
    Exception ex = e.GetException(); 
    Console.WriteLine(ex.ToString()); 
}
Et voici l'utilisation de la fonction Watch

Code c# : Sélectionner tout
1
2
// Pour surveiller l'activité du répertoire c:\rep 
Watch(@"c:\rep", "*");

Mis à jour le 2 novembre 2004 abelman

Vous devez utiliser la méthode GetFileName de la classe System.IO.Path qui vous permet de récupérer le nom du fichier.

Code c# : Sélectionner tout
1
2
3
string fileName = "C:\\toto.tx"; 
string name = System.IO.Path.GetFileName(fileName); 
Console.WriteLine(name);

Mis à jour le 2 novembre 2004 Thomas Lebrun

En .NET, les fichiers sont ouverts par défaut avec l'encodage Unicode. Si le fichier est dans un autre encodage (par exemple ISO-8859-1, aussi appelé Latin 1), les caractères spéciaux (accentués par exemple) ne sont pas correctement interprétés et sont donc mal affichés.
Pour éviter ce problème, il faut spécifier le type d'encodage à utiliser pour la lecture/écriture de votre fichier. Exemple pour la lecture :

Code c# : Sélectionner tout
1
2
3
4
5
using System.IO; 
using System.Text; 
//.. 
  
StreamReader strReader = new System.IO.StreamReader(filePath,Encoding.Default);
Ici, on récupère l'encodage par défaut du système, et on l'applique lors de l'ouverture du fichier par le StreamReader.
On peut faire exactement la même chose avec les StreamWriter pour l'écriture.

Mis à jour le 2 novembre 2004 Thomas Lebrun tomlev

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
if (System.IO.File.Exists("c:\monfichier.txt")) 
{ 
    // Le fichier existe 
} 
else 
{ 
    // Le fichier n'existe pas 
}

Mis à jour le 10 avril 2006 neo.51

Tout d'abord pensez à ajouter ces deux "Imports" sans quoi il n'est pas possible d'utiliser le code donné en exemple.

Code c# : Sélectionner tout
1
2
using System.IO; 
using System.IO.Compression;
Avec cet exemple il vous suffit juste de passer en paramètres le chemin complet du fichier à compresser, et ensuite le chemin de destination du fichier GZip qui va être créé.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public bool compresserFichier(string cheminSource, string cheminDestination) 
{ 
    try 
    { 
        FileStream monFileStream = new FileStream(cheminSource, FileMode.Open); 
        byte[] monBuffer = new byte[monFileStream.Length]; 
        monFileStream.Read(monBuffer, 0, System.Convert.ToInt32(monFileStream.Length)); 
        monFileStream.Close(); 
        monFileStream = new FileStream(cheminDestination, FileMode.Create); 
        GZipStream monGZipStream = new GZipStream(monFileStream, CompressionMode.Compress, false); 
        monGZipStream.Write(monBuffer, 0, monBuffer.Length); 
        monGZipStream.Close(); 
        return true; 
    } 
    catch (Exception ex) 
    { 
        return false; 
    } 
}

Mis à jour le 22 août 2006 Ditch

Tout d'abord pensez à ajouter ces deux using sans quoi il n'est pas possible d'utiliser le code donné en exemple.

Code c# : Sélectionner tout
1
2
using System.IO; 
using System.IO.Compression;
Avec cet exemple il vous suffit juste de passer en paramètres le chemin complet du fichier GZip à décompresser, et ensuite le chemin de destination du fichier qui va être décompressé.

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
public bool decompression(string cheminSource, string cheminDestination) 
{ 
    try 
    { 
        FileStream monFileStream = new FileStream(cheminSource, FileMode.Open); 
        GZipStream monGzipStream = new GZipStream(monFileStream, CompressionMode.Decompress); 
        byte[] tailleOctets = new byte[3]; 
        int position = System.Convert.ToInt32(monFileStream.Length - 4); 
        monFileStream.Position = position; 
        monFileStream.Read(tailleOctets, 0, 4); 
        monFileStream.Position = 0; 
        int tailleFichier = BitConverter.ToInt32(tailleOctets, 0); 
        byte[] buffer = new byte[tailleFichier + 100]; 
        int monOffset = 0; 
        while ((true)) 
        { 
            int decompressionOctets = monGzipStream.Read(buffer, monOffset, 100); 
            if (decompressionOctets == 0) 
            { 
                break; 
            } 
            monOffset += decompressionOctets; 
        } 
  
        monFileStream = new FileStream(cheminDestination, FileMode.Create); 
        monFileStream.Write(buffer, 0, tailleFichier - 1); 
        monFileStream.Flush(); 
        monFileStream.Close(); 
        monGzipStream.Close(); 
        return true; 
    } 
    catch (Exception ex) 
    { 
        return false; 
    } 
}

Mis à jour le 22 août 2006 Ditch

Ce code permet de charger l'arborescence du disque dur c:\ dans un TreeView de la même façon que l'explorateur windows. Ce code nécessite un contrôle TreeView nommé « TV » et un bouton nommé « BTN ». Un using System.IO; est nécessaire.

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
private void Explor(TreeNode Node) 
{ 
    try 
    { 
        Node.Nodes.Clear(); 
        string s; 
        foreach (int s in Directory.GetDirectories(Node.FullPath)) 
        { 
            Node.Nodes.Add(Path.GetFileName(s)); 
        } 
    } 
    catch (Exception ex) 
    { 
        MessageBox.Show(ex.Message); 
    } 
} 
  
private void BTN_Click(object sender, System.EventArgs e) 
{ 
    TreeView1.Nodes.Add("c:\\"); 
    Explor(TreeView1.Nodes.Node[0]); 
} 
  
private void TV_AfterExpand(object sender, System.Windows.Forms.TreeViewEventArgs e) 
{ 
    TreeNode z; 
    foreach (int z in e.Node.Nodes) 
    { 
        Explor(z); 
    } 
}

Mis à jour le 22 août 2006 saline

On utilise la fonction GetFileSystemEntries à travers une méthode récursive afin de scanner tous les sous-répertoires.

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
class Program 
{ 
    static void Main(string[] args) 
    { 
        string strDirectory = @"C:\Inetpub"; 
  
        if (System.IO.Directory.Exists(strDirectory)) 
        { 
            DisplaySubDirectories(strDirectory); 
            System.Console.Read(); 
        } 
        else 
        { 
            System.Console.WriteLine("Ce répertoire n'existe pas !"); 
        } 
    } 
  
    public static void DisplaySubDirectories(string strDirectory) 
    { 
        foreach (string currentSubDirectory in System.IO.Directory.GetDirectories(strDirectory)) 
        { 
            System.Console.WriteLine(currentSubDirectory); 
            DisplaySubDirectories(currentSubDirectory); 
        } 
    } 
}

Mis à jour le 22 août 2006 Jérôme Lambert

Lors du chargement d'une image dans un PictureBox avec la fonction Image.FromFile, le fichier sous-jacent se trouve en utilisation et donc non disponible jusqu'à la fermeture de l'application. Il est ainsi, par exemple, impossible de le supprimer. Pour palier à ce problème, il faut en conséquence pouvoir libérer la ressource du flux sur ce fichier. Plusieurs solutions permettent d'atteindre cet objectif. Nous vous proposons ici celle qui consiste à gérer directement le flux et notamment par l'utilisation de la méthode Image.FromStream. L'exemple suivant charge une image via un FileStream, l'affecte à un PictureBox (appelé pictureBox1) par Image.FromStream, puis libère les ressources du flux (appelé photoStream) sur le fichier pour pouvoir le supprimer :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
// Créer le FileStream sur le fichier monimage.jpeg 
FileStream photoStream = new FileStream("C:\\monimage.jpeg", 
FileMode.Open); 
// affecter l'image à pictureBox1 
pictureBox1.Image = Image.FromStream(photoStream); 
// libérer les ressources 
photoStream.Close(); 
// supprimer le fichier monimage.jpeg 
File.Delete("C:\\monimage.jpeg");

Mis à jour le 22 août 2006 Sirius4

Grâce à la classe File, il est possible de récupérer les attributs (Archive, Lecture seule…) d'un fichier :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
// Récupération des attributs d'un fichier 
FileAttributes Fa = File.GetAttributes(@"C:\text.txt"); 
  
// Vérification si le fichier est en lecture seule 
if ((Fa & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) 
    Console.WriteLine("Ce fichier est en lecture seule !"); 
else 
    Console.WriteLine("Ce fichier n'est pas en lecture seule");

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

La méthode statique GetRandomFileName de la classe Path permet de générer un nom de fichier avec extension aléatoire :

Code c# : Sélectionner tout
Console.WriteLine("Nom de fichier généré : {0}", System.IO.Path.GetRandomFileName());

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

La classe Path possède la méthode statique GetTempFileName permettant de générer un fichier temporaire dans le répertoire temporaire de l'utilisateur courant :

Code c# : Sélectionner tout
1
2
string monFichierTemporaire = System.IO.Path.GetTempFileName(); 
Console.WriteLine("Nom du fichier temporaire : {0}", monFichierTemporaire);

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

On utilise la méthode statique GetTempPath de la classe Path permettant de récupérer le répertoire temporaire de l'utilisateur courant :

Code c# : Sélectionner tout
Console.WriteLine("Nom du fichier temporaire : {0}", System.IO.Path.GetTempPath());

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

On utilisera la méthode Delete de la classe Directory pour supprimer un répertoire et tout ce qu'il contient :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
string path = @"C:\Test\Test"; 
try 
{ 
    // Supprime le répertoire ainsi que ce qu'il contient 
    System.IO.Directory.Delete(path, true); 
} 
catch (Exception exc) 
{ 
    Console.WriteLine("Répertoire {0} impossible à supprimer !\nErreur: {1}", path, exc.Message);    
}

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

On utilisera la méthode Length de la classe FileInfo pour récupérer la taille d'un fichier :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
string path = @"C:\Test\test.txt"; 
try 
{ 
    System.IO.FileInfo monfichier = new System.IO.FileInfo(path); 
    Console.WriteLine("Taille du fichier : {0} octets", monfichier.Length); 
} 
catch (Exception exc) 
{ 
    Console.WriteLine("Un problème a été rencontré avec le fichier '{0}' !\nErreur: {1}", path, exc.Message);    
}

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

On utilisera la méthode statique Exists de la classe Directory pour vérifier qu'un répertoire existe :

Code c# : Sélectionner tout
1
2
3
4
if (System.IO.Directory.Exists(path) == true) 
    Console.WriteLine("Le répertoire ({0}) existe !", path); 
else 
    Console.WriteLine("Le répertoire ({0}) n'existe pas !", path);

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

Renommer un fichier est en fait une opération de déplacement.

Code c# : Sélectionner tout
1
2
3
4
string monAncienFichier, monNouveauFichier; 
monAncienFichier = "toto.txt"; 
monNouveauFichier = "tata.txt"; 
File.Move(monAncienFichier, monNouveauFichier);

Mis à jour le 10 juin 2008 dev01

La méthode statique Combine de la classe Path permet de concaténer de manière intelligente (c'est-à-dire en ajoutant si besoin est le bon séparateur) un chemin de répertoire avec un nom de fichier :

Code c# : Sélectionner tout
1
2
3
String Chemin = "C:/"; 
String Fichier = "fichier.txt"; 
String CheminComplet = System.IO.Path.Combine(Chemin, Fichier);

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

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 -