|
| auteur : abelman |
Pour créer, copier, déplacer ou supprimer un fichier, on utilise la classe System.IO.File
using System.IO;
using System;
public static void FileTests()
{
try
{
FileStream fs = File.Create("myfile.txt");
fs.Close();
Console.WriteLine("fichier myfile.txt créé");
File.Copy("myfile.txt", "copyofmyfile.txt");
Console.WriteLine("fichier myfile.txt copié vers copyofmyfile.txt");
File.Move("copyofmyfile.txt", @"c:\copyofmyfile.txt");
Console.WriteLine(@"fichier copyofmyfile.txt déplacé vers c:\copyofmyfile.txt");
File.Delete(@"c:\copyofmyfile.txt");
Console.WriteLine(@"Fichier c:\copyofmyfile.txt supprimé");
}
catch (Exception e)
{
Debug.WriteLine(ex.ToString());
Console.WriteLine(ex.Message);
}
}
|
|
lien :  System.IO.File (MSDN)
|
|
| auteur : abelman |
On utilise la méthode GetAttributes de la classe System.IO.File
using System.IO;
static void GetFileAttributes(string sFilename)
{
FileAttributes flagAttr = File.GetAttributes(sFilename);
Console.WriteLine("Créé le {0} à {1}",
File.GetCreationTime(sFilename).ToShortDateString(),
File.GetCreationTime(sFilename).ToShortTimeString());
Console.WriteLine("Modifié le {0} à {1}",
File.GetLastWriteTime(sFilename).ToShortDateString(),
File.GetLastWriteTime(sFilename).ToShortTimeString());
Console.WriteLine("Dernier accès le {0} à {1}",
File.GetLastAccessTime(sFilename).ToShortDateString(),
File.GetLastAccessTime(sFilename).ToShortTimeString());
Console.WriteLine("Attributs de {0}", sFilename);
if ((flagAttr & FileAttributes.Archive) == FileAttributes.Archive)
Console.WriteLine(FileAttributes.Archive.ToString());
if ((flagAttr & FileAttributes.Compressed) == FileAttributes.Compressed)
Console.WriteLine(FileAttributes.Compressed.ToString());
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());
if ((flagAttr & FileAttributes.Hidden) == FileAttributes.Hidden)
Console.WriteLine(FileAttributes.Hidden.ToString());
if ((flagAttr & FileAttributes.Normal) == FileAttributes.Normal)
Console.WriteLine(FileAttributes.Normal.ToString());
if ((flagAttr & FileAttributes.NotContentIndexed) == FileAttributes.NotContentIndexed)
Console.WriteLine(FileAttributes.NotContentIndexed.ToString());
if ((flagAttr & FileAttributes.Offline) == FileAttributes.Offline)
Console.WriteLine(FileAttributes.Offline.ToString());
if ((flagAttr & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
Console.WriteLine(FileAttributes.ReadOnly.ToString());
if ((flagAttr & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint)
Console.WriteLine(FileAttributes.ReparsePoint.ToString());
if ((flagAttr & FileAttributes.SparseFile) == FileAttributes.SparseFile)
Console.WriteLine(FileAttributes.SparseFile.ToString());
if ((flagAttr & FileAttributes.System) == FileAttributes.System)
Console.WriteLine(FileAttributes.System.ToString());
if ((flagAttr & FileAttributes.Temporary) == FileAttributes.Temporary)
Console.WriteLine(FileAttributes.Temporary.ToString());
}
|
|
lien : System.IO.File (MSDN)
|
|
| auteur : abelman |
On utilise la fonction GetFileSystemEntries de la classe System.IO.Directory
using System.IO;
using System;
static void Dir(string directory)
{
string[] files;
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 System.IO.Directory.GetFiles()
|
lien : System.IO.Directory (MSDN)
|
|
| auteur : 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
using System;
using System.IO
void FichierTexte(string nomFichier)
{
StreamReader sr = null;
StreamWriter sw = null;
string line;
try
{
if (!File.Exists(nomFichier))
{
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;
}
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
{
if (sr != null) sr.Close();
if (sw != null) sw.Close();
}
}
|
|
lien : System.IO.StreamWriter (MSDN)
lien : System.IO.StreamReader (MSDN)
|
|
| auteur : 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.
using System.IO;
using System;
void FichierBinaire(string NomFichier)
{
BinaryReader br = null;
BinaryWriter bw = null;
FileStream fs = null;
try
{
if (!File.Exists(NomFichier))
{
bw = new BinaryWriter(File.Create(NomFichier));
for (int i = 0; i < 10; i++)
bw.Write(i);
bw.Close();
}
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();
}
}
|
|
lien : System.IO.BinaryReader (MSDN)
lien : System.IO.BinaryWriter (MSDN)
|
|
| auteur : 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.
void Watch(string path, string filter)
{
FileSystemWatcher fw = new FileSystemWatcher(path, filter);
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);
fw.IncludeSubdirectories = true;
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
|
lien : System.IO.FileSystemWatcher (MSDN)
|
|
| auteur : Thomas Lebrun |
Vous devez utiliser la méthode GetFileName de la classe System.IO.Path qui vous permet de récupérer le nom du fichier.
string fileName = "C:\\toto.tx";
string name = System.IO.Path.GetFileName(fileName);
Console.WriteLine(name);
|
|
|
| auteurs : Thomas Lebrun, tomlev |
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 :
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.
|
|
| auteur : Webman |
Tout d'abord pensez à ajouter ces deux "Imports" sans quoi il n'est pas possible d'utiliser le code donné en exemple.
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éé.
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;
}
}
|
|
lien : System.IO.Compression (MSDN)
|
|
| auteur : Webman |
Tout d'abord pensez à ajouter ces deux "using" sans quoi il n'est pas possible d'utiliser le code donné en exemple.
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é.
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;
}
}
|
|
lien : System.IO.Compression (MSDN)
|
|
| auteur : HULK |
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.
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);
}
}
|
|
|
| auteur : cardi |
On utilise la fonction GetFileSystemEntries à travers une méthode récursive afin de scanner tous les sous-répertoires.
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);
}
}
}
|
|
|
| auteur : doudouallemand |
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 :
FileStream photoStream = new FileStream("C:\\monimage.jpeg",
FileMode.Open);
pictureBox1.Image = Image.FromStream(photoStream);
photoStream.Close();
File.Delete("C:\\monimage.jpeg");
|
|
lien : System.IO.FileStream (MSDN)
lien : Image.FromStream (MSDN)
|
|
| auteur : cardi |
Grâce à la classe File, il est possible de récupérer les attributs (Archive, Lecture seule, ...) d'un fichier :
FileAttributes Fa = File.GetAttributes(@"C:\text.txt");
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");
|
|
lien : System.IO.File (MSDN)
lien : FAQ C#
|
|
| auteur : cardi |
La méthode statique GetRandomFileName de la classe Path permet de générer un nom de fichier avec extension aléatoire :
Console.WriteLine("Nom de fichier généré : {0}", System.IO.Path.GetRandomFileName());
|
|
|
| auteur : cardi |
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 :
string monFichierTemporaire = System.IO.Path.GetTempFileName();
Console.WriteLine("Nom du fichier temporaire : {0}", monFichierTemporaire);
|
|
|
| auteur : cardi |
On utilise la méthode statique GetTempPath de la classe Path permettant de récupérer le répertoire temporaire de l'utilisateur courant :
Console.WriteLine("Nom du fichier temporaire : {0}", System.IO.Path.GetTempPath());
|
|
|
| auteur : cardi |
On utilisera la méthode Delete de la classe Directory pour supprimer un répertoire et tout ce qu'il contient :
string path = @"C:\Test\Test";
try
{
System.IO.Directory.Delete(path, true);
}
catch (Exception exc)
{
Console.WriteLine("Répertoire {0} impossible à supprimer !\nErreur: {1}", path, exc.Message);
}
|
|
|
| auteur : cardi |
On utilisera la méthode Length de la classe FileInfo pour récupérer la taille d'un fichier :
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);
}
|
|
|
| auteur : cardi |
On utilisera la méthode statique Exists de la classe Directory pour vérifier qu'un répertoire existe :
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);
|
|
|
| auteur : dev01 |
Renommer un fichier est en fait une opération de déplacement.
string monAncienFichier, monNouveauFichier;
monAncienFichier = "toto.txt";
monNouveauFichier = "tata.txt";
File.Move(monAncienFichier, monNouveauFichier);
|
|
|
| auteurs : cardi, tomlev |
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 :
String Chemin = "C:/";
String Fichier = "fichier.txt";
String CheminComplet = System.IO.Path.Combine(Chemin, Fichier);
|
|
lien : System.IO.Path.Combine (MSDN)
|
Consultez les autres F.A.Q's
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 © 2010 Developpez Developpez LLC.
Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne
peut être faite de ce site ni 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.
Comment compresser un fichier en utilisant GZip ?