Dela via

Filhantering och I/O (C++/CLI)

Visar olika filåtgärder med hjälp av .NET Framework.

Följande avsnitt visar hur du använder klasser som definierats i System.IO namnområdet för att utföra olika filåtgärder.

Räkna upp filer i en katalog

Följande kodexempel visar hur du hämtar en lista över filerna i en katalog. Dessutom räknas underkatalogerna upp. I följande kodexempel används GetFilesGetFiles metoderna och GetDirectories för att visa innehållet i katalogen C:\Windows.

Exempel

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

Övervaka filsystemändringar

I följande kodexempel används FileSystemWatcher för att registrera händelser som motsvarar filer som skapas, ändras, tas bort eller byt namn. I stället för att regelbundet avsöka en katalog för ändringar i filer kan du använda FileSystemWatcher klassen för att utlösa händelser när en ändring identifieras.

Exempel

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

Läsa en binär fil

I följande kodexempel visas hur du läser binära data från en fil med hjälp av två klasser från System.IO namnområdet: FileStream och BinaryReader. FileStream representerar den faktiska filen. BinaryReader tillhandahåller ett gränssnitt till strömmen som tillåter binär åtkomst.

Kodexemplet läser en fil med namnet data.bin och innehåller heltal i binärt format. Information om den här typen av fil finns i Så här skriver du en binär fil (C++/CLI).

Exempel

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

Läsa en textfil

Följande kodexempel visar hur du öppnar och läser en textfil en rad i taget med hjälp av klassen StreamReader som definieras i System.IO namnområdet. En instans av den här klassen används för att öppna en textfil och sedan System.IO.StreamReader.ReadLine används metoden för att hämta varje rad.

Det här kodexemplet läser en fil med namnet textfile.txt och innehåller text. Information om den här typen av fil finns i Så här skriver du en textfil (C++/CLI).

Exempel

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

Hämta filinformation

I följande kodexempel visas FileInfo klassen. När du har namnet på en fil kan du använda den här klassen för att hämta information om filen, till exempel filstorlek, katalog, fullständigt namn och datum och tidpunkt för skapandet och den senaste ändringen.

Den här koden hämtar filinformation för Notepad.exe.

Exempel

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

Skriva en binär fil

Följande kodexempel visar hur du skriver binära data till en fil. Två klasser från System.IO namnområdet används: FileStream och BinaryWriter. FileStream representerar den faktiska filen, medan BinaryWriter tillhandahåller ett gränssnitt till strömmen som tillåter binär åtkomst.

I följande kodexempel skrivs en fil som innehåller heltal i binärt format. Den här filen kan läsas med koden i Så här: Läs en binär fil (C++/CLI).

Exempel

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

Skriva en textfil

Följande kodexempel visar hur du skapar en textfil och skriver text till den StreamWriter med hjälp av klassen, som definieras i System.IO namnområdet. Konstruktorn StreamWriter tar namnet på filen som ska skapas. Om filen finns skrivs den över (såvida du inte skickar True som det andra StringWriter konstruktorargumentet).

Filen arkiveras sedan med hjälp av Write funktionerna och WriteLine .

Exempel

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

Se även

.NET-programmering med C++/CLI (Visual C++)
Fil- och stream-I/O
System.IO namnområde