Bestandsverwerking en I/O (C++/CLI)

Demonstreert verschillende bestandsbewerkingen met behulp van .NET Framework.

De volgende onderwerpen laten zien hoe klassen die in de System.IO naamruimte zijn gedefinieerd, worden gebruikt om verschillende bestandsbewerkingen uit te voeren.

Bestanden in een map opsommen

In het volgende codevoorbeeld ziet u hoe u een lijst met de bestanden in een map ophaalt. Daarnaast worden de submappen opgesomd. In het volgende codevoorbeeld worden de GetFiles GetFiles en GetDirectories methoden gebruikt om de inhoud van de map C:\Windows weer te geven.

Voorbeeld

// 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;
}

Wijzigingen in bestandssysteem bewaken

In het volgende codevoorbeeld wordt gebruikgemaakt FileSystemWatcher van het registreren van gebeurtenissen die overeenkomen met bestanden die worden gemaakt, gewijzigd, verwijderd of hernoemd. In plaats van periodiek een map te peilen voor wijzigingen in bestanden, kunt u de FileSystemWatcher klasse gebruiken om gebeurtenissen te activeren wanneer er een wijziging wordt gedetecteerd.

Voorbeeld

// 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( );
}

Een binair bestand lezen

In het volgende codevoorbeeld ziet u hoe u binaire gegevens uit een bestand kunt lezen met behulp van twee klassen uit de System.IO naamruimte: FileStream en BinaryReader. FileStream vertegenwoordigt het werkelijke bestand. BinaryReader biedt een interface voor de stream die binaire toegang toestaat.

Het codevoorbeeld leest een bestand met de naam data.bin en bevat gehele getallen in binaire indeling. Zie How to: Write a Binary File (C++/CLI) (Een binair bestand schrijven) voor informatie over dit type bestand.

Voorbeeld

// 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;
}

Een tekstbestand lezen

In het volgende codevoorbeeld ziet u hoe u een tekstbestand één regel tegelijk opent en leest met behulp van de StreamReader klasse die is gedefinieerd in de System.IO naamruimte. Een exemplaar van deze klasse wordt gebruikt om een tekstbestand te openen en vervolgens wordt de System.IO.StreamReader.ReadLine methode gebruikt om elke regel op te halen.

Dit codevoorbeeld leest een bestand met de naam textfile.txt en bevat tekst. Zie How to: Write a Text File (C++/CLI) voor informatie over dit type bestand.

Voorbeeld

// 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;
}

Bestandsgegevens ophalen

In het volgende codevoorbeeld ziet u de FileInfo klasse. Wanneer u de naam van een bestand hebt, kunt u deze klasse gebruiken om informatie over het bestand op te halen, zoals de bestandsgrootte, de map, de volledige naam en de datum en tijd van het maken en van de laatste wijziging.

Met deze code worden bestandsgegevens voor Notepad.exeopgehaald.

Voorbeeld

// 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;
}

Een binair bestand schrijven

In het volgende codevoorbeeld ziet u hoe u binaire gegevens naar een bestand schrijft. Er worden twee klassen uit de System.IO naamruimte gebruikt: FileStream en BinaryWriter. FileStream vertegenwoordigt het werkelijke bestand en biedt een BinaryWriter interface voor de stream die binaire toegang toestaat.

In het volgende codevoorbeeld wordt een bestand met gehele getallen in binaire indeling geschreven. Dit bestand kan worden gelezen met de code in Procedure: Een binair bestand lezen (C++/CLI).>

Voorbeeld

// 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;
}

Een tekstbestand schrijven

In het volgende codevoorbeeld ziet u hoe u een tekstbestand maakt en er tekst naar schrijft met behulp van de StreamWriter klasse, die is gedefinieerd in de System.IO naamruimte. De StreamWriter constructor neemt de naam van het bestand dat moet worden gemaakt. Als het bestand bestaat, wordt het overschreven (tenzij u True doorgeeft als het tweede StringWriter constructorargument).

Het bestand wordt vervolgens opgeslagen met behulp van de Write en WriteLine functies.

Voorbeeld

// 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;
}

Zie ook

.NET-programmering met C++/CLI (Visual C++)
Bestands- en Stream-I/O
System.IO naamruimte

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-07

Delen via

Bestandsverwerking en I/O (C++/CLI)

Bestanden in een map opsommen

Voorbeeld

Wijzigingen in bestandssysteem bewaken

Voorbeeld

Een binair bestand lezen

Voorbeeld

Een tekstbestand lezen

Voorbeeld

Bestandsgegevens ophalen

Voorbeeld

Een binair bestand schrijven

Voorbeeld

Een tekstbestand schrijven

Voorbeeld

Zie ook

Feedback

Aanvullende resources