rekord z tablicami 2d -> record z Tlist

Witam.
Mam zadeklarowane typy rekordów, oto jeden z nich:

type
 Tselekcjaad1 = record
 param0 : array of byte;
 param1 : array of single;
 param2 : array of array of single;
 param3: array of array of single;
 end;

Problemy zaczęły się gdy musiałem usuwać rekordy z tablic masowo, kombinowałem z tymczasowymi tablicami itp. Wszystko oczywiście można zrobić ale strasznie wolno zaczęło to chodzić (setlength swoje robi). Czytałem o Tlist gdzie jest łatwa możliwość edycji rekordów. Tylko nie mogę jakoś zadeklarować tego co chcę - przykład powyżej. Tylko nie krzyczeć, nigdy nie korzystałem z TList

http://lmgtfy.com/?q=delphi+tlist

Pewnie jak coś usuwasz to zamiast użyć Move to kopiujesz element po elemencie...
Co do list to masz przykład

unit TestList;

interface

uses
  Classes,
  Contnrs;

type
  TByteList = class(TList)
  private
    function Get(Index: Integer): Byte;
    procedure Put(Index: Integer; const Value: Byte);
  public
    function Add(Item: Byte): Integer;
    function First: Byte;
    function IndexOf(Item: Byte): Integer;
    procedure Insert(Index: Integer; Item: Byte);
    function Last: Byte;
    function Remove(Item: Byte): Integer;
    property Items[Index: Integer]: Byte read Get write Put; default;
  end;

  TSingleList = class(TList)
  private
    function Get(Index: Integer): Single;
    procedure Put(Index: Integer; const Value: Single);
  public
    function Add(Item: Single): Integer;
    function First: Single;
    function IndexOf(Item: Single): Integer;
    procedure Insert(Index: Integer; Item: Single);
    function Last: Single;
    function Remove(Item: Single): Integer;
    property Items[Index: Integer]: Single read Get write Put; default;
  end;

  TSingleSingleList = class(TObjectList)
  private
    function Get(Index: Integer): TSingleList;
    procedure Put(Index: Integer; const Value: TSingleList);
  public
    function Add(Item: TSingleList): Integer;
    function First: TSingleList;
    function IndexOf(Item: TSingleList): Integer;
    procedure Insert(Index: Integer; Item: TSingleList);
    function Last: TSingleList;
    function Remove(Item: TSingleList): Integer;
    property Items[Index: Integer]: TSingleList read Get write Put; default;
  end;

  TSelekcja = class
  private
    FParam0: TByteList;
    FParam1: TSingleList;
    FParam2: TSingleSingleList;
    FParam3: TSingleSingleList;
  public
    constructor Create;
    destructor Destroy; override;

    property param0: TByteList read FParam0;
    property param1: TSingleList read FParam1;
    property param2: TSingleSingleList read FParam2;
    property param3: TSingleSingleList read FParam3;
  end;

implementation

{ TByteList }

function TByteList.Add(Item: Byte): Integer;
begin
  Result := inherited Add(Pointer(Item));
end;

function TByteList.First: Byte;
begin
  Result := Byte(inherited First);
end;

function TByteList.Get(Index: Integer): Byte;
begin
  Result := Byte(inherited Get(Index));
end;

function TByteList.IndexOf(Item: Byte): Integer;
begin
  Result := inherited IndexOf(Pointer(Item));
end;

procedure TByteList.Insert(Index: Integer; Item: Byte);
begin
  inherited Insert(Index, Pointer(Item));
end;

function TByteList.Last: Byte;
begin
  Result := Byte(inherited Last);
end;

procedure TByteList.Put(Index: Integer; const Value: Byte);
begin
  inherited Put(Index, Pointer(Value));
end;

function TByteList.Remove(Item: Byte): Integer;
begin
  Result := inherited Remove(Pointer(Item));
end;

{ TSingleList }

function TSingleList.Add(Item: Single): Integer;
begin
  Result := inherited Add(Pointer(Item));
end;

function TSingleList.First: Single;
begin
  Result := Single(inherited First);
end;

function TSingleList.Get(Index: Integer): Single;
begin
  Result := Single(inherited Get(Index));
end;

function TSingleList.IndexOf(Item: Single): Integer;
begin
  Result := inherited IndexOf(Pointer(Item));
end;

procedure TSingleList.Insert(Index: Integer; Item: Single);
begin
  inherited Insert(Index, Pointer(Item));
end;

function TSingleList.Last: Single;
begin
  Result := Single(inherited Last);
end;

procedure TSingleList.Put(Index: Integer; const Value: Single);
begin
  inherited Put(Index, Pointer(Value));
end;

function TSingleList.Remove(Item: Single): Integer;
begin
  Result := inherited Remove(Pointer(Item));
end;

{ TSingleSingleList }

function TSingleSingleList.Add(Item: TSingleList): Integer;
begin
  result := inherited Add(Item);
end;

function TSingleSingleList.First: TSingleList;
begin
  result := TSingleList(inherited First);
end;

function TSingleSingleList.Get(Index: Integer): TSingleList;
begin
  result := TSingleList(inherited Get(Index));
end;

function TSingleSingleList.IndexOf(Item: TSingleList): Integer;
begin
  result := inherited IndexOf(Item);
end;

procedure TSingleSingleList.Insert(Index: Integer; Item: TSingleList);
begin
  inherited Insert(Index, Item);
end;

function TSingleSingleList.Last: TSingleList;
begin
  result := TSingleList(inherited Last);
end;

procedure TSingleSingleList.Put(Index: Integer; const Value: TSingleList);
begin
  inherited Put(Index, Value);
end;

function TSingleSingleList.Remove(Item: TSingleList): Integer;
begin
  result := inherited Remove(Item);
end;

{ TSelekcja }

constructor TSelekcja.Create;
begin
  FParam0 := TByteList.Create;
  FParam1 := TSingleList.Create;
  FParam2 := TSingleSingleList.Create(True);
  FParam3 := TSingleSingleList.Create(True);
end;

destructor TSelekcja.Destroy;
begin
  FParam0.Free;
  FParam1.Free;
  FParam2.Free;
  FParam3.Free;
  inherited;
end;

var
  x: TSelekcja;

initialization
  x := TSelekcja.Create;
  x.FParam0.Add(123);
  x.FParam1.Add(223);
  x.FParam2.Add(TSingleList.Create);
  x.FParam2[0].Add(213);
  x.FParam2[0][0] := 1234;

end.

ale czy to będzie szybsze?

Na listach pewnie było by szybsze, ale zależy do czego tego będziesz używał

Wielkie dzięki Misiekd. Na razie przemielam kod z tablic na listy później opiszę po testach jak to myka, ale zapowiada się ciekawie :)