FAQ ASP.NET/C#
FAQ ASP.NET/C#Consultez toutes les FAQ
Nombre d'auteurs : 39, nombre de questions : 371, dernière mise à jour : 15 juin 2021
- J'ai besoin de connaître le répertoire physique de mon application ASP.NET. Comment faire ?
- Comment afficher tous les fichiers d'un répertoire du serveur ?
- Comment créer, copier, déplacer, supprimer un fichier ?
- Comment lire et écrire dans un fichier texte ?
- Comment obtenir la liste des fichiers et des sous-répertoires d'un répertoire ?
- Comment lister les répertoires d'une application ?
- Comment lister les fichiers d'un répertoire ?
- Comment connaître la taille totale du contenu d'un répertoire ?
- Comment lire un fichier ligne par ligne ?
- Comment récupérer le content-type d'un fichier ?
- Comment connaître la taille d'un fichier ?
- Comment permettre d'utiliser des fichiers de manière relative ?
Pour lister les fichiers d'un répertoire ou pour accéder à une base de données Access, il nous est parfois nécessaire de savoir l'adresse exacte du répertoire physique dans lequel se trouve l'application. Cela est possible à l'aide de:
string
PhysicalPath =
Server.
MapPath
(
"nomfichier.mdb"
);
Cet exemple initialisera PhysicalPath avec l'adresse physique du fichier nomfichier.mdb.
Nous allons afficher tous les fichiers d'un répertoire dans une ListBox :
DirectoryInfo dir =
new
DirectoryInfo
(
"C:
\\
MonChemin"
);
MalLsttBox.
DataSource =
dir.
GetFiles
(
"*.*"
);
MalLsttBox.
DataBind
(
);
Note : Attention à bien paramétrer vos droits de manière à ce que le user ASPNET puisse parcourir le répertoire ;)
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
{
//Création d'un fichier vide.
FileStream fs =
File.
Create
(
"myfile.txt"
);
fs.
Close
(
);
Debug.
WriteLine
(
"fichier myfile.txt créé"
);
// Copie de fichier
File.
Copy
(
"myfile.txt"
,
"copyofmyfile.txt"
);
Debug.
WriteLine
(
"fichier myfile.txt copié vers copyofmyfile.txt"
);
// Déplacement de fichier
File.
Move
(
"copyofmyfile.txt"
,
@"c:\copyofmyfile.txt"
);
Debug.
WriteLine
(
@"fichier copyofmyfile.txt déplacé vers c:\copyofmyfile.txt"
);
// Suppression de fichier
File.
Delete
(
@"c:\copyofmyfile.txt"
);
Debug.
WriteLine
(
@"Fichier c:\copyofmyfile.txt supprimé"
);
}
catch
(
Exception e)
{
Debug.
WriteLine
(
ex.
ToString
(
));
Debug.
WriteLine
(
ex.
Message);
}
}
Lien : System.IO.File
Nous allons ouvrir un fichier texte et le remplir s'il n'existe pas encore. Nous afficherons ensuite son contenu à l'écran. On utiliser 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))
{
// 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);
Debug.
WriteLine
(
"Début du fichier"
);
line =
sr.
ReadLine
(
);
while
(
line !=
null
)
{
Debug.
WriteLine
(
line);
line =
sr.
ReadLine
(
);
}
Debug.
WriteLine
(
"Fin du fichier"
);
}
finally
{
// Fermeture streamreader
if
(
sr !=
null
)
sr.
Close
(
);
// Fermeture streamwriter
if
(
sw !=
null
)
sw.
Close
(
);
}
}
Lien : System.IO.StreamWriter
Lien : System.IO.StreamReader
On utilise la fonction GetFileSystemEntries de la classe System.IO.Directory
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++
)
Response.
Write
(
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
Il nous est souvent nécessaire de lister les répertoires présents dans le répertoire d'une application
ASP.NET. Pour cela, il suffit de boucler sur la liste des DirectoryInfo renvoyés par
l'intermédiaire de la méthode GetDirectories de cette même classe DirectoryInfo.
Attention que la base de l'application doit être récupérée par l'intermédiaire de
Server.
MapPath
(
"."
);
ce qui donne ...
System.
IO.
DirectoryInfo di =
new
System.
IO.
DirectoryInfo
(
Server.
MapPath
(
"."
));
foreach
(
System.
IO.
DirectoryInfo di2 in
di.
GetDirectories
(
))
{
Response.
Write
(
di2.
FullName);
// Traitement quelconque
}
Bien entendu vous pouvez (voire devez) gérer les exceptions du type "Répertoire inexistant" ou encore "Accès interdit".
Comme pour le listage des répertoires, une simple boucle suffit. DirectoryInfo fournit une
méthode GetFiles qui se chargent de renvoyer la liste des fichiers du répertoires.
Il ne reste plus dès lors qu'à effectuer un traitement sur chacun des fichiers de cette liste.
System.
IO.
DirectoryInfo di =
new
System.
IO.
DirectoryInfo
(
Server.
MapPath
(
"."
));
foreach
(
System.
IO.
FileInfo fi in
di.
GetFiles
(
))
{
Response.
Write
(
fi.
FullName);
// Traitement quelconque
}
Bien entendu vous pouvez (voire devez) gérer les exceptions du type "Répertoire inexistant" ou encore "Accès interdit".
Pour connaître la taille du contenu, il suffit d'additionner la taille de chacun des fichiers de ce répertoire.
Voici une petite fonction permet d'effectuer cette opération.
public
int
DirectoryLength
(
string
relativePath)
{
int
bytes =
0
;
System.
IO.
DirectoryInfo di =
new
System.
IO.
DirectoryInfo
(
Server.
MapPath
(
relativePath));
foreach
(
System.
IO.
FileInfo fi in
di.
GetFiles
(
))
{
bytes +=
fi.
Length;
}
return
bytes;
}
Bien entendu vous pouvez (voire devez) gérer les exceptions du type "Répertoire inexistant" ou encore "Accès interdit".
Certes XML et les bases de données prennent de plus en plus de place dans le monde
de l'informatique mais les fichiers dits "classiques" sont toujours bel et bien présents.
Voici comme lire un fichier et, ce, ligne par ligne.
Tout d'abord il faut utiliser le namespace System.IO.
using
System.
IO;
Pour lire tout le fichier, il suffit de boucler sur toutes les lignes du fichier.
public
void
ReadByLine
(
string
path)
{
StreamReader sr;
try
{
sr =
new
StreamReader
(
path);
string
contenu;
while
((
contenu =
sr.
ReadLine
(
))!=
null
)
{
// Utiliser ce contenu
// Par exemple ajout d'une ListBox, ...
}
}
catch
(
Exception)
{
// Gestion de l'exception (FileNotFound, ...
// (redirection, ...)
}
finally
{
sr.
Close
(
);
}
}
Les content-types se trouvent dans la base de registres. Il "suffit" de parcourir les associations
extension / content-type pour retrouver celle qui correspond à l'extension de notre fichier.
Voici une fonction permettant d'effectuer cette recherche.
public
static
string
GetMIMEType
(
string
filepath)
{
RegistryPermission regPerm =
new
RegistryPermission
(
RegistryPermissionAccess.
Read,
"
\\
HKEY_CLASSES_ROOT"
);
RegistryKey classesRoot =
Registry.
ClassesRoot;
FileInfo fi =
new
FileInfo
(
filepath);
String dotExt =
fi.
Extension.
ToLower
(
);
RegistryKey typeKey =
classesRoot.
OpenSubKey
(
@"MIME\Database\Content Type"
);
String Keyname =
""
;
foreach
(
string
keyname in
typeKey.
GetSubKeyNames
(
))
{
RegistryKey curKey =
classesRoot.
OpenSubKey
(
@"MIME\Database\Content Type\"
+
keyname);
if
((
String)curKey.
GetValue
(
"Extension"
) ==
dotExt)
{
Keyname =
keyname;
}
}
return
Keyname;
}
Sans oublier d'importer les namespaces suivants:
using
System.
IO;
using
System.
Security.
Permissions;
using
Microsoft.
Win32;
Il suffit d'utiliser
int
BytesSize =
FileInfo
(
"nomfichier.ext"
).
Length;
Lorsque vous ouvrez un fichier texte, par exemple, il vous faut savoir l'adresse physique de ce fichier. Malheureusement, nous ne connaissons que le chemin relatif bien souvent.
Server.MapPath est là pour nous aider. En lui passant le chemin relatif, Server.MapPath renverra le chemin physique complet.
Cela donne, dans l'exemple de l'ouverture d'un flux sur le fichier texte :
Fs.
Open
(
Server.
MapPath
(
"./adresserelative/fichier.txt"
));