[ecfisa]

Hola jularaXD.

Mas allá del tamaño de tu arreglo en memoria (50000*6*11 = 33.14713 Mb), podría suceder que mas adelante se les ocurra pedirte que obtengas el valor de una monitorización de un año atrás... Entonces tendrás para manejar 397,69 Mb aprox.

Como sugirió Lepe, lo podes gestionar de manera sencilla usando listas dinámicas como en este esbozo al vuelo:

Código Delphi [-]
...
uses contnrs;

type
  TStr10 = string[10];
  TClase = class
    v: array[0..5] of TStr10;
  end;

var
  List: TObjectList;

procedure TForm1.FormCreate(Sender: TObject);
var
  i: Integer;
  C: TClase;
begin
  List:= TObjectList.Create;
  for i:= 0 to 100 do
  begin
    C:= TClase.Create;
    C.v[0]:= 'cero';
    C.v[1]:= 'uno';
    C.v[2]:= 'dos';
    c.v[3]:= 'tres';
    c.v[4]:= 'cuatro';
    c.v[5]:= 'cinco';
    List.Add(TObject(C));
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  col,row: Integer;
  s: string;
begin
  for row:= 0 to 100 do
  begin
    s:= IntToStr(row)+') ';
    for col:= 0 to 5 do s:= s + TClase(List[row]).v[col] + ',';
    SetLength(s,Length(s)-1);
    ListBox1.Items.Add(s);
  end;
end;
...

también con un árbol binario de búsqueda o un arreglo de apuntadores, cada una con sus pros y contras. Estas soluciones han sido (y son), usadas como las mejores en los procesamientos de arreglos casi vacíos, vg.: planillas de cálculo.

O también,como sugirió duiliosola, mediante un archivo de acceso directo :

Código Delphi [-]
unit Directo;

interface

type
  TStr10     = string[10];
  TDataClass = class
  private
    FData    : array[0..5] of TStr10;
    FFileName: string;
    function  GetDatos(Index: Integer): TStr10;
    procedure SetDatos(Index: Integer; const Value: TStr10);
    function  GetSize: Integer;
  public
    property  FileName: string read FFileName write FFileName;
    property  Data[Index: Integer]: TStr10 read GetDatos write SetDatos; default;
    procedure Open;
    property  Size: Integer read GetSize;
    procedure ReadData(const Posic: Integer);
    procedure SaveData(const Posic: Integer);
    procedure AppendData;
    procedure Close;
    //...
  end;

implementation

uses SysUtils;

type
  TRegData = packed record
    VData: array[0..5] of TStr10;
  end;
  TFileReg = file of TRegData;

var
  RegData : TRegData;
  FileReg: TFileReg;

procedure TDataClass.Open;
begin
  if FFileName = EmptyStr then
    raise Exception.Create('Falta el nombre de archivo');
  AssignFile(FileReg, FFileName);
  try
    Reset(FileReg);
  except
    Rewrite(FileReg);
  end;
end;

function TDataClass.GetDatos(Index: Integer): TStr10;
begin
  Result:= FData[Index];
end;

procedure TDataClass.SetDatos(Index: Integer; const Value: TStr10);
begin
  FData[Index]:= Value;
end;

function TDataClass.GetSize: Integer;
begin
  Result:= FileSize(FileReg);
end;

procedure TDataClass.ReadData(const Posic: Integer);
begin
  if Posic >= Size then
    raise Exception.Create('Índice fuera de rango');
  Seek(FileReg, Posic);
  Read(FileReg, RegData);
  Move(RegData.VData, FData, SizeOf(FData));
end;

procedure TDataClass.SaveData(const Posic: Integer);
begin
  if Posic >= Size then
    raise Exception.Create('Índice fuera de rango');
  Move(FData, RegData.VData, SizeOf(RegData.VData));
  Seek(FileReg, Posic);
  Write(FileReg, RegData);
end;

procedure TDataClass.AppendData;
begin
  Move(FData, RegData.VData, SizeOf(RegData.VData));
  Seek(FileReg, FileSize(FileReg));
  Write(FileReg, RegData);
end;

procedure TDataClass.Close;
begin
  CloseFile(FileReg);
end;
//...
end.

Pero en términos de simpleza, fiabilidad y escalabilidad pienso que almacenar esos valores de monitorización como campos de una tabla de una base de datos tampoco es mala idea.

Saludos