Udostępnij za pośrednictwem

Obsługa plików i we/wy (C++/CLI)

  • Artykuł

Demonstruje różne operacje na plikach przy użyciu programu .NET Framework.

W poniższych tematach pokazano użycie klas zdefiniowanych w System.IO przestrzeni nazw do wykonywania różnych operacji na plikach.

Wyliczanie plików w katalogu

W poniższym przykładzie kodu pokazano, jak pobrać listę plików w katalogu. Ponadto podkatalogi są wyliczane. Poniższy przykład kodu używa GetFilesGetFiles metod i GetDirectories do wyświetlania zawartości katalogu C:\Windows.

Przykład

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

Monitorowanie zmian systemu plików

Poniższy przykład kodu używa FileSystemWatcher metody do rejestrowania zdarzeń odpowiadających tworzonym plikom, zmienianym, usuwanym lub zmienianym. Zamiast okresowo sondować katalog pod kątem zmian w plikach, można użyć FileSystemWatcher klasy do uruchamiania zdarzeń po wykryciu zmiany.

Przykład

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

Odczytywanie pliku binarnego

W poniższym przykładzie kodu pokazano, jak odczytywać dane binarne z pliku przy użyciu dwóch klas z System.IO przestrzeni nazw: FileStream i BinaryReader. FileStream reprezentuje rzeczywisty plik. BinaryReader udostępnia interfejs strumienia, który umożliwia dostęp binarny.

Przykładowy kod odczytuje plik o nazwie data.bin i zawiera liczby całkowite w formacie binarnym. Aby uzyskać informacje na temat tego rodzaju pliku, zobacz Instrukcje: zapisywanie pliku binarnego (C++/CLI).

Przykład

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

Odczytywanie pliku tekstowego

W poniższym przykładzie kodu pokazano, jak otworzyć i odczytać plik tekstowy w jednym wierszu przy użyciu StreamReader klasy zdefiniowanej System.IO w przestrzeni nazw. Wystąpienie tej klasy służy do otwierania pliku tekstowego, a następnie System.IO.StreamReader.ReadLine metoda jest używana do pobierania każdego wiersza.

Ten przykładowy kod odczytuje plik o nazwie textfile.txt i zawiera tekst. Aby uzyskać informacje na temat tego rodzaju pliku, zobacz How to: Write a Text File (C++/CLI) (Instrukcje: pisanie pliku tekstowego (C++/CLI).

Przykład

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

Pobieranie informacji o pliku

W poniższym przykładzie kodu pokazano klasę FileInfo . Jeśli masz nazwę pliku, możesz użyć tej klasy, aby pobrać informacje o pliku, takie jak rozmiar pliku, katalog, pełna nazwa i data i godzina utworzenia oraz ostatniej modyfikacji.

Ten kod pobiera informacje o plikach dla Notepad.exe.

Przykład

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

Pisanie pliku binarnego

W poniższym przykładzie kodu pokazano zapisywanie danych binarnych w pliku. Używane są dwie klasy z System.IO przestrzeni nazw: FileStream i BinaryWriter. FileStream reprezentuje rzeczywisty plik, a jednocześnie BinaryWriter udostępnia interfejs strumienia, który umożliwia dostęp binarny.

Poniższy przykład kodu zapisuje plik zawierający liczby całkowite w formacie binarnym. Ten plik można odczytać za pomocą kodu w temacie Instrukcje: Odczytywanie pliku binarnego (C++/CLI).

Przykład

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

Pisanie pliku tekstowego

W poniższym przykładzie kodu pokazano, jak utworzyć plik tekstowy i napisać do niego tekst przy użyciu StreamWriter klasy zdefiniowanej System.IO w przestrzeni nazw. Konstruktor StreamWriter przyjmuje nazwę pliku do utworzenia. Jeśli plik istnieje, zostanie zastąpiony (chyba że zostanie przekazany wartość True jako drugi StringWriter argument konstruktora).

Plik zostanie następnie złożony przy użyciu Write funkcji i WriteLine .

Przykład

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

Zobacz też

Programowanie .NET w języku C++/interfejsie wiersza polecenia (Visual C++)
We/Wy plików i strumieni
System.IO przestrzeni nazw