Hallo,

Delphi 12.3 und gegeben sei diese Klassendeklaration:

markieren

Delphi-Quellcode:

  TProductTreeItemList = class(TObjectList<TProductTreeItem>,
                               IEnumerator<TProductTreeItem>)

Ich will also das IEnumerator Interface umsetzen.
AddRef usw. hab' ich schon drin.

Nur: wie muss GetCurrent deklariert werden, damit mich
der Compiler auch mag?

das ist es nicht:
function GetCurrent: TProductTreeItem; Der Compiler meckert so:

[dcc32 Fehler] ProductTreeItemList.pas(49): E2211 Deklaration von 'GetCurrent' unterscheidet sich von der Deklaration in Interface 'System.IEnumerator<ProductTreeItem.TProductTreeIt em>'
System.pas(1011): Verwandtes Member: function GetCurrent: TObject;

Ja, ich hatte auch schon mal ein zusätzliches GetCurrent: TObject; overload; Hat aber auch nix gebracht.

Zitat:

markieren

Delphi-Quellcode:

  IEnumerator<T> = interface(IEnumerator)
    function GetCurrent: T;

Das TProductTreeItem im Interface ist aber auch das selbe, wie in der Implementation?



Brauchst du unbedingt das IEnumerator<> oder reicht "ein" Enumerator für FOR-Schleifen?
Bei Letzterem muß die Methide einfach nur so lauten function GetEnumerator: ....; inline; und irgendeine Klasse zurück geben,
mit Methoden die so heißen (mit oder ohne inline)

markieren

Delphi-Quellcode:

function GetCurrent: ...; inline;
function MoveNext: Boolean; inline;
property Current: Pointer read ...;

Leider ist das mit IEnumerator echt nicht so schön, da du GetCurrent mit unterschiedlichen Rückgabewerten brauchst. Overload geht nicht, da beide keine Parameter haben. Du musst daher eine der Methoden anders nennen und umleiten. Das funktioniert so:

markieren

Delphi-Quellcode:

    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    function GetCurrent: TObject;
    function MoveNext: Boolean;
    procedure Reset;
    function IEnumerator<TProductTreeItem>.GetCurrent = GetCurrentT;
    function GetCurrentT: TProductTreeItem;

Hallo,

ja damit komme ich einen Schritt weiter:

Zitat von jaenicke:

Leider ist das mit IEnumerator echt nicht so schön, da du GetCurrent mit unterschiedlichen Rückgabewerten brauchst. Overload geht nicht, da beide keine Parameter haben. Du musst daher eine der Methoden anders nennen und umleiten. Das funktioniert so:

markieren

Delphi-Quellcode:

    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    function GetCurrent: TObject;
    function MoveNext: Boolean;
    procedure Reset;
    function IEnumerator<TProductTreeItem>.GetCurrent = GetCurrentT;
    function GetCurrentT: TProductTreeItem;

Aber: wenn ich jetzt irgendwo sowas tun will:

markieren

Delphi-Quellcode:

TMyClass.DoSomething(ProductData : IEnumerator<TProductTreeItem>;);
begin
  for var TreeItem in ProductData do
    ;
end;

Dann meckert der Compiler:
[dcc32 Fehler] ProductManagerTreeDisplay.pas(139): E2431 for-in-Anweisung arbeitet nicht mit Kollektionstyp 'System.IEnumerator<ProductTreeItem.TProductTreeIt em>', weil 'System.IEnumerator<ProductTreeItem.TProductTreeIt em>' kein Element für 'GetEnumerator' enthält oder darauf nicht zugegriffen werden kann

Nur hab' ich noch nicht kapiert wie ich GetEnumerator umsetzen muss. Alle Versuche bisher scheiterten.
z. B. sowas hier:

markieren

Delphi-Quellcode:

function GetEnumerator: IEnumerator<TProductTreeItem>;
function IEnumerator<TProductTreeItem>.GetEnumerator = GetEnumeratorT;
function GetEnumeratorT: IEnumerator<TProductTreeItem>;

Wenn du for..in verwenden möchtest, muss deine Liste die Methode GetEnumerator implementieren und dort den Enumerator zurückliefern und nicht selbst implementieren. Du musst also IEnumerable<TProductTreeItem> implementieren. Und du benötigst eine Enumerator-Klasse, die IEnumerator<TProductTreeItem> implementiert.

Warum nicht direkt in der Klasse implementieren? Es könnten ja mehrere verschachtelte Enumerationen laufen. Die brauchen daher eigene Instanzen des Enumerators.

Hallo,

ich verstehe grob was du meinst, bekomme es aber nicht hin.

Hier mal was ich so habe:

zusammenfalten · markieren

Delphi-Quellcode:

  TProductTreeItemList = class;

  TProductTreeItemListEnumerator = class(TObject)
  strict private
    FIndex : Integer;
    FList : TProductTreeItemList;
  public
    constructor Create(AList: TProductTreeItemList);
    function GetCurrent: TObject; inline;
    function GetCurrentT: TProductTreeItem;
    function MoveNext: Boolean; inline;
    property Current: TProductTreeItem
      read GetCurrentT;
  end;

  TProductTreeItemList = class(TObjectList<TProductTreeItem>)
  strict private
    [..]
    function GetEnumerator: TProductTreeItemListEnumerator;
  public
    [..]

    function GetLastGroupProductIndex(GroupID: Integer): TGroupProductIndexRec;
  end;



function TProductTreeItemList.GetEnumerator: TProductTreeItemListEnumerator;
begin
  Result := TProductTreeItemListEnumerator.Create(self);
end;

function TProductTreeItemList.GetLastGroupProductIndex(GroupID: Integer): TGroupProductIndexRec;
var
  NewGroupFound : Boolean;
begin
  NewGroupFound := false;
  Result.GroupIndex := 0;
  Result.NextProductIndex := 0;

// Hier meckert der COmpiler:
// [dcc32 Fehler] ProductManagerTreeDisplay.pas(139): E2431 for-in-Anweisung arbeitet nicht mit Kollektionstyp
// 'System.IEnumerator<ProductTreeItem.TProductTreeItem>', weil 'System.IEnumerator<ProductTreeItem.TProductTreeItem>'
// kein Element für 'GetEnumerator' enthält oder darauf nicht zugegriffen werden kann
  for var GItem in self do
  begin
    if (GItem.NodeType = ntGroup) then
    begin
    end;
  end;
end;