TBuildingList = class
  private
    FBuildings: TList;
    function GetCount: Integer;
    function GeTBuilding(Index: Integer): TBuilding;
    function GetAsJSON: string;
    procedure SetAsJSON(const Value: string);
  public
    constructor Create;
    destructor Destroy; override;
    procedure Clear;
    procedure Add(aBuilding: TBuilding);
    procedure Assign(Src: TBuildingList);
    procedure LoadFromJSON(const Str: string); overload;
    procedure LoadFromJSON(Js: ISuperObject); overload;
    procedure SaveToJSON(Js: ISuperObject); overload;
    function SaveToJSON: ISuperObject; overload;
    function IndexOf(ID: Integer): Integer; overload;
    function IndexOf(aItem: TBuilding): Integer; overload;
    function ItemByID(ID: Integer): TBuilding;
    procedure Delete(Index: Integer); overload;
    procedure Delete(aItem: TBuilding); overload;

    property Count: Integer read GetCount;
    property Building[Index: Integer]: TBuilding read GeTBuilding; default;
    property AsJSON: string read GetAsJSON write SetAsJSON;
  end;


............................

{ TBuildingList }

constructor TBuildingList.Create;
begin
  FBuildings := TList.Create;
end;

procedure TBuildingList.Delete(Index: Integer);
begin
  if (Index < 0) or (Index >= Count) then
    raise Exception.Create(ErrItemNotFound);

  TBuilding(FBuildings[Index]).Free;
  FBuildings.Delete(Index);
end;

procedure TBuildingList.Delete(aItem: TBuilding);
begin
  Delete(IndexOf(aItem));
end;

destructor TBuildingList.Destroy;
begin
  Clear;
  FBuildings.Free;
  inherited;
end;

procedure TBuildingList.Add(aBuilding: TBuilding);
begin
  FBuildings.Add(aBuilding)
end;

procedure TBuildingList.Assign(Src: TBuildingList);
var
  I: Integer;
begin
  Clear;
  for I := 0 to Src.Count - 1 do
    Add(Src[I]);
end;

procedure TBuildingList.Clear;
var
  I: Integer;
begin
  for I := 0 to FBuildings.Count - 1 do
    Building[I].Free;
  FBuildings.Clear;
end;


function TBuildingList.GetAsJSON: string;
begin
  Result := SaveToJSON.AsJSon;
end;

function TBuildingList.GetCount: Integer;
begin
  Result := FBuildings.Count;
end;

function TBuildingList.IndexOf(ID: Integer): Integer;
var
  I: Integer;
begin
  for I := 0 to Count - 1 do
    if Building[I].ID = ID then
    begin
      Result := I;
      Exit;
    end;
  Result := -1;
end;

function TBuildingList.GeTBuilding(Index: Integer): TBuilding;
begin
  if (Index >= 0) and (Index < Count) then
    Result := TBuilding(FBuildings[Index])
  else
    Result := nil;
end;

function TBuildingList.IndexOf(aItem: TBuilding): Integer;
begin
 Result := FBuildings.IndexOf(aItem);
end;

function TBuildingList.ItemByID(ID: Integer): TBuilding;
begin
  Result := Building[IndexOf(ID)];
end;

procedure TBuildingList.LoadFromJSON(const Str: string);
begin
  if Length(Str) > 0 then
    LoadFromJSON(SO(Str))
  else
    Clear;
end;

procedure TBuildingList.LoadFromJSON(Js: ISuperObject);
var
  Arr: TSuperArray;
  Building: TBuilding;
  I: Integer;
begin
  if (Js = nil) or (Js.DataType <> stArray) then
    raise Exception.Create(ErrInvalidParam);

  Clear;
  Arr := Js.AsArray;
  for I := 0 to Count - 1 do
  begin
    Building := TBuilding.Create;
    try
      Building.LoadFromJSON(Arr[I]);
      Add(Building);
    except
      Building.Free;
      raise;
    end;
  end;
end;

function TBuildingList.SaveToJSON: ISuperObject;
begin
  Result := TSuperObject.Create(stArray);
  SaveToJSON(Result);
end;


procedure TBuildingList.SetAsJSON(const Value: string);
begin
  LoadFromJSON(Value);
end;


procedure TBuildingList.SaveToJSON(Js: ISuperObject);
var
  Arr: TSuperArray;
  I: Integer;
begin
  if (Js = nil) or (Js.DataType <> stArray) then
    raise Exception.Create(ErrInvalidParam);

  Arr := Js.AsArray;
  for I := 0 to Count - 1 do
    Arr.Add(Building[I].SaveToJSON);
end;