Generics TList<> sortieren

[Shark99]

Ich versuche mit Delphi Xe5 eine generische Liste zu sortieren und bekomme vom Compiler die Fehlermeldung:

[dcc32 Error] SortUnit.pas(255): E2035 Not enough actual parameters

Was mache ich falsch?

Delphi-Quellcode:

type

  TDataItem = class
    Modified: int64;
    Data: string;

    Constructor Create(iModified: int64; sData: string);
  end;

var

  TestList: TList<TDataItem>;

  ListModifiedComparer: IComparer<TDataItem>;
  
...

  ListModifiedComparer := TDelegatedComparer<TDataItem>.Construct(
                          function(const L,R:TDataItem): integer;
                          begin
                              Result := 0;
                              if (L.Modified > R.Modified)  then Result := 1
                              else if (L.Modified < R.Modified) then Result := -1;
                          end;
                          );
                         
 TestList.Sort(ListModifiedComparer); // Zeile 255

[bra]

Versuchs mal mit TDelegatedComparer<TDataItem>.Create statt Construct.

und ich meine die ; in der inneren Function dürfen nicht sein (kann mich aber täuschen):

Delphi-Quellcode:

ListModifiedComparer := TDelegatedComparer<TDataItem>.Create(
                          function(const L,R:TDataItem): integer
                          begin
                              Result := 0;
                              if (L.Modified > R.Modified) then Result := 1
                              else if (L.Modified < R.Modified) then Result := -1;
                          end
                          );

[Shark99]

Danke, hat geklappt.

[himitsu]

PS: Es gibt auch schon was Fertiges:

Delphi-Quellcode:

function(const L, R: TDataItem): Integer
begin
  Result := CompareValue(L.Modified, R.Modified);  // oder CompareStr/CompareText
end

// lässt sich auch verschachteln
function(const L, R: TDataItem): Integer
begin
  Result := CompareValue(L.Modified, R.Modified);
  if Result = 0 then
    Result := CompareValue(L.WasAnderes, R.WasAnderes);
  if Result = 0 then
    ...
end

Aber wenn, dann kann es nie schaden, wenn man die "korrekten" Typen und passende Konstanten verwendet.

Delphi-Quellcode:

function(const A, B: xxxx): TValueRelationship;
begin
  if A = B then //if SameValue(A, B, Epsilon) then
    Result := EqualsValue
  else if A < B then
    Result := LessThanValue
  else
    Result := GreaterThanValue;
end

function(const A, B: xxxx): TValueRelationship;
begin
  Result := EqualsValue;
  if A < B then
    Result := LessThanValue
  else if A > B then
    Result := GreaterThanValue;
end

[Stevie]

Man kann auch einen kleinen Trick nutzen.

Da TComparison<T> und IComparer<T> binärkompatibel sind, kann man die anonyme Methode direkt hardcasten:

Delphi-Quellcode:

TestList.Sort(IComparer<TDataItem>(
  function(const L, R: TDataItem): Integer
  begin
    Result := CompareValue(L.Modified, R.Modified);
  end));

Schöner wär natürlich, wenn TList<T> direkt ein Sort overload mit TComparison<T> hätte...