Implementacja listy Enumerator typów w Delphi

Nie chcesz używać IEnumerator z systemu.pas, zaufaj mi. To coś sprawia tyle kłopotów, ponieważ dziedziczy z IEnumerator i tak ma tę metodę GetCurrent z różnymi wynikami (TObject dla IEnumerator i T dla IEnumerator).

Lepiej zdefiniuj swojego Ienumeratora:

IEnumerator<T> = interface
  function GetCurrent: T;
  function MoveNext: Boolean;
  procedure Reset;
  property Current: T read GetCurrent;
end;

To samo z IEnumerable. Powiedziałbym, że zdefiniuj swój własny IEnumerable:

IEnumerable<T> = interface
  function GetEnumerator: IEnumerator<T>;
end;

Jeśli użyjesz tego w TOfTypeEnumerator możesz usunąć metodę klauzule rozdzielcze powodujące lód.

Kiedy to zrobisz, zaczniesz widzieć inne błędy kompilatora E2008, E2089 i kilka innych.

• Wywołanie po prostu dziedziczone w konstruktorze próbuje wywołać konstruktor z tym samym podpisem w klasie przodka, która nie istnieje. Więc zmień go na dziedziczone Tworzenie.

• Nie używaj IEnumerable, ale używaj IEnumerable ponieważ to jest to, co chcesz wyliczyć przez

• Nie używaj metod i odlewy, które są dozwolone tylko dla obiektów lub określają ograniczenie klasy na T i TFilter

• MoveNext wymaga wyniku

Oto Jednostka kompilacji. Zrobiłem szybki test i wygląda na to, że działa:

unit uTestList;

interface

uses
  Generics.Collections;

type
  IEnumerator<T> = interface
    function GetCurrent: T;
    function MoveNext: Boolean;
    property Current: T read GetCurrent;
  end;

  IEnumerable<T> = interface
    function GetEnumerator: IEnumerator<T>;
  end;

  TOfTypeEnumerator<T: class; TFilter: class> = class(TInterfacedObject, IEnumerator<TFilter>)
  private
    FTestList: TList<T>;
    FIndex: Integer;
  protected
    constructor Create(Owner: TList<T>); overload;

    function GetCurrent: TFilter;
    function MoveNext: Boolean;
  end;

  TOfTypeEnumeratorFactory<T: class; TFilter: class> = class(TInterfacedObject, IEnumerable<TFilter>)
  private
    FTestList: TList<T>;
  public
    constructor Create(Owner: TList<T>); overload;
    function GetEnumerator: IEnumerator<TFilter>;
  end;

  TTestList<T: class> = class(TList<T>)
  public
    function OfType<TFilter: class>: IEnumerable<TFilter>;
  end;

implementation

{ TOfTypeEnumerator<T, TFilter> }

constructor TOfTypeEnumerator<T, TFilter>.Create(Owner: TList<T>);
begin
  inherited Create;
  FTestList := Owner;
  FIndex := -1;
end;

function TOfTypeEnumerator<T, TFilter>.GetCurrent: TFilter;
begin
  Result := TFilter(TObject(FTestList[FIndex]));
end;

function TOfTypeEnumerator<T, TFilter>.MoveNext: Boolean;
begin
  repeat
    Inc(FIndex);
  until (FIndex >= FTestList.Count) or FTestList[FIndex].InheritsFrom(TFilter);
  Result := FIndex < FTestList.Count;
end;

{ TOfTypeEnumeratorFactory<T, TFilter> }

constructor TOfTypeEnumeratorFactory<T, TFilter>.Create(Owner: TList<T>);
begin
  inherited Create;
  FTestList := Owner;
end;

function TOfTypeEnumeratorFactory<T, TFilter>.GetEnumerator: IEnumerator<TFilter>;
begin
  Result := TOfTypeEnumerator<T, TFilter>.Create(FTestList);
end;

{ TTestList<T> }

function TTestList<T>.OfType<TFilter>: IEnumerable<TFilter>;
begin
  Result := TOfTypeEnumeratorFactory<T,TFilter>.Create(self);
end;

end.