logo标签列表

在TList<TMyObject>上实现筛选枚举器的更好方法

delphifilterdelphi-2010foreachenumerator
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的方法吗？
后来我决定采用Robert Love的想法，使用匿名方法实现枚举器，并使用gabr的“record”工厂来保存另一个类。这使我可以仅仅使用几行代码在函数中创建全新的、完整的带有代码的枚举器，而无需声明新的类。
下面是我的通用枚举器在库单元中的声明：
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;
谢谢您，现在实现类的枚举器支持变得更加容易了。如果您想使用像“for obj in list do”这样的东西，只需声明GetEnumerator()如下：“function GetEnumerator:TEnumGenericAnonim<T>”，然后在实现中在Create语句的最后添加“.GetEnumerator”。 - Sharken
5个回答
8

请查看DeHL (http://code.google.com/p/delphilhlplib/)。您可以编写类似以下代码的代码：

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

就像在.NET中一样（当然没有语法linq）。

谢谢提供链接。即使我最终使用DeHL，我也会更倾向于Robert Love的答案，因为它展示了一种语言特性，可以让我自己实现这个功能。 - Cosmin Prund
当然。如果您不想投资于这种事情，DeHL可以节省您的时间。如果您更喜欢编写自己的轻量级实现，则Robert的答案是最佳选择。 - alex
6

你的方法很好，我不知道有更好的方法。

枚举器工厂也可以实现为记录而不是接口。

也许你会在这里得到一些想法。

使用记录（record）而不是接口（interface）可以省去我另外再写一个“类”。谢谢。 - Cosmin Prund
4
Delphi中的“for in”循环支持需要以下之一：（从文档中了解更多）
  • 编译器可以识别的原始类型，如数组、集合或字符串
  • 实现IEnumerable接口的类型
  • 按照Delphi语言指南中所述实现GetEnumerator模式的类型
如果您查看Generics.Collections.pas文件，您会发现TDictionary<TKey,TValue>的实现，其中有三个枚举器用于TKey、TValue和TPair<TKey,TValue>类型。Embarcadero表明他们使用了冗长的实现方法。
您可以像这样做：
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方法。
1
使用匿名方法来实现枚举器的想法绝对是非常聪明的，它使我免于创建无数个类来实现不同的枚举器。毕竟，枚举器的代码通常非常简单，只需要几行代码就可以实现。谢谢。 - Cosmin Prund
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@

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;
谢谢Nige，但这并没有回答我的问题。我问的是如何实现枚举器，因为我想使用“for E in L”循环。 - Cosmin Prund
这是一个好主意（虽然与问题不完全相关），并且真的不应该被踩。 - gabr
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接