uses System.IO;

					var filename : String ;
					name : String ;
					begin
					fileName := 'C:\toto.txt';
					name := System.IO.Path.GetFileName(fileName);
					Console.WriteLine(name);

					uses System.IO;

					{$APPTYPE CONSOLE}

					procedure FileTests;
					const Source='C:\Temp\MonFichier.txt';
					Destination='C:\Temp\Copy de MonFichier.txt';
					Deplace='C:\Temp\MonFichierDéplacé.txt';

					var Fichier : FileStream ;

					begin
					try
					With System.IO.File do
					begin
					//Création d'un fichier vide.
					Fichier := &Create(Source) ;

					Fichier.Close;
					Console.WriteLine('Fichier {0} créé.',Source);

					// Copie de fichier
					Copy(Source, Destination);
					Console.WriteLine('Fichier {0} copié vers {1}.',[Source,Destination]);

					// Déplacement de fichier
					Move(Destination, Deplace);
					Console.WriteLine('Fichier {0} déplacé vers {1}.',[Destination,Deplace]);

					// Suppression de fichier
					Delete(Destination);
					Console.WriteLine('Fichier {0} supprimé.',[Destination]);
					end;

					except
					on ex : System.IO.IOException do
					begin
					Console.WriteLine(Environment.Newline+'Erreur : '+ex.Message);
					Console.WriteLine(Environment.Newline+Environment.Newline+'Détails de l''exception :');
					Console.WriteLine(ex.ToString);
					end;
					end;
					end;

					uses System.IO;

					procedure GetFileAttributes(NomFichier : String) ;
					//  Test : GetFileAttributes('C:\IO.SYS');
					var flagAttr : FileAttributes;
					unAttr : System.IO.FileAttributes;
					DateFichier : System.DateTime;

					begin
					With System.IO.File,DateFichier do
					begin
					flagAttr := GetAttributes(NomFichier);
					// Date de création
					DateFichier:=GetCreationTime(NomFichier);
					Console.WriteLine('Créé le {0} à {1}',ToShortDateString,ToShortTimeString);

					// Date de la dernière modification
					DateFichier:=GetLastWriteTime(NomFichier);
					Console.WriteLine('Modifié le {0} à {1}',ToShortDateString,ToShortTimeString);

					// Date du dernier accès
					DateFichier:=GetLastAccessTime(NomFichier);
					Console.WriteLine('Dernier accès le {0} à {1}',ToShortDateString,ToShortTimeString);

					Console.WriteLine('Attributs de {0}', NomFichier);

					//Itération sur l'énumération
					for UnAttr in Enum.GetValues(TypeOf(System.IO.FileAttributes)) do
					if ( (flagAttr and unAttr) = UnAttr)
					then Console.WriteLine(UnAttr);

					// Il est possible de tester les attributs par le test suivant
					// if ((flagAttr and FileAttributes.Archive) = FileAttributes.Archive)
					//  then Console.WriteLine(FileAttributes.Archive);
					end;
					end;

					uses System.IO;

					procedure ScanDir(MonRepertoire : String);
					var Fichiers : array of String;
					I : Integer;
					begin
					// Obtient les noms des fichiers et sous-répertoires du répertoire MonRepertoire
					Fichiers:= System.IO.Directory.GetFileSystemEntries(MonRepertoire);
					for i:=0 to Length(Fichiers)-1 do
					Console.WriteLine(Fichiers[i]);
					end;

					procedure FichierTexte(nomFichier : TFileName);
					var Lecteur  : StreamReader ;
					Ecrivain : StreamWriter ;
					Ligne : String ;

					begin
					try
					if not FileExists(nomFichier) then
					begin
					// Le fichier n'existe pas. On le crée.
					Ecrivain := StreamWriter.Create(nomFichier);
					Ecrivain.WriteLine('Bonjour. Nous sommes le {0} et il est {1} ',
					DateTime.Now.ToLongDateString(),
					DateTime.Now.ToLongTimeString());
					Ecrivain.Close;
					// Remarque : on peut ajouter du texte à un fichier existant par
					//   Ecrivain:= File.AppendText(NomFichier);
					end ;

					// Ouverture du fichier et écriture du contenu du fichier sur la console
					Console.WriteLine('Début du fichier');
					Lecteur := StreamReader.Create( nomFichier );
					Ligne := Lecteur.ReadLine;
					while ligne <> nil do
					begin
					Console.WriteLine(ligne);
					ligne := Lecteur.ReadLine;
					end ;
					Console.WriteLine( 'Fin du fichier' );

					finally
					// Fermeture streamreader
					if Assigned(Lecteur)
					then Lecteur.Close;
					// Fermeture streamwriter
					if Assigned(Ecrivain)
					then Ecrivain.Close;
					end ;
					end;

					begin
					With System.String,System.Environment do
					Filename:=Concat(IncludeTrailingBackslash(GetEnvironmentVariable('TEMP')),'Test.txt');
					FichierTexte(Filename);
					end.

					Uses System.Text;

					begin

					Ecrivain := StreamWriter.Create(nomFichier,False,Encoding.Default);
					...
					Lecteur := StreamReader.Create(nomFichier,Encoding.Default);

					procedure FichierTexte(nomFichier : TFileName);
					var Fichier  : Text;
					Ligne : String ;

					begin
					Assign(Fichier,NomFichier);
					if not FileExists(nomFichier) then
					begin
					Rewrite(Fichier);
					Ligne:='Nous sommes le '+DateTime.Now.ToLongDateString+' et il est '+DateTime.Now.ToLongTimeString;
					Fichier.WriteAnsiString(Ligne,length(Ligne));
					Fichier.Flush;
					Close(Fichier);
					// Remarque : on peut ajouter du texte à un fichier existant par
					//   Append(Fichier);
					end ;

					// Ouverture du fichier et écriture du contenu du fichier sur la console
					Writeln('Début du fichier');
					Reset(Fichier);
					Ligne := Fichier.ReadAnsiString;
					while ligne <> nil do
					begin
					Writeln(ligne);
					ligne := Fichier.ReadAnsiString;
					end ;
					Close(Fichier);
					Writeln( 'Fin du fichier' );
					end;

					Text = class
					Mode: Word;
					Flags: Word;
					Factory: ITextDeviceFactory;
					Reader: System.IO.TextReader;
					Writer: System.IO.TextWriter;
					Filename: string;
					...

					ITextDeviceFactory = interface
					function Open(t: Text; Mode: Word): Integer;
					function Close(t: Text): Integer;
					end;

					fmOpenRead or fmShareDenyWrite.

					procedure FichierTexte(nomFichier : TFileName);
					var Fichier : TOpenedFile ;
					Lignes : String ;
					S      : String;
					LecteurChaine : StringReader;

					begin
					if not FileExists(nomFichier) then
					begin
					// Le fichier n'existe pas.
					Fichier := FileCreate(nomFichier);// crée et ouvre le fichier
					if Assigned(Fichier) then
					begin
					With DateTime.Now do
					Lignes:=Format('Bonjour. Nous sommes le %s et il est %s ',[ToLongDateString,ToLongTimeString]);
					if FileWrite(Fichier, Lignes,Lignes.Length)=-1
					then Writeln('Erreur lors de l''écriture');
					FileClose(Fichier);
					// Remarque : on peut ajouter du texte à un fichier existant par
					{
					Fichier := FileOpen(nomFichier,(fmOpenReadWrite));
					Position:=FileSeek(Fichier,0,2);
					Lignes:=Environment.NewLine+Lignes;
					NbOctetEcris:=FileWrite(Fichier,Lignes,Lignes.Length);
					FileClose(Fichier);
					}
					end;
					end;

					// Ouverture du fichier et écriture du contenu du fichier sur la console
					Console.WriteLine('Début du fichier');
					Fichier := FileOpen(nomFichier,(fmOpenReadWrite));
					if Assigned(Fichier) then
					begin
					if FileRead(Fichier,Lignes, Fichier.Length)=-1
					then Writeln('Erreur lors de la lecture');
					FileClose(Fichier);
					LecteurChaine:=StringReader.Create(Lignes);
					Repeat
					S:=LecteurChaine.ReadLine; // Pour un saut de ligne dans un texte, readline renvoi S=''=Nil
					Console.WriteLine(S);
					// Test s'il reste qq chose à lire, un saut de ligne est considéré comme 'qq chose à lire'
					Until LecteurChaine.Peek=-1;
					LecteurChaine.Close;
					end;
					Console.WriteLine( 'Fin du fichier' );
					end;

					01 00 00 00 02 00 00 00-03 00 00 00 04 00 00 00
					05 00 00 00 06 00 00 00-07 00 00 00 08 00 00 00

					01 02 03 04 05 06 07 08-09 0A

					procedure TestFichierBinaire(NomFichier : String) ;

					var //i : integer;
					i : Byte;
					LecteurBinaire : BinaryReader;
					EcrivainBinaire : BinaryWriter;
					Fichier : FileStream;
					begin
					try
					if not FileExists(NomFichier) then
					begin
					Console.WriteLine('Ecriture du fichier');
					// Le fichier n'existe pas. On le crée
					Fichier:=System.IO.File.&Create(NomFichier);
					EcrivainBinaire := BinaryWriter.Create(Fichier);
					//EcrivainBinaire := System.IO.BinaryWriter.Null;

					for i:=1 to 10 do
					// Écrit un entier non signé dans le flux actuel et avance la position du flux du nombre d'octet
					// correspondant à la taille du type écrit.
					EcrivainBinaire.Write(i);
					//EcrivainBinaire.Write(Nomfichier); // Ecrit un tableau de Byte
					EcrivainBinaire.Close;
					end ;
					Console.WriteLine('Lecture du fichier');
					// Ouverture du contenu du fichier et écriture sur la console
					Fichier := System.IO.File.Open(NomFichier, FileMode.Open);
					LecteurBinaire := BinaryReader.Create(Fichier);

					while (Fichier.Position < Fichier.Length) do
					//Console.Writeline('{0}',[LecteurBinaire.ReadInt32]);
					Console.Writeline('{0}',[LecteurBinaire.ReadByte]);
					Console.WriteLine(Environment.NewLine+'Fin du fichier');

					finally
					if Assigned(LecteurBinaire)
					then LecteurBinaire.Close;  //Ferme le BinaryReader et le flux associé
					if Assigned(EcrivainBinaire)
					then EcrivainBinaire.Close; //Ferme le BinaryWriter et le flux associé
					end ;
					end;

					EcrivainBinaire := BinaryWriter.Null;

					EcrivainBinaire := BinaryWriter.Create(Fichier);

					procedure OnChanged( Source : TObject ; E : FileSystemEventArgs) ;
					begin
					Console.WriteLine('[Notification]Fichier {0} {1}', E.FullPath, E.ChangeType);
					Console.WriteLine;
					end;

					procedure OnRenamed( Source : TObject ; E : RenamedEventArgs ) ;
					begin
					Console.WriteLine('[Notification]Fichier {0} renommé en {1}', E.OldFullPath, E.FullPath);
					Console.WriteLine;
					end;

					procedure OnError(Source : TObject ; E : ErrorEventArgs) ;
					begin
					Console.WriteLine('[Notification]Erreur' + E.GetException.ToString);
					Console.WriteLine;
					end;

					Function Watch(Path : String ; Filtre : String ): FileSystemWatcher;
					// Surveille les modifications survenues au sein du répertoire Path mais pas celles apportées au répertoire lui-même.

					begin
					// si Filtre='*.txt' Surveille tous les fichiers portant l'extension .txt
					// si Filtre='' Surveille tous les fichiers (par défaut).

					// Création de l'objet watcher
					Result := FileSystemWatcher.Create(Path, Filtre);

					// On ajoute les handlers pour surveiller les événements souhaités.
					With Result do
					begin
					// limite le nombre de modifications de fichier ou de répertoire pour lesquelles
					// l'instance du composant déclenche des événements.
					//NotifyFilter:= NotifyFilters.Attributes;

					Include( Changed, OnChanged );
					Include( Renamed, OnRenamed );
					Include( Created, OnChanged );
					Include( Deleted, OnChanged );
					Include( Error, OnError );

					// On surveillera aussi les sous-répertoires existant et ceux qui seront créés
					IncludeSubdirectories := True;

					// Affecter EnableRaisingEvents à true démarre la surveillance des modifications.
					EnableRaisingEvents := True;
					// Affecter EnableRaisingEvents à false arrête la surveillance des modifications.
					end;
					end;

					// Pour surveiller l'activité sur les fichier *.txt du répertoire c:\temp
					var FichierSurveille : FileSystemWatcher;
					begin
					FichierSurveille:=Watch('c:\temp','*.txt');
					Filetests; // Voir la QR citée dans la section Lien
					readln;
					FichierSurveille.EnableRaisingEvents := False;
					readln;