Control y E/S de archivos (C++/CLI)
Muestra varias operaciones de archivo mediante .NET Framework.
En los temas siguientes se muestra el uso de clases definidas en el espacio de nombres System.IO para realizar varias operaciones de archivo.
Enumeración de archivos en un directorio
En el ejemplo de código siguiente se muestra cómo recuperar una lista de los archivos de un directorio. Además, se enumeran los subdirectorios. En el ejemplo de código siguiente se usan los métodos GetFilesGetFiles y GetDirectories para mostrar el contenido del directorio C:\Windows.
Ejemplo
// 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;
}
Supervisión de los cambios realizados en el sistema de archivos
En el ejemplo de código siguiente se usa FileSystemWatcher para registrar eventos correspondientes a los archivos que se crean, cambian, eliminan o se cambian de nombre. En lugar de sondear periódicamente en un directorio los cambios en los archivos, puede usar la clase FileSystemWatcher a fin de activar eventos cuando se detecte un cambio.
Ejemplo
// 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( );
}
Lectura de un archivo binario
En el ejemplo de código siguiente se muestra cómo leer datos binarios de un archivo mediante dos clases del espacio de nombres System.IO: FileStream y BinaryReader. FileStream representa el archivo real. BinaryReader representa una interfaz de la secuencia que permite el acceso binario.
El ejemplo de código lee un archivo denominado data.bin y contiene enteros en formato binario. Para obtener información sobre este tipo de archivo, vea Procedimientos para escribir un archivo binario (C++/CLI).
Ejemplo
// 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;
}
Lectura de un archivo de texto
En el ejemplo de código siguiente se muestra cómo abrir y leer un archivo de texto línea por línea mediante la clase StreamReader definida en el espacio de nombres System.IO. Se usa una instancia de esta clase para abrir un archivo de texto y, después, se usa el método System.IO.StreamReader.ReadLine para recuperar cada línea.
En este ejemplo de código se lee un archivo denominado textfile.txt y que incluye texto. Para obtener información sobre este tipo de archivo, vea Procedimientos para escribir un archivo de texto (C++/CLI).
Ejemplo
// 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;
}
Recuperación de la información del archivo
En el ejemplo de código siguiente, se muestra la clase FileInfo. Cuando se tiene el nombre de un archivo, se puede utilizar esta clase para recuperar información sobre el archivo como, por ejemplo, tamaño, directorio, nombre completo, y fecha y hora de su creación y de la última modificación.
Este código recupera información del archivo para Notepad.exe.
Ejemplo
// 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;
}
Escritura de un archivo binario
En el siguiente ejemplo de código se muestra cómo escribir datos binarios en un archivo. Se usan dos clases del espacio de nombres System.IO: FileStream y BinaryWriter. La clase FileStream representa al propio archivo, mientras que la clase BinaryWriter proporciona una interfaz a la secuencia que permite el acceso binario.
En el siguiente ejemplo de código se escribe un archivo que contiene enteros en formato binario. Este archivo se puede leer con el código en Procedimientos para leer un archivo binario (C++/CLI).
Ejemplo
// 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;
}
Escritura de un archivo de texto
En el ejemplo de código siguiente se muestra cómo crear un archivo de texto y escribir texto en él mediante la clase StreamWriter, que se define en el espacio de nombres System.IO. El constructor StreamWriter toma el nombre del archivo que se va a crear. Si el archivo existe, se sobrescribe (a menos que pase True como segundo argumento del constructor StringWriter).
Después, el archivo se archiva mediante las funciones Write y WriteLine.
Ejemplo
// 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;
}
Consulte también
Programación de .NET con C++/CLI (Visual C++)
E/S de archivos y secuencias
System.IO namespace
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de