FAQ C#Consultez toutes les FAQ

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

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

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

System.IO.Directory.GetFiles()

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
try 
{ 
    string nomFichier = @"C:\monfichier.txt"; 
    if (!File.Exists(nomFichier)) 
    { 
        // Le fichier n'existe pas. On le crée 
        using (System.IO.StreamWriter sw = new System.IO.StreamWriter(nomFichier)) 
        { 
            // On écrit dans le fichier 
            sw.WriteLine("Bonjour. Nous sommes le {0} et il est {1}", 
            DateTime.Now.ToLongDateString(), 
            DateTime.Now.ToLongTimeString()); 
        } 
    } 
  
    // Ouverture du fichier 
    using (System.IO.StreamReader sr = new System.IO.StreamReader(nomFichier)) 
    { 
        // Lit le contenu 
        string content = sr.ReadToEnd(); 
  
        // Affiche le contenu 
        Console.Write(content); 
    } 
} 
catch (Exception ex) 
{ 
    Console.WriteLine("Une erreur s'est produite : {0}", ex.Message); 
}

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

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

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

1
2
3
string fileName = @"C:\monfichier.txt"; 
string name = System.IO.Path.GetFileName(fileName); 
Console.WriteLine(name);

1
2
3
4
5
6
7
8
// Obtient un flux de lecture dans l'encodage spécifié 
System.IO.StreamReader strReader = new System.IO.StreamReader(@"C:\monfichier.txt", System.Text.Encoding.Unicode); 
  
// Lit le contenu 
string content = strReader.ReadToEnd(); 
  
// Affiche le contenu 
Console.Write(content);

1
2
// Obtient un flux d'écriture dans l'encodage spécifié 
System.IO.StreamWriter strWriter = new System.IO.StreamWriter(@"C:\monfichier.txt", System.Text.Encoding.Unicode);

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 
}

1
2
using System.IO; 
using System.IO.Compression;

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

1
2
using System.IO; 
using System.IO.Compression;

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

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 Explore(TreeNode Node) 
{ 
    try 
    { 
        Node.Nodes.Clear(); 
        foreach (string s in System.IO.Directory.GetDirectories(Node.FullPath)) 
        { 
            Node.Nodes.Add(System.IO.Path.GetFileName(s)); 
        } 
    } 
    catch (Exception ex) 
    { 
        System.Diagnostics.Debug.WriteLine(ex.Message); 
    } 
} 
  
private void BTN_Click(object sender, EventArgs e) 
{ 
    TV.Nodes.Clear(); 
    TreeNode tn = TV.Nodes.Add(@"C:\"); 
    Explore(tn); 
} 
  
private void TV_BeforeExpand(object sender, TreeViewCancelEventArgs e) 
{ 
    Explore(e.Node); 
    foreach (TreeNode tn in e.Node.Nodes) 
    { 
        Explore(tn); 
    } 
}

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

1
2
3
4
5
6
7
8
// 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");

1
2
3
4
5
6
7
8
9
10
11
12
// 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"); 
}

1
2
3
4
Console.WriteLine("Nom de fichier généré : {0}", System.IO.Path.GetRandomFileName()); 
  
// Sortie : 
// Nom de fichier généré : w143kxnu.idj

1
2
3
4
5
string monFichierTemporaire = System.IO.Path.GetTempFileName(); 
Console.WriteLine("Nom du fichier temporaire : {0}", monFichierTemporaire); 
  
// Sortie : 
// Nom du fichier temporaire : C:\Users\DVP\AppData\Local\Temp\tmp2F56.tmp

Console.WriteLine("Nom du dossier temporaire : {0}", System.IO.Path.GetTempPath());

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

1
2
3
4
5
6
7
8
9
10
11
string path = @"C:\Test\test.txt";  
  
System.IO.FileInfo monfichier = new System.IO.FileInfo(path); 
if (monfichier.Exists == true) 
{ 
    Console.WriteLine("Taille du fichier : {0} octets", monfichier.Length); 
} 
else 
{ 
    Console.WriteLine("Le fichier '{0}' n'existe pas", path); 
}

1
2
3
4
5
6
7
8
9
10
11
  
string path = @"C:\Windows"; 
  
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); 
}

1
2
3
string monAncienFichier = "toto.txt";  
string monNouveauFichier = "tata.txt";  
File.Move(monAncienFichier, monNouveauFichier);

1
2
3
String Chemin = "C:/"; 
String Fichier = "fichier.txt"; 
String CheminComplet = System.IO.Path.Combine(Chemin, Fichier);