using namespace System::IO;
using namespace System;				
 
public: static void FileTests()
{
	try
	{
		//Création d'un fichier vide.
		FileStream ^fs = File::Create("myfile.txt");
 
		fs->Close();
		Console::WriteLine("fichier myfile.txt créé");
 
		// Copie de fichier
		File::Copy("myfile.txt", "copyofmyfile.txt");   
		Console::WriteLine("fichier myfile.txt copié vers copyofmyfile.txt");
 
		// Déplacement de fichier
		File::Move("copyofmyfile.txt", "c:\\copyofmyfile.txt");
		Console::WriteLine("fichier copyofmyfile.txt déplacé vers c:\\copyofmyfile.txt");
 
		// Suppression de fichier
		File::Delete("c:\\copyofmyfile.txt");
		Console::WriteLine("Fichier c:\\copyofmyfile.txt supprimé");
	}   
	catch  (Exception ^ex)
	{ 
		Console::WriteLine(ex->ToString());
		Console::WriteLine(ex->Message);
	}
}

static void GetFileAttributes(String ^sFilename)
{
	FileAttributes flagAttr = File::GetAttributes(sFilename);
 
	// Date de création
	Console::WriteLine("Créé le {0} à {1}", 
		File::GetCreationTime(sFilename).ToShortDateString(),
		File::GetCreationTime(sFilename).ToShortTimeString());
 
	// Date de la dernière modification
	Console::WriteLine("Modifié le {0} à {1}", 
		File::GetLastWriteTime(sFilename).ToShortDateString(),
		File::GetLastWriteTime(sFilename).ToShortTimeString());
 
	// Date du dernier accès
	Console::WriteLine("Dernier accès le {0} à {1}",
		File::GetLastAccessTime(sFilename).ToShortDateString(),
		File::GetLastAccessTime(sFilename).ToShortTimeString());
 
	Console::WriteLine("Attributs de {0}", sFilename);
 
	// Attribut Archive
	if ((flagAttr & FileAttributes::Archive) == FileAttributes::Archive) 
		Console::WriteLine(FileAttributes::Archive);
 
	// Attribut Compressé
	if ((flagAttr & FileAttributes::Compressed) == FileAttributes::Compressed) 
		Console::WriteLine(FileAttributes::Compressed);
 
	// Attribut Device
	if ((flagAttr & FileAttributes::Device) == FileAttributes::Device)
		Console::WriteLine(FileAttributes::Device);
 
	if ((flagAttr & FileAttributes::Directory) == FileAttributes::Directory)
		Console::WriteLine(FileAttributes::Directory);
 
	if ((flagAttr & FileAttributes::Encrypted) == FileAttributes::Encrypted )
		Console::WriteLine(FileAttributes::Encrypted);
 
	// Attribut caché
	if ((flagAttr & FileAttributes::Hidden) == FileAttributes::Hidden)
		Console::WriteLine(FileAttributes::Hidden);
 
	// Attribut Normal
	if ((flagAttr & FileAttributes::Normal) == FileAttributes::Normal)
		Console::WriteLine(FileAttributes::Normal);
 
	// Attibut non indexé
	if ((flagAttr & FileAttributes::NotContentIndexed) == FileAttributes::NotContentIndexed) 
		Console::WriteLine(FileAttributes::NotContentIndexed);
 
	// Attribut Offline
	if ((flagAttr & FileAttributes::Offline) == FileAttributes::Offline) 
		Console::WriteLine(FileAttributes::Offline);
 
	// Attribut ReadOnly
	if ((flagAttr & FileAttributes::ReadOnly) == FileAttributes::ReadOnly) 
		Console::WriteLine(FileAttributes::ReadOnly);
 
	// Attribut ReparsePoint
	if ((flagAttr & FileAttributes::ReparsePoint) == FileAttributes::ReparsePoint) 
		Console::WriteLine(FileAttributes::ReparsePoint);
 
	// Attribut SparseFile
	if ((flagAttr & FileAttributes::SparseFile) == FileAttributes::SparseFile)
		Console::WriteLine(FileAttributes::SparseFile);
 
	// Attribut System
	if ((flagAttr & FileAttributes::System) == FileAttributes::System) 
		Console::WriteLine(FileAttributes::System);
 
	// Attribut Temporary
	if ((flagAttr & FileAttributes::Temporary) == FileAttributes::Temporary)
		Console::WriteLine(FileAttributes::Temporary);
}

static void Dir(String ^directory)
{
	array<String ^> ^ files;
 
	// pour avoir les noms des fichiers et sous-répertoires
	files = Directory::GetFileSystemEntries(directory);
 
	for each (String ^file in files)
		Console::WriteLine(file);
}

void FichierTexte(String ^nomFichier)
{
	StreamReader ^sr;
	StreamWriter ^sw;
	String ^line;
	try
	{
		if (! File::Exists(nomFichier))
		{
			// Le fichier n'existe pas. On le crée.
			sw = gcnew StreamWriter(nomFichier);
			sw->WriteLine("Bonjour. Nous sommes le {0} et il est {1} ",
				DateTime::Now.ToLongDateString(),
				DateTime::Now.ToLongTimeString());
			sw->Close();
			// Remarque : On peut utiliser sw = File::AppendText(NomFichier) pour ajouter
			// du texte à un fichier existant
		}
		// Ouverture du fichier et écriture du contenu du fichier sur la console
		sr = gcnew StreamReader(nomFichier);
		Console::WriteLine("Début du fichier");
		line = sr->ReadLine();
		while (line != nullptr)
		{
			Console::WriteLine(line);
			line = sr->ReadLine();
		}
		// Remarque : on peut aussi utiliser ReadToEnd pour lire tout le fichier en une seule fois
		Console::WriteLine("Fin du fichier");
	}
	finally
	{
		// Fermeture streamreader
		if (sr != nullptr) sr->Close();
		// Fermeture streamwriter
		if (sw != nullptr) sw->Close();
	}
}

void FichierBinaire(String ^NomFichier)
{
	BinaryReader ^br;
	BinaryWriter ^bw;
	FileStream ^fs;
	try
	{
		if (!File::Exists(NomFichier))
		{
			// Le fichier n'existe pas. On le crée
			bw = gcnew BinaryWriter(File::Create(NomFichier));
			for (int i=0; i<10; i++)
				bw->Write(i);
			bw->Close();
		}
		// Ouverture du contenu du fichier et écriture sur la console
		fs = File::Open(NomFichier, FileMode::Open);
		br = gcnew BinaryReader(fs);
		while (fs->Position < fs->Length)
			Console::Write(br->ReadInt32());
		Console::WriteLine("\nFin du fichier");
	}
	finally
	{
		if (br!=nullptr) br->Close();
		if (bw!=nullptr) bw->Close();
	}
}

void OnChanged(Object ^source, FileSystemEventArgs ^e)
{
	Console::WriteLine("Fichier {0} {1}", e->FullPath, e->ChangeType);
}
void OnRenamed(Object ^source, RenamedEventArgs ^e)
{
	Console::WriteLine("Fichier {0} renommé en {1}", e->OldFullPath, e->FullPath);
}
 
void OnError(Object ^source, ErrorEventArgs ^e)
{
    Exception ^ex = e->GetException();
	Console::WriteLine(ex->ToString());
}
void Watch(String ^path, String ^filter)
{
    // On peut utiliser les '*' avec filter
 
    // Création de l'objet watcher
    FileSystemWatcher ^fw = gcnew FileSystemWatcher(path, filter);
 
    // On ajoute les handlers pour surveiller les événements qu'on souhaite.
    fw->Changed += gcnew FileSystemEventHandler(OnChanged);
    fw->Renamed += gcnew RenamedEventHandler(OnRenamed);
    fw->Created += gcnew FileSystemEventHandler(OnChanged);
    fw->Deleted += gcnew FileSystemEventHandler(OnChanged);
    fw->Error += gcnew ErrorEventHandler(OnError);
 
    // On surveillera aussi les sous répertoires
    fw->IncludeSubdirectories = true;
 
    // Mettre EnableRaisingEvents à true démarre la surveillance des modifications.
    // Mettre à false l'arrête. 
    fw->EnableRaisingEvents = true;   
}

// Pour surveiller l'activité du répertoire c:\rep
Watch("c:\\rep", "*");

String ^fileName = "C:\\toto.txt";
String ^name = System::IO::Path::GetFileName(fileName);
Console::WriteLine(name);

using namespace System::IO;
using namespace System::Text;				
StreamReader ^strReader = gcnew StreamReader(fileName, Encoding::Default);

if (System::IO::File::Exists("c:\\monfichier.txt"))
	//le fichier existe
else
	//le fichier n'existe pas

	// Récupération des attributs d'un fichier
	FileAttributes Fa = File::GetAttributes("C:\\text.txt");
	// Vérification si le fichier est en lecture seule
	if ((Fa & FileAttributes::ReadOnly) == FileAttributes::ReadOnly)
		Console::WriteLine("Ce fichier est en lecture seule !");
	else
		Console::WriteLine("Ce fichier n'est pas en lecture seule");

// Chemin de l'exécutable
// Pour les WinForms, on peut aussi utiliser Application::ExecutablePath
String ^ exepath = Environment::GetCommandLineArgs()[0]; 
// Répertoire de l'exécutable
String ^ exedir = exepath->Substring(0, exepath->LastIndexOf('\\'));

Console::WriteLine("Le répertoire courant est : {0}", Environment::CurrentDirectory);

Console::WriteLine("Le répertoire système est : {0}", Environment::SystemDirectory);

static void PrintSpecFolder()
{
	// Répertoire spéciaux
	Console::WriteLine("Répertoire spéciaux");
	System::Array ^ sfe = Enum::GetValues(Environment::SpecialFolder::typeid);
	for each (Environment::SpecialFolder s in sfe)
		Console::WriteLine(Environment::GetFolderPath(s));
}

static void PrintLogicalDrives()
{
	// Lecteurs logiques
	Console::WriteLine("Lecteurs logiques");
	array<String ^> ^drives = Environment::GetLogicalDrives();
	for each (String ^drive in drives)
		Console::WriteLine(drive);
}

using namespace System;
using namespace System::Management;
 
ManagementObject ^disque = gcnew ManagementObject("win32_logicaldisk.deviceid=\"c:\"");
disque->Get();
 
//Afficher toutes les propriétés du disque
String ^strProp;
for each(PropertyData ^d in disque->Properties)
	strProp += d->Name + "\n";
Console::WriteLine(strProp);
 
//Obtenir une propriété en particulier
strProp = disque->GetPropertyValue("VolumeSerialNumber")->ToString();
Console::WriteLine("n° série volume : " + strProp);

	// Parcours de la liste des disques durs
	for each (DriveInfo ^CurrentDrive in DriveInfo::GetDrives())
	{
		// Vérification qu'on a bien affaire à un disque dur de l'ordinateur
		if (CurrentDrive->DriveType == DriveType::Fixed)
		{
			// Calcul du pourcentage d'espace disque libre
			Double pourcentageLibre = safe_cast<Double>(safe_cast<Double>(CurrentDrive->AvailableFreeSpace) / safe_cast<Double>(CurrentDrive->TotalSize) * 100);
			Console::WriteLine("Espace libre de {0} >> {1}%", CurrentDrive->Name, Convert::ToInt16(pourcentageLibre));
		}
	}

	String ^ monDrive = "D:\\";
	try
	{
		DriveInfo ^monDriveInfo = gcnew DriveInfo(monDrive);
		// Vérification qu'on a bien affaire à un lecteur CD/DVD
		if (monDriveInfo->DriveType == DriveType::CDRom)
		{
			// Vérification si il y a un cd dans le lecteur
			if (monDriveInfo->IsReady == true)
				Console::WriteLine("Lecteur identifié avec CD : {0}", monDriveInfo->VolumeLabel);
			else
				Console::WriteLine("Lecteur identifié sans CD : {0}", monDriveInfo->Name);
		}
		else
			Console::WriteLine("Ce lecteur n'est pas un lecteur CD/DVD !");
	}
	catch (Exception ^e)
	{
		Console::WriteLine("Ceci n'est pas un lecteur !");
	}

static void WriteFileEntries(String^ folder, int indent)
{
	// Créer une indentation du texte
	StringBuilder^ tab = gcnew StringBuilder(String::Empty);
	for(int i = 0; i < indent; i++)
		tab->Append(L" ");
	// Afficher les dossiers présents et leur contenu par récursivité
	array<System::String ^>^ subdirs = Directory::GetDirectories(folder);
	// SI le dossier contient des sous-dossiers
	if (subdirs->Length != 0)
	{
		for each (String^ s in subdirs)
		{
			// Afficher le nom du dossier à explorer
			Console::WriteLine(tab->ToString() + Path::GetFileName(s));
			//Utiliser la récursivité avec une indentation
			WriteFileEntries(s, indent + 3);
		}
	}
	// Afficher les noms des fichiers présents
	array<System::String ^>^ files = Directory::GetFiles(folder);
	// SI le dossier contient des fichiers
	if (files->Length != 0)
	{
		for each (String^ s in files)
			Console::WriteLine(tab->ToString() + Path::GetFileName(s));
	}
}

	String ^chemin = "C:\\dev";
	String ^fichier = "fichier.txt";
	String ^cheminComplet = System::IO::Path::Combine(chemin, fichier);	
	Console::WriteLine(cheminComplet);

using namespace System::IO;
 
static Int64 TailleRepertoire(DirectoryInfo ^rep)
{
	Int64 Size = 0;
	// liste tous les fichiers du répertoire rep  
	array<FileInfo ^> ^ fichiers = rep->GetFiles();
	for each (FileInfo ^fich in fichiers)
		Size += fich->Length;
	// liste tous les sous-répertoires.       
	array<DirectoryInfo^>^ sousrep = rep->GetDirectories();
	for each (DirectoryInfo ^repert in sousrep)
		Size += TailleRepertoire(repert); //appelle la méthode TailleRepertoire pour calculer la taille de chaque sous répertoire
	return (Size);
}
 
int main(array<System::String ^> ^args)
{
	String ^path = "E:\\temp";
	Int64 TailleOctet = TailleRepertoire(gcnew DirectoryInfo(path));
	Int64 TailleKiloOctet = TailleOctet / 1024;
	Console::WriteLine("Taille du répertoire {0} : {1} ko", path, TailleKiloOctet);
	return 0;
}

String ^pathModule = System::IO::Path::GetDirectoryName(System::Reflection::Assembly::GetEntryAssembly()->Location);

System::IO::Directory::GetCurrentDirectory()