Wie Sortiere ich eine generische Liste mit einer benutzerdefinierten comparer?

Ich bin irgendwie ein Delphi-Neuling und ich weiß nicht, wie die Sort-Methode, eine TList von Datensätzen aufgerufen wird, um zu Sortieren die Datensätze nach aufsteigenden integer-Wert.
Ich habe einen Datensatz wie folgt:

 type
   TMyRecord = record
     str1: string;
     str2: string;
     intVal: integer;
   end;

Sowie eine generische Liste von solchen Aufzeichnungen:

TListMyRecord = TList<TMyRecord>;

Habe versucht zu finden ein code-Beispiel in die Hilfe-Dateien und fand dieses:

MyList.Sort(@CompareNames);

Welche ich nicht verwenden kann, da es verwendet Klassen. Also versuchte ich zu schreiben, meine eigene compare-Funktion mit etwas anderen Parametern:

function CompareIntVal(i1, i2: TMyRecord): Integer;
begin
  Result := i1.intVal - i2.intVal;
end;

Aber der compiler wirft immer ein "nicht genügend Parameter" - Fehler, wenn ich rufen Sie es mit open.Sort(CompareIntVal);, was offensichtlich scheint; so habe ich versucht, näher an die Hilfe Datei:

function SortKB(Item1, Item2: Pointer): Integer;
begin
  Result:=PMyRecord(Item1)^.intVal - PMyRecord(Item2)^.intVal;
end;

mit PMyRecord als PMyRecord = ^TMyRecord;

Habe ich versucht, verschiedene Möglichkeiten, eine Funktion aufrufen, die immer wieder einige Fehler...

InformationsquelleAutor p1.e | 2012-11-06

delphi sorting

46

Den Sort überlastung, die Sie verwenden sollten, ist diese:
```
procedure Sort(const AComparer: IComparer<TMyRecord>);
```
Nun, Sie können erstellen einen IComparer<TMyRecord> durch den Aufruf TComparer<TMyRecord>.Construct. Wie diese:
```
var
  Comparison: TComparison<TMyRecord>;
....
Comparison := 
  function(const Left, Right: TMyRecord): Integer
  begin
    Result := Left.intVal-Right.intVal;
  end;
List.Sort(TComparer<TMyRecord>.Construct(Comparison));
```
Habe ich geschrieben das Comparison Funktion als anonyme Methode, aber Sie können auch eine einfache alte Stil nicht-OOP-Funktion oder eine Methode ein Objekt.

Einem problem mit der Vergleich-Funktion ist, dass Sie leiden können integer-überlauf. So könnte man statt dessen den Standard-integer-comparer.
```
Comparison := 
  function(const Left, Right: TMyRecord): Integer
  begin
    Result := TComparer<Integer>.Default.Compare(Left.intVal, Right.intVal);
  end;
```
Könnte es teuer werden, rufen Sie TComparer<Integer>.Default wiederholt, so konnte Sie speichern Sie es Weg in eine Globale variable:
```
var
  IntegerComparer: IComparer<Integer>;
....
initialization
  IntegerComparer := TComparer<Integer>.Default;
```
Andere option zu prüfen, ist zu passieren in der comparer beim erstellen der Liste. Wenn Sie immer nur die Liste zu Sortieren verwenden Sie diese Reihenfolge, dann ist das bequemer.
```
List := TList<TMyRecord>.Create(TComparer<TMyRecord>.Construct(Comparison));
```
Dann Sortieren Sie die Liste mit
```
List.Sort;
```
Danke verry viel! Muss ich auf irgendetwas 'verwendet' neben der uses Generics.Collections,..., 'Ursache, die ich eine "schwarzarbeit" für TComparisonund IComparerim var Comparison: TComparison<TKanteRecord>; IntegerComparer: IComparer<Integer>;?
Sie müssen auch die Generika.Standardwerte. Haben Sie festgestellt, dass die RTL-source-code noch. Das würde Ihnen helfen.
sind Sie sicher, dass TComparer ist eine gute Wahl für einen code, den Sie zur Verfügung gestellt ? TComparer gemeint ist die abstrakte Basisklasse. Ich würde vorschlagen, zu verwenden TDelegatedComparer für Ihren code.
Ja, ich bin sicher, dass: TComparer<T>.Construct(Comparison) ist umgesetzt mit einem Aufruf TDelegatedComparer<T>.Create(Comparison).
Die TList<T> nicht über einen Konstruktor verfügen, akzeptieren TComparer<T> als input-parameter in Delphi 10.2. Könnten Sie kompilierbare Beispiele?

InformationsquelleAutor David Heffernan

Die knappe Antwort:

uses
  .. System.Generics.Defaults // Contains TComparer

myList.Sort(
  TComparer<TMyRecord>.Construct(
    function(const Left, Right: TMyRecord): Integer
    begin
      Result := Left.intVal - Right.intVal;
    end
  )
);

InformationsquelleAutor Ian Boyd

Fand ich eine viel einfachere modifizierte Funktion Sortieren auf alphabetisch, eine TList von Datensätzen oder nicht standardisierte Liste von Elementen.

Beispiel

PList = ^TContact;
    TContact = record             //Record for database of user contact records
      firstname1 : string[20];
      lastname1 : string[20];
       phonemobile : Integer;       //Fields in the database for contact info
      phonehome : Integer;
      street1 : string;
      street2 : string;

 type
    TListSortCompare = function (Item1,
                                Item2: TContact): Integer;
var
  Form1: TForm1;
  Contact : PList;         //declare record database for contacts
  arecord : TContact;
  Contacts : TList;   //List for the Array of Contacts

function CompareNames(i1, i2: TContact): Integer;
begin
   Result := CompareText(i1.lastname1, i2.lastname1) ;
end;

und die Funktion, um den Anruf zu Sortieren Sie Ihre Liste

Contacts.Sort(@CompareNames);

Möchten Sie vielleicht zu reinigen Sie Ihren code-Beispiel ein wenig. Entfernen Sie nicht verwendete Variablen. Hinzufügen Anwendungsbeispiel. Korrigieren Sie die syntax.
Die ursprüngliche Frage war zum Sortieren eine generische Liste, die während dieses Beispiel nutzt die standard-TList (Liste der Verweise), die ein anderes Szenario.

InformationsquelleAutor Jason Brown

Möchte ich meine Lösung (basierend auf dem input, den ich hier versammelt haben).

Es ist ein standard-setup. Ein filedata Klasse, der hält, was Daten aus einer Datei in eine generische TObjectList. Die Liste hat zwei private Attribute fCurrentSortedColumn und fCurrentSortAscending zu Steuerung der Sortierreihenfolge. Der AsString-Methode gibt den Pfad und den Dateinamen kombiniert.

function TFileList.SortByColumn(aColumn: TSortByColums): boolean;
var
  Comparison: TComparison<TFileData>;
begin
  result := false;
  Comparison := nil;

  case aColumn of
    sbcUnsorted   : ;
    sbcPathAndName: begin
                      Comparison := function(const Left, Right: TFileData): integer
                                    begin
                                      Result := TComparer<string>.Default.Compare(Left.AsString,Right.AsString);
                                    end;
                    end;
    sbcSize       : begin
                      Comparison := function(const Left, Right: TFileData): integer
                                    begin
                                      Result := TComparer<int64>.Default.Compare(Left.Size,Right.Size);
                                      if Result = 0 then
                                        Result := TComparer<string>.Default.Compare(Left.AsString,Right.AsString);
                                    end;
                    end;
    sbcDate       : begin
                      Comparison := function(const Left, Right: TFileData): integer
                                    begin
                                      Result := TComparer<TDateTime>.Default.Compare(Left.Date,Right.Date);
                                      if Result = 0 then
                                        Result := TComparer<string>.Default.Compare(Left.AsString,Right.AsString);
                                    end;
                    end;
    sbcState      : begin
                      Comparison := function(const Left, Right: TFileData): integer
                                    begin
                                      Result := TComparer<TFileDataTestResults>.Default.Compare(Left.FileDataResult,Right.FileDataResult);
                                      if Result = 0 then
                                        Result := TComparer<string>.Default.Compare(Left.AsString,Right.AsString);
                                    end;
                     end;
  end;

  if assigned(Comparison) then
  begin
    Sort(TComparer<TFileData>.Construct(Comparison));

    // Control the sort order
    if fCurrentSortedColumn = aColumn then
      fCurrentSortAscending := not fCurrentSortAscending
    else begin
      fCurrentSortedColumn := aColumn;
      fCurrentSortAscending := true;
    end;

    if not fCurrentSortAscending then
      Reverse;

    result := true;
  end;
end;

InformationsquelleAutor Henrik Carlsen

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.