FAQ C#Consultez toutes les FAQ

Nombre d'auteurs : 41, nombre de questions : 272, dernière mise à jour : 1er novembre 2017  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
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); 
}

Si le fichier existe, on peut utiliser sw = File.AppendText(nomFichier) pour ajouter du texte en fin de fichier.

Mis à jour le 1er novembre 2017 abelman ericlm128

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

On utilisera la méthode GetFileName de la classe Path pour extraire le nom d'un fichier :

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

Mis à jour le 1er novembre 2017 François DORIN Thomas Lebrun

Un fichier texte peut être encodé dans différents formats (ASCII, Unicode, UTF8 ...).
Si nous accédons au fichier avec le mauvais encodage les caractères spéciaux (accentués par exemple) ne sont pas correctement interprétés.
Pour éviter ce problème, il faut spécifier le type d'encodage à utiliser :

Code c# : Sélectionner tout
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);

Pour l'écriture, on utilisera un flux StreamWriter tout en spécifiant l'encodage :
Code c# : Sélectionner tout
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);

Mis à jour le 1er novembre 2017 ericlm128 François DORIN Thomas Lebrun tomlev

On utilise la méthode Exists de la classe File pour déterminer l'existence d'un fichier :

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 1er novembre 2017 François DORIN 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 ». Ne pas oublier d'abonner les évènements.

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

Mis à jour le 1er novembre 2017 ericlm128 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
// 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 16 août 2017 ericlm128 Sirius4

La méthode statique GetAttributes de la classe File permet 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
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"); 
}

Note 1 : L'attribut lecture seule peut être récupéré via la classe FileInfo qui possède la propriété IsReadOnly
Note 2 : Les attributs peuvent être récupérés via la classe FileInfo qui possède la propriété Attributes (hérité de FileSystemInfo)

Mis à jour le 1er novembre 2017 ericlm128 Jérôme Lambert

La méthode statique GetRandomFileName de la classe Path permet de générer un nom aléatoire unique, utilisable pour la création d'un fichier ou d'un répertoire. Contrairement à GetTempFileName, aucun fichier n'est créé, et seul un nom est retourné.

Code c# : Sélectionner tout
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

Mis à jour le 1er novembre 2017 ericlm128 François DORIN Jérôme Lambert

La classe Path possède la méthode statique GetTempFileName générant un fichier temporaire de 0 octet dans le répertoire temporaire de l'utilisateur courant et retournant son chemin complet :

Code c# : Sélectionner tout
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

Mis à jour le 16 août 2017 ericlm128 François DORIN 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 dossier temporaire : {0}", System.IO.Path.GetTempPath());

Mis à jour le 16 août 2017 ericlm128 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 16 août 2017 ericlm128 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
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); 
}

Mis à jour le 16 août 2017 ericlm128 François DORIN 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
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); 
}

Mis à jour le 16 août 2017 ericlm128 François DORIN Jérôme Lambert

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

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

Mis à jour le 14 août 2017 dev01 ericlm128

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 -