Hallo,
wir haben immer wieder die Aufgabe ein Minimum oder Maximum zu bestimmen von einer Menge von Elementen in einem Container (TList<>, IList<>, TArray<>, etc.). Das ist keine grosse Sache - Schleife darüber, vorher Grenzwert festlegen und vergleichen.

Allerdings kam hier die Frage auf, ob man das nicht generisch lösen könnte.
Gefunden habe ich
etwas, das hilft aber nicht weiter.
Jemand meinte mit C# würde das gehen. Dort gäbe es eine Max function. Die Klasse müsste IEnumerable implementieren.

Die IList<T> von Spring4D hat eine Max function. Hat mir jemand ein Beispiel dazu?
Oder sonst irgendwelche Ideen oder Meinungen?

Zitat von freimatz:

Jemand meinte mit C# würde das gehen. Dort gäbe es eine Max function. Die Klasse müsste IEnumerable implementieren.

Muss die Klasse dazu nicht auch irgendwie einen Wert liefern?

Aber sonst: Klar sollte das per Generics gehen.

for-Schleife via IEnumerable, für jedes Objekt den Wert ermitteln und dann vergleichen.

Das geht sogar ohne Compiler-Unterstützung für Generics, es reicht eine TInterfaceList und darin gespeicherte Interfaces, die den Wert liefern.

Meinst du in etwa so? (Müsste man aber noch ausbauen)

zusammenfalten · markieren

Delphi-Quellcode:

type
  TGeneric = record
  public
    class function Max<T>(List: TEnumerable<T>): T; static;
  end;

class function TGeneric.Max<T>(List: TEnumerable<T>): T;
begin
  var comparer := IComparer<T>(TComparer<T>._Default);
  Result := Default(T);
  for var item in List do
    if comparer.Compare(Result, item) < 0 then
      Result := item;
end;

Zitat von freimatz:

Die IList<T> von Spring4D hat eine Max function. Hat mir jemand ein Beispiel dazu?

zusammenfalten · markieren

Delphi-Quellcode:

uses
  Spring.Collections;

var
  list: IList<Integer>;
begin
  list := TCollections.CreateList<Integer>;
  list.Add(1);
  list.Add(5);
  list.Add(3);
  ShowMessage(Format('%d, %d, %d, Max: %d',[list[0], list[1], list[2], list.Max]));

oder so:

markieren

Delphi-Quellcode:

var
  list: IList<Integer>;
begin
  list := TCollections.CreateList<Integer>([1, 5, 3]);
  ShowMessage(Format('%d, %d, %d, Max: %d',[list[0], list[1], list[2], list.Max]));

Bis bald...
Thomas

Zitat von Uwe Raabe:

Meinst du in etwa so? (Müsste man aber noch ausbauen)

zusammenfalten · markieren

Delphi-Quellcode:

type
  TGeneric = record
  public
    class function Max<T>(List: TEnumerable<T>): T; static;
  end;

class function TGeneric.Max<T>(List: TEnumerable<T>): T;
begin
  var comparer := IComparer<T>(TComparer<T>._Default);
  Result := Default(T);
  for var item in List do
    if comparer.Compare(Result, item) < 0 then
      Result := item;
end;

Da ist nen kleiner aber subtiler Bug drin: wenn dein TEnumerable<T> die Zahlen -1, -3 und -7 enthält, dann würde es inkorrekterweise 0 als Max ausgeben und nicht -1.
Result muss mit dem ersten Wert aus der Sequenz initialisiert werden und ab da muss verglichen werden. Außerdem brauchts ein Verhalten, wenn die Sequenz leer ist (in Spring gibt's genau wie in .NET ne Exception)

Zitat von Stevie:

Da ist nen kleiner aber subtiler Bug drin:

Ich weiß - deswegen mein Hinweis mit dem ausbauen. Es ging mir im Wesentlichen erstmal um die Syntax.

Eine andere Tretmine: was wenn für <T> kein Default-Comparer existiert?

Sorry, das ist keine Tretmine, sondern der Normalfall bei uns.
Tut mir leid hätte ich vielleicht gleich am Anfang noch dazu schreiben sollen. Bei "Menge von Elementen" handelt es sich nicht nur um Integer sondern Records, Klassen, etc. z.B. einem record von einem Abstand: Double und einem vector.
Müsste dann der Record einen IComparer implementerien? Oder die Liste. Habt ihr mir da auch ein Beispiel dazu? Basierend auf Spring4D reicht mir mal vorläufig.

Wie bei anderen Lösungen auch, muss der Comparer dann in irgendeiner Form bereitgestellt werden. Das kann durch einen zusätzlichen Parameter geschehen oder durch eine Art Registrierung zu den verschiedenen Typen.

Zitat von Uwe Raabe:

was wenn für <T> kein Default-Comparer existiert?

Es existiert immer einer (bzw wird erstellt) - ob ein binary compare eines records Sinn ergibt, ist dann eine andere Geschichte.

In Spring 2.0 bin ich einen Schritt (oder mehrere) weiter gegangen als die RTL, indem ich die Möglichkeit gegeben habe, einen Default Comparer zu registrieren (siehe unit Spring.Comparers).

Übrigens bieten alle Methoden der Spring Collections, die irgendwas mit comparern machen, immer einen Overload an, in den man einen comparer oder eine comparison übergeben kann, sollte man das nicht bei der Erstellung der Liste z.B. schon getan haben.

zusammenfalten · markieren

Delphi-Quellcode:

function CompareMyRecord(const left, right: TMyRecord): Integer;
begin
  // Vergleichslogik
end;

var
  list: IList<TMyRecord>;
  maxRec: TMyRecord;
begin
  ...
  maxRec := list.Max(CompareMyRecord);

Zitat von freimatz:

Müsste dann der Record einen IComparer implementerien? Oder die Liste. Habt ihr mir da auch ein Beispiel dazu? Basierend auf Spring4D reicht mir mal vorläufig.

Zur Veranschaulichung der Fälle. Kombination ist möglich. Beispiel für TComparison<T>:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TRec = record
    x, y: Integer;
  end;

function CompareRecY(const pmcLeft, pmcRight: TRec): Integer;
begin
  Result := (pmcLeft.y - pmcRight.y);
end;

const
  RECS: array[0..2] of TRec = ((x: 1; y: 4), (x: 5; y: 6), (x: 3; y: 2));
var
  list: IList<TRec>;
begin
  list := TCollections.CreateList<TRec>(RECS);
  list.Sort(CompareRecY);
  ShowMessage(Format('First Y: %d, Max Y: %d',[list[0].y, list.Max(CompareRecY).y]));
end;

Beispiel für IComparer<T>:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TData = class
  private
    FX, FY: Integer;
  public
    constructor Create(pmX, pmY: Integer);
    property X: Integer
      read FX;
    property Y: Integer
      read FY;
  end;

  TDataYComparer<T: TData> = class(TComparer<T>)
  public
    function Compare(const pmcLeft, pmcRight: T): Integer; override;
  end;

constructor TData.Create(pmX, pmY: Integer);
begin
  inherited Create;
  FX := pmX;
  FY := pmY;
end;

function TDataYComparer<T>.Compare(const pmcLeft, pmcRight: T): Integer;
begin
  Result := (T(pmcLeft).Y - T(pmcRight).Y);
end;

var
  list: IList<TData>;
  comp: IComparer<TData>;
begin
  comp := TDataYComparer<TData>.Create;
  list := TCollections.CreateObjectList<TData>(comp, True);
  list.Add(TData.Create(1, 4));
  list.Add(TData.Create(5, 6));
  list.Add(TData.Create(3, 2));
  list.Sort;
  ShowMessage(Format('First Y: %d, Max Y: %d',[list[0].Y, list.Max.Y]));
end;

Bis bald...
Thomas