在 Delphi XE 中使用通用容器 - 总是？

Question

通用容器在拥有一个项目和这些项目的强类型列表时可以节省时间。它节省了使用 TList 内部变量和类型化的 Add/Delete 类型方法创建新类的重复编码，以及其他好处（例如通用容器类提供的所有新功能。）

但是，是否建议今后始终对强类型列表使用通用容器？这样做的具体缺点是什么？ （如果不担心代码的向后兼容性。）我昨天正在编写一个服务器应用程序，并且有一个我创建的“旧方式”的项目列表，并将用通用列表替换它，但决定保持精简，但是主要是出于习惯。 （我们是否应该改掉这个习惯并通过始终使用泛型来开始一个新的习惯？）

Answer 1

在 Delphi XE 中，没有理由不使用通用容器。

使用强制转换从旧方法切换将为您提供：

• 更简洁、类型安全、不易出错的代码，
• 枚举器，for in 循环，
• 相同更好的性能特征。

Answer 2

我们应该改掉这个习惯并通过始终使用泛型来开始一个新的习惯吗？ 是

Answer 3

在大多数情况下，是的，通用容器是一件好事。但是，the compiler generates a lot of duplicate code, 不幸的是，链接器还不知道如何删除它，因此大量使用泛型可能会导致可执行文件臃肿。但除此之外，它们都很棒。

Answer 4

您写了关于向后兼容性的文章...这是我最关心的问题，如果（像我一样）您正在编写应该更好地与最常见的 Delphi 版本编译的库。

即使您只将 XE 用于已关闭的项目，您也可能正在制作自己的一些自定义库，即使您从未发布过代码。我们手头都有这样最喜欢的单元，只是可以不用为每个项目重新发明轮子。

在未来的任务中，您可能必须维护一些旧代码，而无法升级到较新的 Delphi 版本（没有钱进行 1,000,000 行代码迁移和审查）。在这种情况下，您可能会错过仅限 XE 的库，以及基于泛型的闪亮列表...

但是对于一个 100%“私有”的应用程序，如果你确信你永远不必维护旧的 Delphi 代码，我看不出有任何理由不使用泛型。我唯一担心的是重复代码问题（正如 Mason 所引用的）：CPU 缓存可能会被不必要的代码填充，因此执行速度可能会受到影响。但在实际应用中，我认为您不会看到任何区别。

注意：我刚刚添加了一些new features to my TDynArray wrapper。我试图模仿the sample code from EMB docwiki。因此，您可以拥有类似泛型的功能，以及良好的旧 Delphi 版本...当然，泛型更适合处理类，但对于一些数组和记录，它就很糟糕！

Answer 5

如果您需要多态列表，那么泛型是一个障碍，而不是帮助。例如，这甚至无法编译，因为您不能在需要 TAnimalList 的地方使用 TDogList：

  uses
    Generics.Collections;

  type
    TAnimal = class
    end;

    TDog = class(TAnimal)
    end;

    TAnimalList = TList<TAnimal>;
    TDogList = TList<TDog>;


  procedure FeedTheAnimals(const aList: TAnimalList);
  begin
    // Blah blah blah
  end;


  var
    dogs: TDogList;
  begin
    dogs := TDogList.Create;
    try
      FeedTheAnimals(dogs);

    finally
      dogs.Free;
    end;
  end;

这样做的原因很清楚，也很容易解释，但同样违反直觉。

我自己的观点是，您可以通过使用泛型而不是滚动更具体和更适合您的需求的类型安全容器来节省几秒钟或几分钟（如果您是一个慢打字员），但您很可能最终会花费未来解决泛型的问题和限制的时间比你从一开始就使用它们节省的时间要多（根据定义，如果你到目前为止还没有使用过泛型容器，那么你不知道这些问题/限制可能是什么直到你遇到他们）。

如果我需要一个 TAnimalList，那么我很可能需要或可以从该列表类上的其他 TAnimal 特定方法中受益，我想在 TDogList 中继承这些方法，这反过来可能会引入与它的 TDog 项相关的其他特定成员。

（当然，Animal and Dog 仅用于说明目的。我目前实际上并没有编写兽医代码 - LOL）

问题是，你并不总是一开始就知道这一点。

防御性编程原则表明（对我来说，ymmv）为了节省一点时间而把自己逼到角落里可能会在未来付出很多代价。如果不这样做，那么不预先节省的额外“成本”本身就可以忽略不计。

此外，如果您愿意如此慷慨，您的代码更易于与旧版 Delphi 的用户共享。

:)

Answer 6

这是由 Deltic 的回答提示的，我想提供一个反例来证明您可以在动物喂养程序中使用泛型。 （即：多态泛型列表）

首先是一些背景知识：您可以使用通用基列表类来喂养通用动物的原因是因为您通常会有这种继承：

TBaseList = class
  // Some code to actually make this a list
end

TSpecificList = class(TBaseList)
  // Code that reintroduces the Add and GetItem routines to turn TSpecificList
  // into a type-safe list of a different type, compatible with the TBaseList
end

这不适用于泛型，因为您通常会有这样的：

TDogList = TList<TDog>
end

TCatList = TList<TCat>
end

... 这两个列表的唯一“共同祖先”是TObject - 一点帮助都没有。但是我们可以定义一个新的泛型列表类型，它接受两个类参数：TAnimal 和TSpecificAnimal，生成与TAnimal 的泛型列表兼容的TSpecificAnimal 类型安全列表。这是基本类型定义：

TCompatibleList<T1:class;T2:class> = class(TObjectList<T1>)
private
  function GetItem(i: Integer): T2;
public
  procedure Add(A:T2);
  property Item[i:Integer]:T2 read GetItem;default;
end;

使用这个我们可以做到：

TAnimal = class; 
TDog = class(TAnimal); 
TCat = class(TAnimal);

TDogList = TCompatibleList<TAnimal, TDog>;
TCatList = TCompatibleList<TAnimal, TCat>;

这样 TDogList 和 TCatList 实际上都继承自 TObjectList<TAnimal>，所以我们现在有了一个多态的泛型列表！

这是一个完整的控制台应用程序，展示了这个概念的实际应用。该类现在正在进入我的 ClassLibrary 以供将来重用！

program Project23;

{$APPTYPE CONSOLE}

uses
  SysUtils, Generics.Collections;

type

  TAnimal = class
  end;

  TDog = class(TAnimal)
  end;

  TCat = class(TAnimal)
  end;

  TCompatibleList<T1:class;T2:class> = class(TObjectList<T1>)
  private
    function GetItem(i: Integer): T2;
  public
    procedure Add(A:T2);
    property Item[i:Integer]:T2 read GetItem;default;
  end;

{ TX<T1, T2> }

procedure TCompatibleList<T1, T2>.Add(A: T2);
begin
  inherited Add(T1(TObject(A)));
end;

function TCompatibleList<T1, T2>.GetItem(i: Integer): T2;
begin
  Result := T2(TObject(inherited Items[i]));
end;

procedure FeedTheAnimals(L: TObjectList<TAnimal>);
var A: TAnimal;
begin
  for A in L do
    Writeln('Feeding a ' + A.ClassName);
end;

var Dogs: TCompatibleList<TAnimal, TDog>;
    Cats: TCompatibleList<TAnimal, TCat>;
    Mixed: TObjectList<TAnimal>;

begin
  try
    // Feed some dogs
    Dogs := TCompatibleList<TAnimal, TDog>.Create;
    try
      Dogs.Add(TDog.Create);
      FeedTheAnimals(Dogs);
    finally Dogs.Free;
    end;
    // Feed some cats
    Cats := TCompatibleList<TAnimal, TCat>.Create;
    try
      Cats.Add(TCat.Create);
      FeedTheAnimals(Cats);
    finally Cats.Free;
    end;
    // Feed a mixed lot
    Mixed := TObjectList<TAnimal>.Create;
    try
      Mixed.Add(TDog.Create);
      Mixed.Add(TCat.Create);
      FeedTheAnimals(Mixed);
    finally Mixed.Free;
    end;
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Answer 7

本着 Cosmin 回答的精神，本质上是对 Deltic 回答的回应，这里是如何修复 Deltic 的代码：

type
  TAnimal = class
  end;

  TDog = class(TAnimal)
  end;

  TAnimalList<T:TAnimal> = class(TList<T>)
    procedure Feed;
  end;
  TDogList = TAnimalList<TDog>;

现在你可以写了：

var
  Dogs: TDogList;
...
  Dogs.Feed;