Gestion de fichiers et E/S (C++/CLI)
Illustre différentes opérations de fichier à l’aide du .NET Framework.
Les rubriques suivantes illustrent l’utilisation de classes définies dans l’espace System.IO de noms pour effectuer différentes opérations de fichier.
Énumérer des fichiers dans un répertoire
L’exemple de code suivant montre comment récupérer une liste des fichiers dans un répertoire. En outre, les sous-répertoires sont énumérés. L’exemple de code suivant utilise les méthodes et GetDirectories les GetFilesGetFiles méthodes pour afficher le contenu du répertoire C :\Windows.
Exemple
// enum_files.cpp
// compile with: /clr
using namespace System;
using namespace System::IO;
int main()
{
String^ folder = "C:\\";
array<String^>^ dir = Directory::GetDirectories( folder );
Console::WriteLine("--== Directories inside '{0}' ==--", folder);
for (int i=0; i<dir->Length; i++)
Console::WriteLine(dir[i]);
array<String^>^ file = Directory::GetFiles( folder );
Console::WriteLine("--== Files inside '{0}' ==--", folder);
for (int i=0; i<file->Length; i++)
Console::WriteLine(file[i]);
return 0;
}
Surveiller les modifications apportées au système de fichiers
L’exemple de code suivant utilise FileSystemWatcher pour s’inscrire aux événements correspondant aux fichiers créés, modifiés, supprimés ou renommés. Au lieu d’interroger régulièrement un répertoire pour connaître les modifications apportées aux fichiers, vous pouvez utiliser la FileSystemWatcher classe pour déclencher des événements lorsqu’une modification est détectée.
Exemple
// monitor_fs.cpp
// compile with: /clr
#using <system.dll>
using namespace System;
using namespace System::IO;
ref class FSEventHandler
{
public:
void OnChanged (Object^ source, FileSystemEventArgs^ e)
{
Console::WriteLine("File: {0} {1}",
e->FullPath, e->ChangeType);
}
void OnRenamed(Object^ source, RenamedEventArgs^ e)
{
Console::WriteLine("File: {0} renamed to {1}",
e->OldFullPath, e->FullPath);
}
};
int main()
{
array<String^>^ args = Environment::GetCommandLineArgs();
if(args->Length < 2)
{
Console::WriteLine("Usage: Watcher.exe <directory>");
return -1;
}
FileSystemWatcher^ fsWatcher = gcnew FileSystemWatcher( );
fsWatcher->Path = args[1];
fsWatcher->NotifyFilter = static_cast<NotifyFilters>
(NotifyFilters::FileName |
NotifyFilters::Attributes |
NotifyFilters::LastAccess |
NotifyFilters::LastWrite |
NotifyFilters::Security |
NotifyFilters::Size );
FSEventHandler^ handler = gcnew FSEventHandler();
fsWatcher->Changed += gcnew FileSystemEventHandler(
handler, &FSEventHandler::OnChanged);
fsWatcher->Created += gcnew FileSystemEventHandler(
handler, &FSEventHandler::OnChanged);
fsWatcher->Deleted += gcnew FileSystemEventHandler(
handler, &FSEventHandler::OnChanged);
fsWatcher->Renamed += gcnew RenamedEventHandler(
handler, &FSEventHandler::OnRenamed);
fsWatcher->EnableRaisingEvents = true;
Console::WriteLine("Press Enter to quit the sample.");
Console::ReadLine( );
}
Lire un fichier binaire
L’exemple de code suivant montre comment lire des données binaires à partir d’un fichier, à l’aide de deux classes de l’espace System.IO de noms : FileStream et BinaryReader. FileStream représente le fichier réel. BinaryReader fournit une interface au flux qui autorise l’accès binaire.
L’exemple de code lit un fichier nommé data.bin et contient des entiers au format binaire. Pour plus d’informations sur ce type de fichier, consultez Guide pratique pour écrire un fichier binaire (C++/CLI).
Exemple
// binary_read.cpp
// compile with: /clr
#using<system.dll>
using namespace System;
using namespace System::IO;
int main()
{
String^ fileName = "data.bin";
try
{
FileStream^ fs = gcnew FileStream(fileName, FileMode::Open);
BinaryReader^ br = gcnew BinaryReader(fs);
Console::WriteLine("contents of {0}:", fileName);
while (br->BaseStream->Position < br->BaseStream->Length)
Console::WriteLine(br->ReadInt32().ToString());
fs->Close( );
}
catch (Exception^ e)
{
if (dynamic_cast<FileNotFoundException^>(e))
Console::WriteLine("File '{0}' not found", fileName);
else
Console::WriteLine("Exception: ({0})", e);
return -1;
}
return 0;
}
Lire un fichier texte
L’exemple de code suivant montre comment ouvrir et lire un fichier texte d’une ligne à la fois à l’aide de la StreamReader classe définie dans l’espace System.IO de noms. Une instance de cette classe est utilisée pour ouvrir un fichier texte, puis la System.IO.StreamReader.ReadLine méthode est utilisée pour récupérer chaque ligne.
Cet exemple de code lit un fichier nommé textfile.txt et contient du texte. Pour plus d’informations sur ce type de fichier, consultez Guide pratique pour écrire un fichier texte (C++/CLI).
Exemple
// text_read.cpp
// compile with: /clr
#using<system.dll>
using namespace System;
using namespace System::IO;
int main()
{
String^ fileName = "textfile.txt";
try
{
Console::WriteLine("trying to open file {0}...", fileName);
StreamReader^ din = File::OpenText(fileName);
String^ str;
int count = 0;
while ((str = din->ReadLine()) != nullptr)
{
count++;
Console::WriteLine("line {0}: {1}", count, str );
}
}
catch (Exception^ e)
{
if (dynamic_cast<FileNotFoundException^>(e))
Console::WriteLine("file '{0}' not found", fileName);
else
Console::WriteLine("problem reading file '{0}'", fileName);
}
return 0;
}
Récupérer des informations sur le fichier
L’exemple de code suivant illustre la FileInfo classe. Lorsque vous avez le nom d’un fichier, vous pouvez utiliser cette classe pour récupérer des informations sur le fichier, telles que la taille, le répertoire, le nom complet et la date et l’heure de création et de la dernière modification.
Ce code récupère les informations de fichier pour Bloc-notes Windows.exe.
Exemple
// file_info.cpp
// compile with: /clr
using namespace System;
using namespace System::IO;
int main()
{
array<String^>^ args = Environment::GetCommandLineArgs();
if (args->Length < 2)
{
Console::WriteLine("\nUSAGE : file_info <filename>\n\n");
return -1;
}
FileInfo^ fi = gcnew FileInfo( args[1] );
Console::WriteLine("file size: {0}", fi->Length );
Console::Write("File creation date: ");
Console::Write(fi->CreationTime.Month.ToString());
Console::Write(".{0}", fi->CreationTime.Day.ToString());
Console::WriteLine(".{0}", fi->CreationTime.Year.ToString());
Console::Write("Last access date: ");
Console::Write(fi->LastAccessTime.Month.ToString());
Console::Write(".{0}", fi->LastAccessTime.Day.ToString());
Console::WriteLine(".{0}", fi->LastAccessTime.Year.ToString());
return 0;
}
Écrire un fichier binaire
L’exemple de code suivant illustre l’écriture de données binaires dans un fichier. Deux classes de l’espace System.IO de noms sont utilisées : FileStream et BinaryWriter. FileStream représente le fichier réel, tandis que BinaryWriter fournit une interface au flux qui autorise l’accès binaire.
L’exemple de code suivant écrit un fichier contenant des entiers au format binaire. Ce fichier peut être lu avec le code dans How to : Read a Binary File (C++/CLI).
Exemple
// binary_write.cpp
// compile with: /clr
#using<system.dll>
using namespace System;
using namespace System::IO;
int main()
{
array<Int32>^ data = {1, 2, 3, 10000};
FileStream^ fs = gcnew FileStream("data.bin", FileMode::Create);
BinaryWriter^ w = gcnew BinaryWriter(fs);
try
{
Console::WriteLine("writing data to file:");
for (int i=0; i<data->Length; i++)
{
Console::WriteLine(data[i]);
w->Write(data[i]);
}
}
catch (Exception^)
{
Console::WriteLine("data could not be written");
fs->Close();
return -1;
}
fs->Close();
return 0;
}
Écrire un fichier texte
L’exemple de code suivant montre comment créer un fichier texte et y écrire du texte à l’aide de la StreamWriter classe, qui est définie dans l’espace System.IO de noms. Le StreamWriter constructeur prend le nom du fichier à créer. Si le fichier existe, il est remplacé (sauf si vous passez True en tant que deuxième StringWriter argument de constructeur).
Le fichier est ensuite déposé à l’aide des fonctions et WriteLine des Write fonctions.
Exemple
// text_write.cpp
// compile with: /clr
using namespace System;
using namespace System::IO;
int main()
{
String^ fileName = "textfile.txt";
StreamWriter^ sw = gcnew StreamWriter(fileName);
sw->WriteLine("A text file is born!");
sw->Write("You can use WriteLine");
sw->WriteLine("...or just Write");
sw->WriteLine("and do {0} output too.", "formatted");
sw->WriteLine("You can also send non-text objects:");
sw->WriteLine(DateTime::Now);
sw->Close();
Console::WriteLine("a new file ('{0}') has been written", fileName);
return 0;
}
Voir aussi
Programmation .NET avec C++/CLI (Visual C++)
Fichier et flux de données E/S
espace de noms System.IO