10

Delphi 2010を使用して、次のように宣言されたクラスがあるとします。

TMyList = TList<TMyObject>

このリストについて、Delphiは親切にも列挙子を提供してくれるので、次のように書くことができます。

var L:TMyList;
    E:TMyObject;
begin
  for E in L do ;
end;

問題は、これを書きたいということです。

var L:TMyList;
    E:TMyObject;
begin
  for E in L.GetEnumerator('123') do ;
end;

つまり、いくつかの基準を使用して、同じリストに複数の列挙子を提供する機能が必要です。残念ながら、の実装には、指定された列挙子を返す、パラメーターのないfor X in Z関数の存在が必要です。Z.GetEnumeratorこの問題を回避するために、「GetEnumerator」関数を実装するインターフェイスを定義し、次にそのインターフェイスを実装するクラスを実装し、最後にインターフェイスを返す関数をTMyListに記述します。そして、非常に単純なクラスを手動で解放することに煩わされたくないので、インターフェイスを返します...とにかく、これには多くの入力が必要です。これは次のようになります。

TMyList = class(TList<TMyObject>)
protected

  // Simple enumerator; Gets access to the "root" list
  TSimpleEnumerator = class
  protected
  public
    constructor Create(aList:TList<TMyObject>; FilterValue:Integer);

    function MoveNext:Boolean; // This is where filtering happens
    property Current:TTipElement;
  end;

  // Interface that will create the TSimpleEnumerator. Want this
  // to be an interface so it will free itself.
  ISimpleEnumeratorFactory = interface
    function GetEnumerator:TSimpleEnumerator;
  end;

  // Class that implements the ISimpleEnumeratorFactory
  TSimpleEnumeratorFactory = class(TInterfacedObject, ISimpleEnumeratorFactory)
    function GetEnumerator:TSimpleEnumerator;
  end;

public
  function FilteredEnum(X:Integer):ISimpleEnumeratorFactory;
end;

これを使用して、私は最終的に書くことができます：

var L:TMyList;
    E:TMyObject;
begin
  for E in L.FilteredEnum(7) do ;
end;

これを行うためのより良い方法を知っていますか？たぶん、Delphiはパラメータを使ってGetEnumeratorを直接呼び出す方法をサポートしていますか？

後で編集：

私は、匿名メソッドを使用して列挙子を実装し、gabrの「レコード」ファクトリを使用してさらに他のクラスを保存するというRobertLoveのアイデアを使用することにしました。これにより、関数で数行のコードを使用するだけで、新しいクラス宣言を必要とせずに、コードを備えたまったく新しい列挙子を作成できます。

ライブラリユニットで、私の汎用列挙子がどのように宣言されるかを次に示します。

TEnumGenericMoveNext<T> = reference to function: Boolean;
TEnumGenericCurrent<T> = reference to function: T;

TEnumGenericAnonim<T> = class
protected
  FEnumGenericMoveNext:TEnumGenericMoveNext<T>;
  FEnumGenericCurrent:TEnumGenericCurrent<T>;
  function GetCurrent:T;
public
  constructor Create(EnumGenericMoveNext:TEnumGenericMoveNext<T>; EnumGenericCurrent:TEnumGenericCurrent<T>);

  function MoveNext:Boolean;
  property Current:T read GetCurrent;
end;

TGenericAnonEnumFactory<T> = record
public
  FEnumGenericMoveNext:TEnumGenericMoveNext<T>;
  FEnumGenericCurrent:TEnumGenericCurrent<T>;
  constructor Create(EnumGenericMoveNext:TEnumGenericMoveNext<T>;   EnumGenericCurrent:TEnumGenericCurrent<T>);
  function GetEnumerator:TEnumGenericAnonim<T>;
end;

そして、これがそれを使用する方法です。List<T>どのクラスでも、このような関数を追加できます（そして、この概念の力を示すためにを使用しない列挙子を意図的に作成しています）：

type Form1 = class(TForm)
protected
  function Numbers(From, To:Integer):TGenericAnonEnumFactory<Integer>;  
end;

// This is all that's needed to implement an enumerator!
function Form1.Numbers(From, To:Integer):TGenericAnonEnumFactory<Integer>;
var Current:Integer;
begin
  Current := From - 1;
  Result := TGenericAnonEnumFactory<Integer>.Create(
    // This is the MoveNext implementation
    function :Boolean
    begin
      Inc(Current);
      Result := Current <= To;
    end
    ,
    // This is the GetCurrent implementation
    function :Integer
    begin
      Result := Current;
    end
  );
end;

そして、これが私がこの新しい列挙子をどのように使用するかです：

procedure Form1.Button1Click(Sender: TObject);
var N:Integer;
begin
  for N in Numbers(3,10) do
    Memo1.Lines.Add(IntToStr(N));
end;
4

5 に答える 5

8

DeHL（http://code.google.com/p/delphilhlplib/）を参照してください。次のようなコードを記述できます。

for E in List.Where(...).Distinct.Reversed.Take(10).Select(...)... etc.

.NETで実行できるのと同じように（もちろん構文linqはありません）。

于 2010-07-05T09:46:55.527 に答える
6

あなたのアプローチは大丈夫です。これ以上の方法はわかりません。

列挙子ファクトリは、インターフェイスの代わりにレコードとして実装することもできます。

多分あなたはここでいくつかのアイデアを得るでしょう。

于 2010-07-05T10:22:22.377 に答える
4

Delphi Forのループ内サポートには、次のものが必要です:(ドキュメントから）

  • 配列、セット、文字列など、コンパイラが認識するプリミティブ型
  • IEnumerableを実装する型
  • Delphi言語ガイドに記載されているGetEnumeratorパターンを実装する型

Generics.Collections.pasを見ると、、、、およびタイプの3つの列挙子がある実装が見つかりますTDictionary<TKey,TValue>。Embarcaderoは、詳細な実装を使用したことを示しています。TKeyTValueTPair<TKey,TValue>

あなたはこのようなことをすることができます：

unit Generics.AnonEnum;
interface
uses
 SysUtils,
 Generics.Defaults,
 Generics.Collections;

type

  TAnonEnumerator<T> = class(TEnumerator<T>)
  protected
    FGetCurrent : TFunc<TAnonEnumerator<T>,T>;
    FMoveNext : TFunc<TAnonEnumerator<T>,Boolean>;
    function DoGetCurrent: T; override;
    function DoMoveNext: Boolean; override;
  public
    Constructor Create(aGetCurrent : TFunc<TAnonEnumerator<T>,T>;
                       aMoveNext : TFunc<TAnonEnumerator<T>,Boolean>);
  end;

  TAnonEnumerable<T> = class(TEnumerable<T>)
  protected
    FGetCurrent : TFunc<TAnonEnumerator<T>,T>;
    FMoveNext : TFunc<TAnonEnumerator<T>,Boolean>;
    function DoGetEnumerator: TEnumerator<T>; override;
  public
    Constructor Create(aGetCurrent : TFunc<TAnonEnumerator<T>,T>;
                       aMoveNext : TFunc<TAnonEnumerator<T>,Boolean>);
  end;

implementation

{ TEnumerable<T> }

constructor TAnonEnumerable<T>.Create(aGetCurrent: TFunc<TAnonEnumerator<T>, T>;
  aMoveNext: TFunc<TAnonEnumerator<T>, Boolean>);
begin
  FGetCurrent := aGetCurrent;
  FMoveNext := aMoveNext;
end;

function TAnonEnumerable<T>.DoGetEnumerator: TEnumerator<T>;
begin
 result := TAnonEnumerator<T>.Create(FGetCurrent,FMoveNext);
end;


{ TAnonEnumerator<T> }

constructor TAnonEnumerator<T>.Create(aGetCurrent: TFunc<TAnonEnumerator<T>, T>;
  aMoveNext: TFunc<TAnonEnumerator<T>, Boolean>);
begin
  FGetCurrent := aGetCurrent;
  FMoveNext := aMoveNext;
end;

function TAnonEnumerator<T>.DoGetCurrent: T;
begin
  result := FGetCurrent(self);
end;

function TAnonEnumerator<T>.DoMoveNext: Boolean;
begin
 result := FMoveNext(Self);
end;

end.

これにより、CurrentメソッドとMoveNextメソッドを匿名で宣言できます。

于 2010-07-05T09:54:37.430 に答える
3

GetEnumerator()次のように列挙子に関数を追加すると、ファクトリとインターフェイスを廃止できます。

TFilteredEnum = class
public
  constructor Create(AList:TList<TMyObject>; AFilterValue:Integer);

  function GetEnumerator: TFilteredEnum;

  function MoveNext:Boolean; // This is where filtering happens
  property Current: TMyObject;
end;

そして、ただ自分自身を返します：

function TFilteredEnum.GetEnumerator: TSimpleEnumerator;
begin
  result := Self;
end;

Delphiは、他の列挙子と同じように、インスタンスを便利にクリーンアップします。

var 
  L: TMyList;
  E: TMyObject;
begin
  for E in TFilteredEnum.Create(L, 7) do ;
end;

次に、列挙子を拡張して、コンストラクターに渡すことができる匿名メソッドを使用できます。

TFilterFunction = reference to function (AObject: TMyObject): boolean;

TFilteredEnum = class
private
  FFilterFunction: TFilterFunction;
public
  constructor Create(AList:TList<TMyObject>; AFilterFunction: TFilterFunction);

  ...
end;

...

function TFilteredEnum.MoveNext: boolean;
begin
  if FIndex >= FList.Count then
    Exit(False);
  inc(FIndex);
  while (FIndex < FList.Count) and not FFilterFunction(FList[FIndex]) do
    inc(FIndex);
  result := FIndex < FList.Count;
end;

このように呼んでください：

var 
  L:TMyList;
  E:TMyObject;
begin
  for E in TFilteredEnum.Create(L, function (AObject: TMyObject): boolean
                                   begin
                                     result := AObject.Value = 7;
                                   end;
                                ) do 
  begin
    //do stuff here
  end
end;

そうすれば、それをジェネリックにすることもできますが、ここではそれを行いません。私の答えはそれなりに長いです。

N @

于 2010-07-06T02:23:45.597 に答える
1

私はこのアプローチを使用します...AProcがフィルターテストを実行します。

TForEachDataItemProc = reference to procedure ( ADataItem: TDataItem; var AFinished: boolean );

procedure TDataItems.ForEachDataItem(AProc: TForEachDataItemProc);
var
  AFinished: Boolean;
  ADataItem: TDataItem;
begin
  AFinished:= False;
  for ADataItem in FItems.Values do
  begin
    AProc( ADataItem, AFinished );
    if AFinished then
      Break;
  end;
end;
于 2010-07-05T09:23:14.643 に答える