Files suchen und sortieren

[stahli]

Ich ermittle einige PDF-Dateien und sortiere die nach dem Erstellungsdatum.
Das funktioniert, ich bin aber nicht sicher, ob ich die einfachste Lösung habe.
Würde es jemand anders machen?

Muss nicht mit Generics sein. Würde eine anonyme Methode etwas vereinfachen?

Delphi-Quellcode:

type

  TsrComparer = class(TComparer<TSearchRec>)
    function Compare(const sr1, sr2: TSearchRec): Integer; override;
  end;

implementation

{ TMeleePairComparer }

function TsrComparer.Compare(const sr1, sr2: TSearchRec): Integer;
begin
  Result := 0;
  if Result = 0 then
    Result := -CompareValue(sr1.TimeStamp, sr2.TimeStamp);
  if Result = 0 then
    Result := CompareStr(sr1.Name, sr2.Name);
end;

...

procedure TFormOlympic.TabSheetReportShow(Sender: TObject);

  procedure GetFiles;
  var
    sr: TSearchRec;
    srList: TList<TSearchRec>;
    F: Boolean; // ergänzt
  begin
    srList := TList<TSearchRec>.Create(TsrComparer.Create);
    if PathReport <> '' then
    begin
      F := FindFirst(PathReport + '*.pdf', (faAnyFile and not faDirectory), sr);
      while F = 0 do
      begin
        if ExtractFileExt(sr.Name) = '.pdf' then
          srList.Add(sr);
        F := FindNext(sr);
      end;
      FindClose(sr);
    end;
    srList.Sort;
    ListBoxReport.Clear;
    for sr in srList do
      ListBoxReport.Items.Add(sr.Name);
    FreeAndNil(srList);
  end;

begin
  GetFiles;
  ListBoxReport.ItemIndex := 0;
  ListBoxReportClick(Sender);
end;

PS: Auf ein TsShellListView (AlphaControls) hatte ich verzichtet, da ein umsortieren dort nicht möglich war.

[daywalker9]

Könnte man auch so machen:

Delphi-Quellcode:

    lst:=TList<TSearchRec>.create;
    lst.Sort(TComparer<TSearchRec>.Construct(function (const sr1,sr2 : TSearchRec):integer
                                               begin
                                                Result := 0;
                                                if Result = 0 then
                                                  Result := -CompareValue(sr1.TimeStamp, sr2.TimeStamp);
                                                if Result = 0 then
                                                  Result := CompareStr(sr1.Name, sr2.Name);
                                               end));

[himitsu]

Resourcenscchutz?

FreeAndNil ist, bei Variablen, welche eh nicht geprüft werden und nur lokal genutzt werden, etwas übertrieben.

Wieso ist das lokale F global deklariert, bzw. wo wurde es eigentlich deklariert?

Und jupp, an die anonymen Methoden gewöhne ich mich auch so langsam, aber ob es hier wirklich sinnvoll/nötig ist, ist eine andere Frage
(aber oftmals machen sie den Code schon lesbarer, da der Code dann zwar nicht wiederverwendbar ist, aber wenigenstens, bei linearen Funktionen, im Kontext des aufrufenden Codes bleibt und man nicht erst suchen/umblättern muß ... z.B. bei Synchronize-Aufrufen ist das eine geile Angelegenheite und auch kleinere Thread-Prozeduren erstelle ich heutzutage anonym )

Da man FindClose eh nur aufrufen muß, wenn FindFirst erfolgreich war, ist die Repeat-Schleife (aus dem OH-Beispiel) keine schlechte Idee.

Zitat:

ExtractFileExt(sr.Name) = '.pdf'

irgendwas.PDF oder x.PdF willst du nicht finden?

Delphi-Quellcode:

procedure GetFiles;
var
  sr: TSearchRec;
  srList: TList<TSearchRec>;
begin
  srList := TList<TSearchRec>.Create(function(const sr1, sr2: TSearchRec): Integer
    begin
      Result := 0;
      if Result = 0 then
        Result := -CompareValue(sr1.TimeStamp, sr2.TimeStamp);
      if Result = 0 then
        Result := CompareStr(sr1.Name, sr2.Name);
    end));
  try
    if (PathReport <> '') and (FindFirst(PathReport + '*.pdf', (faAnyFile and not faDirectory), sr) = 0) then
    begin
      repeat
        //if SameText(ExtractFileExt(sr.Name), '.pdf') then
        if EndsText('.pdf', sr.Name) then //Unit StrUtils
          srList.Add(sr);
      until FindNext(sr) <> 0;
      FindClose(sr);
    end;
    srList.Sort;
    ListBoxReport.Clear;
    for sr in srList do
      ListBoxReport.Items.Add(sr.Name);
  finally
    srList.Free;
  end;
end;

PS: Leider hat man in TDirectory.GetFiles (Unit IOUtils) die Sortierung vergessen, aber sonst könnte man diese neue Unit sich schonmal ansehn, auch wenn ich persönlich diese Unit für total Mißlungen halte.
Aber zumindestens die Methoden, um über nur einen Befehl auf bestimmte Dateieigenschaften zuzugreifen, ist manchmal recht praktisch.

[FredlFesl]

Ich würde da noch Refacoring ansetzen:

Delphi-Quellcode:

Function FileList (aPath : String) : TSearchRecList;
Begin
  Result := TSearchRecList.Create;
  Try
    ReadDirectory (aPath, Result);
    SortListByCreationData(Result);
  Except
    Result.Free;
    Result := Nil;
    Raise;
  End;
End;

Übersichtlich, einfach zu lesen.

So praktisch Generics auch sind, so 'häßlich' finde ich sie. Ich kapsele lieber bzw. lasse sie nur in den untersten Ebenen ihr wahres Gesicht zeigen. Denn vielleicht ist eine 'TList<TSearchRec>' ja irgendwann nicht mehr das Gelbe vom Ei.

[stahli]

Zitat von himitsu:

Resourcenscchutz?

Setze ich nur ein, wenn es wirklich Sinn macht.

Zitat von himitsu:

FreeAndNil ist, bei Variablen, welche eh nicht geprüft werden und nur lokal genutzt werden, etwas übertrieben.

Ist Gewohnheitssache. Free sieht so billig aus.

Zitat von himitsu:

Wieso ist das lokale F global deklariert, bzw. wo wurde es eigentlich deklariert?

Ups, versehentlich entfernt...

Zitat von himitsu:

Und jupp, an die anonymen Methoden gewöhne ich mich auch so langsam, aber ob es hier wirklich sinnvoll/nötig ist, ist eine andere Frage
(aber oftmals machen sie den Code schon lesbarer, da der Code dann zwar nicht wiederverwendbar ist, aber wenigenstens, bei linearen Funktionen, im Kontext des aufrufenden Codes bleibt und man nicht erst suchen/umblättern muß ... z.B. bei Synchronize-Aufrufen ist das eine geile Angelegenheite und auch kleinere Thread-Prozeduren erstelle ich heutzutage anonym )

Das meinte ich mit meiner Frage vor allem. Danke auch an DayWalker9.
Wobei ich mir noch nicht sicher bin, was nun wirklich übersichtlicher ist. Für meinen vorliegenden Anwendungszweck bleibe ich wohl besser bei meiner Lösung. Ich finde das dann doch etwas strukturierter. Außerdem kann man so in übersichtlicher Weise ggf. verschiedene Comparer für verschiedene Zwecke zuweisen.

Zitat von himitsu:

ExtractFileExt(sr.Name) = '.pdf' irgendwas.PDF oder x.PdF willst du nicht finden?

Stimmt, ich bessere das nach. Aber vorliegend war es kein Problem, da die pdf´s vom Programm selbst erzeugt werden.

Danke.


EDIT: @FredFesl
Da schließe ich mich mal nicht an. Die Lösung mit den Generics ist schon ganz nett.

[p80286]

Delphi-Quellcode:

Function FileList (aPath : String) : TSearchRecList;
Begin
  Result := TSearchRecList.Create;
  Try
    ReadDirectory (aPath, Result);
    SortListByCreationData(Result);
  Except
    Result.Free;
    Result := Nil;
    Raise;
  End;
End;

Ist das nicht pfui bah wegen möglicher Speicherleks?

Gruß
K-H

[DeddyH]

Ich meine auch,
procedure FileList(aPath : String; DestList: TSearchRecList); wäre besser, Beispiele hatten wir doch letztens erst.

[FredlFesl]

Klar, geht auch. Hier ging es je eher um das Refactoring.