Gestione di file e I/O (C++/CLI)
Illustra varie operazioni sui file con .NET Framework.
Negli argomenti seguenti viene illustrato l'uso di classi definite nello spazio dei System.IO nomi per eseguire varie operazioni sui file.
Enumerare i file in una directory
Nell'esempio di codice seguente viene illustrato come recuperare un elenco dei file in una directory. Inoltre, le sottodirectory vengono enumerate. Nell'esempio di codice seguente vengono usati i GetFilesGetFiles metodi e GetDirectories per visualizzare il contenuto della directory C:\Windows.
Esempio
// 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;
}
Monitorare le modifiche del file system
Nell'esempio di codice seguente viene FileSystemWatcher usato per registrare gli eventi corrispondenti ai file creati, modificati, eliminati o rinominati. Anziché eseguire periodicamente il polling di una directory per le modifiche apportate ai file, è possibile usare la FileSystemWatcher classe per generare eventi quando viene rilevata una modifica.
Esempio
// 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( );
}
Leggere un file binario
Nell'esempio di codice seguente viene illustrato come leggere i dati binari da un file usando due classi dello spazio dei System.IO nomi : FileStream e BinaryReader. FileStream rappresenta il file effettivo. BinaryReader fornisce un'interfaccia al flusso che consente l'accesso binario.
L'esempio di codice legge un file denominato data.bin e contiene numeri interi in formato binario. Per informazioni su questo tipo di file, vedere Procedura: Scrivere un file binario (C++/CLI).
Esempio
// 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;
}
Leggere un file di testo
Nell'esempio di codice seguente viene illustrato come aprire e leggere un file di testo una riga alla volta usando la StreamReader classe definita nello spazio dei System.IO nomi . Un'istanza di questa classe viene utilizzata per aprire un file di testo e quindi il System.IO.StreamReader.ReadLine metodo viene usato per recuperare ogni riga.
Questo esempio di codice legge un file denominato textfile.txt e contiene testo. Per informazioni su questo tipo di file, vedere Procedura: Scrivere un file di testo (C++/CLI).
Esempio
// 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;
}
Recuperare informazioni sui file
Nell'esempio di codice seguente viene illustrata la FileInfo classe . Quando si dispone del nome di un file, è possibile usare questa classe per recuperare informazioni sul file, ad esempio le dimensioni del file, la directory, il nome completo e la data e l'ora di creazione e dell'ultima modifica.
Questo codice recupera le informazioni sul file per Blocco note.exe.
Esempio
// 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;
}
Scrivere un file binario
Nell'esempio di codice seguente viene illustrata la scrittura di dati binari in un file. Vengono usate due classi dello System.IO spazio dei nomi: FileStream e BinaryWriter. FileStream rappresenta il file effettivo, mentre BinaryWriter fornisce un'interfaccia al flusso che consente l'accesso binario.
Nell'esempio di codice seguente viene scritto un file contenente numeri interi in formato binario. Questo file può essere letto con il codice in Procedura: Leggere un file binario (C++/CLI).
Esempio
// 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;
}
Scrivere un file di testo
Nell'esempio di codice seguente viene illustrato come creare un file di testo e scrivervi testo usando la StreamWriter classe , definita nello spazio dei System.IO nomi . Il StreamWriter costruttore accetta il nome del file da creare. Se il file esiste, viene sovrascritto (a meno che non si passi True come secondo StringWriter argomento del costruttore).
Il file viene quindi archiviato usando le Write funzioni e WriteLine .
Esempio
// 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;
}
Vedi anche
Programmazione .NET con C++/CLI (Visual C++)
I/O di file e di flussi
spazio dei nomi System.IO
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per