FAQ DelphiConsultez toutes les FAQ

1
2
3
4
5
6
begin 
  if FileExists('C:\MyDirectory\MyFile.txt') then 
    { le fichier existe } 
  else 
    { le fichier n'existe pas} 
end;

RenameFile('C:\MonFichier.txt', 'C:\MonTexte.txt');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  
function CopyFile(Source, Destination: String ) : boolean; 
var 
  fos : TSHFileOpStruct; 
begin 
  FillChar(fos, SizeOf(fos),0); 
  with fos do 
  begin 
    wFunc := FO_COPY; 
    pFrom := PChar(Source+#0);  
    pTo   := PChar(Destination+#0);  
    fFlags := FOF_ALLOWUNDO or FOF_NOCONFIRMATION or FOF_SILENT; 
  end; 
  result := (0 = ShFileOperation(fos)); 
end;

CopyFile(NomDeFichierExistant, NouveauNomDeFichier : String; EchecSiExiste: BOOL): BOOL;

1
2
  
  Result := CopyFile(PChar(NomDeFichierExistant), PChar(NouveauNomDeFichier), False);

MoveFileEx(ExistingFileName, NewFileName : PChar; Flags : DWord): Boolean;

1
2
3
4
5
6
  
function MoveFile(FichierSource, FichierDestination: String; 
      CommentDeplacerLeFichier: DWORD) : boolean; 
Begin 
  Result := MoveFileEx(PChar(FichierSource), PChar(FichierDestination),MOVEFILE_COPY_ALLOWED); 
end;

1
2
3
4
5
6
7
8
9
10
11
12
var 
  F: TextFile; 
begin 
  ForceDirectories('c:\PremierRep\DeuxRep\TroisRep'); 
  AssignFile(F,'c:\PremierRep\DeuxRep\TroisRep\MonFichier.txt'); 
  ReWrite(F); 
  try 
    { Code  } 
  finally 
    CloseFile(F); 
  end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
function DeleteFileToRecycleBin(AFileName : string ) : boolean; 
var 
  fos : TSHFileOpStruct; 
begin 
  FillChar(fos, SizeOf(fos),0); 
  with fos do 
  begin 
    wFunc  := FO_DELETE; 
    pFrom  := PChar(AFileName+#0); 
    fFlags := FOF_ALLOWUNDO or FOF_NOCONFIRMATION or FOF_SILENT; 
  end; 
  result := (0 = ShFileOperation(fos)); 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function SHEmptyRecycleBin (Wnd : HWnd; LPCTSTR : PChar; DWORD : Word) : Integer; stdcall; 
  
const 
  SHERB_NOCONFIRMATION = $00000001; 
  SHERB_NOPROGRESSUI   = $00000002; 
  SHERB_NOSOUND        = $00000004; 
  
Implementation 
{$R *.DFM} 
  
function SHEmptyRecycleBin; external  'SHELL32.DLL' name 'SHEmptyRecycleBinA'; 
  
procedure TForm1.EmptyBtnClick(Sender: TObject); 
begin 
  SHEmptyRecycleBin(self.handle,'', SHERB_NOCONFIRMATION); 
end;

ShellExecute(0,'OPEN','C:\Mes documents\mon rapport.doc', Nil, Nil, SW_SHOW);

uses  [...] ,ShellApi;

1
2
3
4
5
ShellExecute(0,'OPEN','C:\Mes documents\mon rapport.doc', Nil, Nil, SW_SHOW); 
ShellExecute(0,'OPEN','http://www.developpez.com', Nil, Nil, SW_SHOW); 
ShellExecute(0,'OPEN','C:\MaMusiqueBranchée.MP3', Nil, Nil, SW_SHOW); 
ShellExecute(0,'OPEN','mailto:Nono40@fr.st', Nil, Nil, SW_SHOW); 
ShellExecute(0,'OPEN','C:\projets\MonProg.exe', Nil, Nil, SW_SHOW);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
procedure TForm1.Button1Click(Sender: TObject); 
Var Chemin : String; 
    Info   : TSearchRec; 
begin 
  ListBox1.Items.Clear; 
  ListBox2.Items.Clear; 
  
  { Pour être sur que la barre oblique finisse le nom du chemin } 
  Chemin := IncludeTrailingPathDelimiter(Edit1.Text); 
  
  { Recherche de la première entrée du répertoire } 
  If FindFirst(Chemin+'*.*',faAnyFile,Info)=0 Then 
  Begin 
    Repeat 
      { Les fichiers sont affichés dans ListBox1 }     
      { Les répertoires sont affichés dans ListBox2 } 
      If Not((Info.Attr And faDirectory)=0) 
Then ListBox2.Items.Add(Info.FindData.cFileName) 
Else ListBox1.Items.Add(Info.FindData.cFileName) 
  
      { Il faut ensuite rechercher l'entrée suivante } 
    Until FindNext(Info)<>0; 
  
    { Dans le cas ou une entrée au moins est trouvée il faut } 
    { appeler FindClose pour libérer les ressources de la recherche } 
    FindClose(Info); 
  End; 
end;

1
2
3
4
5
6
7
8
9
10
var 
  Fichiers: TArray<string>; 
  nomF: string; 
  
begin 
  Fichiers := TDirectory.GetFiles('d:\monrepertoire','nav_*.xml'); 
  for nomF in Fichiers do 
  begin 
   .........//traitement des fichiers 
  end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
uses 
  ShlObj, Windows; 
  
function GetLongFilename(const ShortFilename: string): string; 
var 
  desktop: IShellFolder; 
  filename: Widestring; 
  pchEaten: Cardinal; 
  ppIdl: PItemIDList; 
  pdwAttributes: Cardinal; 
  buffer: array [0..MAX_PATH] of char; 
begin 
  result:= ShortFilename; 
  if SHGetDesktopFolder(desktop) = NOERROR then 
  begin 
    filename:= ShortFilename; { Conversion en WideString } 
    if Desktop.ParseDisplayName(0, nil, PWideChar(filename), 
  pchEaten, ppidl, pdwAttributes) = NOERROR then 
    begin 
      if SHGetPathFromIDList(ppidl, buffer) then 
result:= buffer; 
    end; 
  end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
  
uses 
  SysUtils, ShellAPI, Windows; 
  
procedure OpenWith(const Filename: string); 
{ Appelle le dialogue "Ouvrir avec..." pour le fichier dont le nom est 
  passé en argument. } 
begin 
  ShellExecute(0, 'open', 'rundll32.exe', 
    PChar('shell32.dll,OpenAs_RunDLL ' + Filename), 
    PChar(ExtractFilePath(Filename)), SW_SHOWNORMAL); 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
  
uses 
  SysUtils, ShellAPI, Windows; 
  
function OpenFile(const Filename: string; const Handle: THandle = 0): boolean; 
{ Tente d'ouvrir le fichier dont le nom est passé en argument avec 
  l'application associée à son extension. Si aucune application n'est 
  associée à celle-ci, le dialogue "Ouvrir avec..." est appelé. } 
var 
  errCode: Cardinal; 
  filePath: string; 
begin 
  { On stocke le chemin pour éviter de le décoder 2 fois } 
  filePath:= ExtractFilePath(Filename); 
  
  { Tentative d'ouverture de l'application associée } 
  errCode:= ShellExecute(Handle, 'Open', PChar(Filename), '', 
    PChar(filePath), SW_SHOWNORMAL); 
  
  { Si la tentative a échoué avec le code SE_ERR_NOASSOC, c'est que l'extension 
    n'est associée à aucune application } 
  if errCode = SE_ERR_NOASSOCthen 
    { Dans ce cas, on appelle le dialogue } 
    errCode:= ShellExecute(0, 'open', 'rundll32.exe', 
      PChar('shell32.dll,OpenAs_RunDLL ' + Filename), 
      PChar(filePath), SW_SHOWNORMAL); 
  
  { Si le code retourné par ShellExecute est supérieur à 32, alors l'opération 
    a réussi, sinon c'est un code d'erreur } 
  result:= errCode > 32; 
end;

1
2
3
4
5
6
7
  
var ProgramPath : String; 
  
begin 
ProgramPath := ExtractFilePath(ParamStr(0)); // Récupére le path complet du programme 
... 
end;

1
2
3
4
5
6
7
  
var ProgramName : String; 
  
begin 
ProgramName := ExtractFileName(ParamStr(0)); // Récupére le nom du programme 
... 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
  
Function ExtractFileNameOnly(FileName:TFileName): TFileName; 
// renvoie la partie nom, d'un nom de fichier constitué d'un nom et d'une extension 
  
var ExtPart : TFileName; 
    lgExt   : Integer; 
  
begin 
ExtPart := ExtractFileExt(FileName); 
LgExt:=Length(ExtPart); 
Delete(FileName,Length(FileName)-lgExt+1,lgExt); 
Result:=FileName; 
end;

1
2
3
4
5
6
7
  
var MyFileExtension : String; 
  
begin 
MyFileExtension := ExtractFileExt(MyFileName); 
... 
End;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  
Type 
  TFileNamePart = Record 
    Drive     : Char; 
    DirPart, 
    FilePartExt, 
    FilePart, 
    ExtPart   : String; 
  end; 
  
Procedure GetFilePart(FileName:TFileName; Var Part :TFileNamePart); 
// Décompose un nom de fichier existant dans un enregistrement 
begin 
  FillChar(Part, SizeOf(Part),#0); 
  If FileExists(FileName) then 
  begin 
  ProcessPath(FileName,Part.Drive,Part.DirPart,Part.FilePartExt); 
  Part.ExtPart :=ExtractFileExt(Part.FilePartExt); // Extrait l'extension 
  Part.FilePart:=ExtractFileNameOnly(Part.FilePartExt); // Extrait le nom uniquement 
  end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
  
var  
  Attributs : Word;  
begin  
  Attributs := FileGetAttr('C:\Temp\Test.txt');  
  
  if Attributs and faReadOnly = faReadOnly then  
  begin  
    // Modifie l'attribut ReadOnly 
  FileSetAttr('C:\Temp\Test.txt', Attributs and not faReadOnly);  
  end;  
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
function TForm1.GetFileSize(const APath: string): int64; 
var 
  Sr : TSearchRec; 
begin 
  if FindFirst(APath,faAnyFile,Sr)=0 then 
  try 
    Result := Int64(Sr.FindData.nFileSizeHigh) shl 32 + Sr.FindData.nFileSizeLow; 
  finally 
    FindClose(Sr); 
  end 
  else 
    Result := -1; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
function GetFileTimes(const FileName: string; var Created: TDateTime;  
  var Accessed: TDateTime; var Modified: TDateTime): Boolean;  
var  
  h: THandle;  
  Info1, Info2, Info3: TFileTime;  
  SysTimeStruct: SYSTEMTIME;  
  TimeZoneInfo: TTimeZoneInformation;  
  Bias: Double;  
begin  
  Result := False;  
  Bias   := 0;  
  h      := FileOpen(FileName, fmOpenRead or fmShareDenyNone);  
  if h > 0 then  
  begin  
    try  
      if GetTimeZoneInformation(TimeZoneInfo) <> $FFFFFFFF then 
        Bias := TimeZoneInfo.Bias / 1440; // 60x24  
      GetFileTime(h, @Info1, @Info2, @Info3);  
      if FileTimeToSystemTime(Info1, SysTimeStruct) then 
        Created := SystemTimeToDateTime(SysTimeStruct) - Bias;  
      if FileTimeToSystemTime(Info2, SysTimeStruct) then 
        Accessed := SystemTimeToDateTime(SysTimeStruct) - Bias;  
      if FileTimeToSystemTime(Info3, SysTimeStruct) then  
        Modified := SystemTimeToDateTime(SysTimeStruct) - Bias;  
      Result := True;  
    finally  
      FileClose(h);  
    end;  
  end;  
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  
function TailleFichier(Fichier: String): Int64; 
var 
  hFile: THandle; 
  HiSize: DWord; 
begin 
  Result := 0; 
  
  hFile := CreateFile(pAnsiChar(Fichier), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, 0); 
  
  if hFile <> INVALID_HANDLE_VALUE then 
  begin 
    Result := GetFileSize(hFile, @HiSize ); 
    Result := Result + Int64( HiSize ) shl 32; 
    FileClose(hFile); 
  end; 
end;