Gestione di file e I/O (C++/CLI)

Articolo
10/12/2023

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 GetFiles GetFiles 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 sui file per Notepad.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

Condividi tramite

Gestione di file e I/O (C++/CLI)

Enumerare i file in una directory

Esempio

Monitorare le modifiche del file system

Esempio

Leggere un file binario

Esempio

Leggere un file di testo

Esempio

Recuperare informazioni sui file

Esempio

Scrivere un file binario

Esempio

Scrivere un file di testo

Esempio

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive