How to create a dynamic array of single as a property in a class

Question

I'm currently creating a class to write and read arrays Opening a file, closing a file all works well. Also, I'm able to write an array towards a bin file. But returning an array from the class is a bridge to far.
So far, ther're 2 issues where I'm not able to work around

1) in the public section function ReadArrFromFile : array of single; ==> identifier expected but array found & incompatible types single and dynamic array

2) In the implementation with function Tbinfiles.ReadArrFromFile : array of single, ==> I always get E2029 Identifier expected but ARRAY found

For 1), if I define array of single in the main program it's not causing any problem 2) same for the ReadArrFromFile works fine on the main program

I'm working with codegear RAD delphi 2007 & windows vista.

 unit UbinFiles;

interface

type
    TBinFiles = Class
      private
        pFileName        : String;          //  File name (FILENAME.bin)
        pFileType        : string;          //  File type (of .. )
        pFileLoc         : string;          //  FileLocation path
        pMyarr           : array of single; //  array to receive / provide results
        pArrLen          : integer;         //  To define arraylength
        pFKA             : file;            //  File Known As or the internal name
        pRecsWritten     : integer;         //  # of blocks written towards file
        pRecsRead        : integer;         //  # of blocks read from file

      public
        procedure SetFname(const Value: String);
        procedure SetFtype(const Value: String);
        procedure SetFLoc(const Value: String);
        procedure SetArrLen(const Value: integer);

        constructor Create;                                                   overload;
        constructor Create(Fname : String);                                   overload;
        constructor Create(Fname : String ; Ftype : string);                  overload;
        constructor Create(Fname : String ; Ftype : string ; FLoc : String);  overload ;

        procedure OpenMyFile;
        procedure CloseMyFile;
        procedure Write2MyFile(Myarr : array of single );
        procedure ReadFromMyFile;
        function CheckBackSpace(MyPath : string) : string ;
        procedure TSTreadAnArray(Myarr : array of single);
//---first problem 
        function ReadArrFromFile : array of single;

      published

        property Fname : String read pFileName write SetFname;
        property Ftype : String read pFileType write SetFtype;
        property FLoc : String read pFileLoc write SetFLoc;
        property ArrLen : integer read pArrLen write SetArrLen;

end;

implementation

uses
    Dialogs, SysUtils, StrUtils;   // controls required for this class
//
//---Constructors-----------------------------
//
constructor TBinFiles.Create;               // void constructor
 begin
   inherited;
    self.pFileName       := 'MyBinary';
    self.pFileType       := '';
    self.pFileLoc        := 'C:\Users\';
    self.pRecsWritten    := 0;
    self.pRecsRead       := 0;
 end;

 constructor TBinFiles.Create(Fname: String); // contructor + Fname
 begin
    self.pFileName       := Fname;
    self.pFileType       := '';
    self.pFileLoc        := 'C:\Users\';
    self.pRecsWritten    := 0;
    self.pRecsRead       := 0;
 end;

 constructor TBinFiles.Create(Fname: String ; Ftype : string); // constructor etc..
 begin
    self.pFileName       := Fname;
    self.pFileType       := Ftype;
    self.pFileLoc        := 'C:\Users\';
    self.pRecsWritten    := 0;
    self.pRecsRead       := 0;
 end;

 constructor TBinFiles.Create(Fname: String ; Ftype : string ; FLoc : string);
 begin
    self.pFileName       := Fname;
    self.pFileType       := Ftype;
    self.pFileLoc        := CheckBackSpace(FLoc);
    self.pRecsWritten    := 0;
    self.pRecsRead       := 0;
 end;
//
//----setters---------------------------------------
//
procedure TBinFiles.SetFname(const Value: String);  // pFileName
 begin
   pFileName         := Value;
 end;

 procedure TBinFiles.SetFtype(const Value: String); // pFileType
 begin
   pFileType         := Value;
 end;

 procedure TBinFiles.SetFLoc(const Value: String);  // pFileLoc
 begin
   pFileLoc         := Value;
 end;

 procedure TBinFiles.SetArrLen(const Value: integer);
 begin
   pArrLen         := Value;
 end;


 //
 //---general functions / procs----
 //
procedure Tbinfiles.OpenMyFile;
begin
  try
    AssignFile(self.pFKA, self.pFileLoc + self.pFileName +'.bin');
    ReWrite(self.pFKA);
  except
    on E : Exception do
      begin
        ShowMessage(E.ClassName+' error raised, with message : '+E.Message);
      end;
  End;
end;

procedure Tbinfiles.CloseMyFile;
begin
    CloseFile(self.pFKA);
End;

procedure Tbinfiles.Write2MyFile(Myarr : array of single );
begin
    BlockWrite(self.pFKA, Myarr, 1,self.pRecsWritten);
End;

procedure Tbinfiles.ReadFromMyFile;
begin
    BlockRead(self.pFKA, self.pMyarr, 1,self.pRecsread);
End;

//------second problem----------------------------------------------<<<<<< doesn't work 

function Tbinfiles.ReadArrFromFile : array of single  ;
begin
    BlockRead(self.pFKA, self.pMyarr, 1,self.pRecsread);
End;

function Tbinfiles.CheckBackSpace(MyPath : string) : string ;
begin
  if AnsiRightStr(MyPath, 1) = '\'
  then Result := MyPath
  else Result := MyPath + '\'
  ;
end;

procedure Tbinfiles.TSTreadAnArray(Myarr : array of single );
var i:integer;
begin
  for i := 0 to high(Myarr) do
    begin
      showmessage('Element ' + intToStr(i)+ floatToStr(MyArr[i]) );
    end;
end;

end.

Answer 1

You can't have an array as a property, but you can have array properties:

TMyObject = class
private
    function GetSingleArray(aIndex: Integer): Single;
    procedure SetSingleArray(aIndex: Integer; const Value: Single);
    function GetSingleArrayCount: Integer;
    procedure SetSingleArrayCount(const Value: Integer);
  public
    property SingleArray[aIndex: Integer]: Single read GetSingleArray write SetSingleArray;
    //returns or sets the length of the single array
    property SingleArrayCount: Integer read GetSingleArrayCount write SetSingleArrayCount;
end;

Answer 2

You can use a named type - try TSingleDynArray from unit Types. However using array properties (see The_Fox's answer) might be more appropriate.

Answer 3

1)At first declare array type..

type
  TpMyarr = array of single;

...and than yo can do:

function ReadArrFromFile : TpMyarr;

2)Before writing in dinamic array call SetLength first.

3)There is no need to use 'self.' in your program!

4)Instead BlockRead/BlockWrite use TFileStream delphi class.