Question

我有一系列TPersistent对象。我想通过它们的内存位置（作为主索引）和它们的属性（使用rtti）来索引它们。集合可能有几个基于属性的索引（基于不同的属性）。

解决此问题的策略和数据结构是什么，因此在处理基于属性的索引时，我可以从集合中删除无效对象（已经被销毁的对象）而没有访问冲突？

编辑：澄清事情，我希望实现这种接口（类和方法）：

type
  TMyItem=class(TPersistent)
  public
    property HasProp[Name: string]: Boolean read GetHasProp;
    property PropValue[Name: string]: Variant read GetPropValue write SetPropValue;
  end;

  TMyCollection=class(TPersistent)
  private
    FMainList: TSortedList;
    FIndexes : TIndexes;
  public
    function Add(AItem: TMyItem): Integer;
    procedure Extract(AItem: TMyItem);
    procedure Delete(AItem: TMyItem);

    // and new sorted list based on the given property name to the FIndexes
    procedure AddIndex(const APropName: string);
    // remove sorted list correspoding to the given property name from FIndexes
    procedure RemoveIndex(const APropName: string);

    // just to see if the item is in the collection
    function Find(AItem: TMyItem): Boolean;
    // try to find first item which property specified by APropName has value specified by APropValue
    function Find(const APropName: string; const APropValue: Variant; var AItem: TMyItem): Boolean;
  end;

FMainList包含指向TMyItem实例的指针列表。通过将指针强制转换为NativeInt进行排序。因此，如果找到无效的对象，那将是没有问题的。但是在基于属性的索引中，我根据属性值对TMyItem进行排序。因此，如果我试图找到无效TMyItem的条目（已经被销毁的条目），则会引发EAccessViolation，因为我需要获取属性值。

我目前解决这个问题的想法是将TMyItem在每个基于属性的索引中的位置存储到存储在FMainList中的主记录中。但是这种方法还需要在每次添加或删除新项目时更新所有位置。这是我想要避免的。那么还有其他更好的机制吗？

Answer 1

这些问题通常会导致在保存或计算索引之间做出选择，这与速度和内存之间的选择是同义的。它还取决于用法：那些经常被调用的Find例程吗？

就像你自己说的那样：将每个索引保存在一个单独的数组中会带来所有类型的同步问题，同时还需要额外的内存。

就个人而言，我会根据要求计算/获取每个索引。当然，花费一些时间来迭代所有项目，但是当计数保持在100K以下甚至更高的数字时，我相信它不会受到任何延迟的影响。当您将设计基于TCollection类似于menjaraz评论时，您不必担心已删除的项目：将不会有任何内容。

更新

因为你想在具有需要使用RTTI的任意名称的属性中搜索值，所以这个迭代任务可能会慢一点。为了消除这种情况，我为你写了这个优化。它基于排除搜索操作中没有属性的项目。为此，我将集合中包含的属性名称与它们所属的类一起存储。唯一的限制是没有重复的属性名称，但我怀疑你将在共同的祖先中组合具有相同属性名称的类。（但是，只要第二个类继承自第一个类，就可以添加具有相同属性名的类。）

unit MyCollection;

interface

uses
  Classes, TypInfo;

type
  TMyItem = class(TCollectionItem)
  end;

  TMyCollection = class(TOwnedCollection)
  private
    FPrevItemClass: TClass;
    FPropList: TStringList;
    function GetItem(Index: Integer): TMyItem;
    procedure RegisterItemClass(AClass: TClass);
    procedure SetItem(Index: Integer; Value: TMyItem);
  protected
    procedure Notify(Item: TCollectionItem;
      Action: TCollectionNotification); override;
  public
    constructor Create(AOwner: TPersistent); virtual;
    destructor Destroy; override;
    function Find(AItem: TMyItem): Boolean; overload;
    function Find(const APropName: String; AValue: Variant;
      var AItem: TMyItem): Boolean; overload;
    property Items[Index: Integer]: TMyItem read GetItem write SetItem;
      default;
  end;

implementation

resourcestring
  SDupPropName = 'Duplicate property name. Only classes with unique ' +
                 'property names are supposed to be added to this collection.';

{ TMyCollection }

constructor TMyCollection.Create(AOwner: TPersistent);
begin
  inherited Create(AOwner, TMyItem);
  FPropList := TStringList.Create;
  RegisterItemClass(TMyItem);
end;

destructor TMyCollection.Destroy;
begin
  FPropList.Free;
  inherited Destroy;
end;

function TMyCollection.Find(AItem: TMyItem): Boolean;
var
  I: Integer;
begin
  for I := 0 to Count - 1 do
    if Items[I] = AItem then
    begin
      Result := True;
      Exit;
    end;
  Result := False;
end;

function TMyCollection.Find(const APropName: String; AValue: Variant;
  var AItem: TMyItem): Boolean;
var
  I: Integer;
  ItemClass: TClass;
begin
  Result := False;
  if FPropList.Find(APropName, I) then
  begin
    ItemClass := TClass(FPropList.Objects[I]);
    for I := 0 to Count - 1 do
      if Items[I] is ItemClass then
        if GetPropValue(Items[I], APropName, False) = AValue then
        begin
          AItem := Items[I];
          Result := True;
        end;
  end;
end;

function TMyCollection.GetItem(Index: Integer): TMyItem;
begin
  Result := TMyItem(inherited GetItem(Index));
end;

procedure TMyCollection.Notify(Item: TCollectionItem;
  Action: TCollectionNotification);
begin
  inherited Notify(Item, Action);
  if Action = cnAdded then
    if Item.ClassType <> FPrevItemClass then
      if FPropList.IndexOfObject(TObject(Item.ClassType)) = -1 then
        RegisterItemClass(Item.ClassType)
end;

procedure TMyCollection.RegisterItemClass(AClass: TClass);
var
  PropCount: Integer;
  PropList: PPropList;
  I: Integer;
  J: Integer;
  PropName: String;
begin
  PropCount := GetTypeData(AClass.ClassInfo)^.PropCount;
  if PropCount > 0 then
  try
    GetPropList(AClass.ClassInfo, PropList);
    for I := 0 to PropCount - 1 do
    begin
      PropName := PropList[I].Name;
      if not FPropList.Find(PropName, J) then
      begin
        FPropList.AddObject(PropName, TObject(AClass));
      end
      else
        if not AClass.InheritsFrom(TClass(FPropList.Objects[J])) then
          raise EInvalidOperation.Create(SDupPropName);
    end;
    FPrevItemClass := AClass;
  finally
    FreeMem(PropList);
  end;
end;

procedure TMyCollection.SetItem(Index: Integer; Value: TMyItem);
begin
  inherited SetItem(Index, Value);
end;

end.

收集索引策略

1 个答案:

更新