As with all VCL objects, you will need to create it before you use it. The TFileStream Create method will open a file on a drive, and it has two parameters.

TFileStream.Create(const FileName: string; Mode: Word);

procedure TFileStream.WriteBuffer(const Buffer; Count: Integer);

procedure TFileStream.ReadBuffer(var Buffer; Count: Integer);

    Tech Note - The TFileStream source code uses the standard API File access functions of CreateFile( ), ReadFile( ), WriteFile( ), and CloseHandle( ). So the TFileStream file access methods are like the API functions.

You may want to read the Delphi Help for the TFileStream.Create and the TFileStream.WriteBuffer procedures. The following code is an example for writing four integers to a file, in a procedure. This will create a file named "G:\Test1.file'" and overwrite that file if it already exists without warning. When naming this file, I have used a File extention of ".file" which is an uncommon file extention (compared to-  .txt  .doc  .bmp  .wav  .pas) but you can name your files anyway that is useful for you, with any file extention or no file extention. Be careful if you use a commom file extention - -

procedure WriteToFile; var FileStream1: TFileStream; Int1, Int2, Int3, Int4: Integer; begin Int1 := 100; Int2 := 200; Int3 := 1918986307; Int4 := 1702521171; FileStream1 := TFileStream.Create('G:\Test1.file', fmCreate or fmOpenWrite or fmShareDenyWrite); try FileStream1.WriteBuffer(Int1, SizeOf(Int1)); FileStream1.WriteBuffer(Int2, SizeOf(Int2)); FileStream1.WriteBuffer(Int3, SizeOf(Int3)); FileStream1.WriteBuffer(Int4, SizeOf(Int4)); finally FileStream1.Free;; end; end;

The FileStream1 is created with the fmCreate or fmOpenWrite open Mode and the fmShareDenyWrite share Mode. This means that a New File is created with write access, and no other program can write to this file while it is open. All of our integer variables are given values in the begining of the procedure, an after we create the FileStream1 we can write to this file. The first FileStream1 write buffer is for the variable Int1, an Integer, notice that we use the SizeOf( ) function in the Count parameter. (Do you know the number of bytes this SizeOf function will return for an Integer?) This will write 4 bytes to the file with the bits set in these 4 bytes for the integer value of 100. But these 4 bytes are all that is saved to the file, there is NO information saved to the file about what this data was (an Integer in this case). Next the second Integer Int2 is written to the file. But where are the 4 bytes for this integer written, at the beginning of the File, over top of the Int1 bytes? No, after each write the FileStream position is Advanced to where the last write ended, so the Int2 is added on the end of the file, which would be byte number 5, Also, when you use the FileStream write the file size is automatically increased to the size needed for that write. So we can just use the WriteBuffer method and put as many fixed size variables in the file as we want to. Two more Integers Int3 and Int4 are added to the file, the values for these integers (1702521171, 1918986307) will be explained later.

the TFileStream.Position - Is a zero based integer value that has the current offset of bytes from the begining of the FileStream. Any operation for reading and writing the FileStream will use the file byte begining at the current FileStream Position. The TFileStream access methods, (Write, WriteBuffer, Read, ReadBuffer, LoadFromStream, SaveToStream, CopyFrom) all start their file operation at the Current FileStream Position and automatically advance the FileStream Position to where that method ends it's operation. You can set the FileStream Position to any location of the file, you can also set the position Past (greater than) the current end of the file, if the FileStream is created with the fmOpenWrite Mode, then the file's Size will be increased to the new FileStream Position past the end of the file. If the FileStream is created with the fmOpenRead mode, then the Position can NOT go higher than the Size of the FileStream.

  IMPORTANT - You must FREE the FileStream to release the file from the system's file handleing. To use operating system resources efficiently, a program should Free a TFileStream as soon as you are finished with it, I usually use a try and finally block to make sure the FileStream is Free.

So now we have made a Muti Data file with 4 integers in it at file path 'G:\Test1.file' . . . Now we need to Read these 4 integers out of the file. Remember, that since we wrote the file, we know what the data Types are, and where the data segments are located (their file Byte position). Here is some code to read the four integers out of the file. - -

procedure ReadFromFile; var FileStream1: TFileStream; Int1, Int2, Int3, Int4: Integer; Str1: String; begin FileStream1 := TFileStream.Create('G:\Test1.file', fmOpenRead or fmShareDenyWrite); try FileStream1.ReadBuffer(Int1, SizeOf(Int1)); FileStream1.ReadBuffer(Int2, SizeOf(Int2)); FileStream1.ReadBuffer(Int3, SizeOf(Int3)); FileStream1.ReadBuffer(Int4, SizeOf(Int4)); finally FileStream1.Free;; end; Str1 := 'Int1-'+IntToStr(Int1)+' Int2-'+IntToStr(Int2)+' Int3=' +IntToStr(Int3)+' Int4'+IntToStr(Int4); end;

This time the FileStream1 is Created with the fmOpenRead mode so we can read from the file. Remember, that there is NO information in this file about what the bytes in this file are for, or the order or type of Data in this file, so you will need to know what Data is in the file to get data out of this file. Since we wrote this file we know the data in it and it's arrangement, so we just read the Data out of the file in the exact same sequence that we put the data into it. After the file is opened, we just read the file one Integer at a time like we did when we wrote the file. Remember, the ReadBuffer procedure will automatically advance the FileStream Position to the end of the read operation or the end of the file, whichever comes first. It can NOT advance the Position past the end of the file. So after the second integer (Int2) is read, the FileStream Position is 8, after the third integer is read the file Position is 12. I have added a String, Str1, which is used to put the Integer values into text, so you can display this string in a TLabel.Caption or ShowMessage( ) to confirm that it has gotten the correct integer values.

the Bytes in a File do NOT have a Type - As I have said, there is no information about the bytes (data) in the file unless you put this information in the file, and know how to get this information out of the file and use it. I did not put any information into the file about the data of this file, I will deal with that later. The next code examples are meant to show you that the bytes of a file can be read out of the file and used in ANY WAY, without any reguard to what the bytes were used as (their data Type) when the bytes were written to file. The file Size of the "G:\Test1.file" will be 16 bytes (4 bytes for each integer). An Integer is a common variable in Delphi, a TPoint has two integers in it's Record type. So 4 Integers would be the amount of Integers in 2 TPoints. So we can read these 16 file bytes into 2 TPoints, as in the following example - -

procedure ReadFromFile; var FileStream1: TFileStream; Pnt1, Pnt2: TPoint; Str1: String; begin FileStream1 := TFileStream.Create('G:\Test1.file', fmOpenRead or fmShareDenyWrite); try FileStream1.ReadBuffer(Pnt1, SizeOf(Pnt1)); FileStream1.ReadBuffer(Pnt2, SizeOf(Pnt2)); finally FileStream1.Free;; end; Str1 := 'Pnt1.x-'+IntToStr(Pnt1.x)+' Pnt1.y-'+IntToStr(Pnt1.y)+ ' Pnt2.x='+IntToStr(Pnt2.x)+' Pnt2.y'+IntToStr(Pnt2.y); end;

This works because the TPoint has 2 integers in it. The integer Values for the Pnt1, Pnt2, x and y values will be the same as the Integer values we got before in the Int1, Int2, Int3, Int4 integers. What about a TRect. . . it has 4 integers in it. . . you could read a TRect from this FileStream1 with -

procedure ReadFromFile; var FileStream1: TFileStream; Rect1: TRect; Str1: String; begin FileStream1 := TFileStream.Create('G:\Test1.file', fmOpenRead or fmShareDenyWrite); try FileStream1.ReadBuffer(Rect1, SizeOf(Rect1)); finally FileStream1.Free;; end; Str1 := 'Rect1.Left-'+IntToStr(Rect1.Left)+ ' Rect1.Top-'+IntToStr(Rect1.Top)+ ' Rect1.Right='+IntToStr(Rect1.Right)+ ' Rect1.Bottom'+IntToStr(Rect1.Bottom); end;

Again we get the same integer values from the file in the Rect1 variable. I am showing you these last two examples, not for a way to read files, but so you will see that the bytes in your file are not restricted in how they are read or used. You should notice that there is NO TYPE-CHECKING by the compiler for the bytes read into the TPoints or the TRect. This is not posible, the program has no information about what is in this file. The ONLY thing that sets how and what is read form this file is YOU, in your code.

Changing File Position with Seek and Position
In the examples above, whenever you wrote or read from the file, the file's position was automatically changed to the location where the write or read ended. You can use the TFileStream.Postion property to get or set where the file is written to or read from. Position gets or sets the Byte location for the file operation to begin with that byte (it is zero based). Position uses the Seek function to change the file position. The function
TFileStream.Seek(Offset: Integer; Origin: Word): Integer;
also resets the current file position, and also has a reference in the Origin parameter for where in the file to apply the Offset parameter. Let's look at a code example that changes the FileStream Position and reads a variable from the new Position. Keep in mind that there are Four Bytes in an Integer variable and that the FileStream Position is zero based -

procedure ReadFromFile; var FileStream1: TFileStream; Int1, Int2, Int3, Int4: Integer; Pnt1: TPoint; begin FileStream1 := TFileStream.Create('G:\Test1.file', fmOpenRead or fmShareDenyWrite); try FileStream1.ReadBuffer(Int1, SizeOf(Int1)); FileStream1.ReadBuffer(Int2, SizeOf(Int2)); FileStream1.ReadBuffer(Int3, SizeOf(Int3)); FileStream1.ReadBuffer(Int4, SizeOf(Int4)); FileStream1.Position := 4; FileStream1.ReadBuffer(Pnt1, SizeOf(Pnt1)); finally FileStream1.Free;; end; ShowMessage(IntToStr(Int2)+' '+ IntToStr(Int3)+' '+ IntToStr(Pnt1.x)+' '+ IntToStr(Pnt1.y)); end;

The 4 integers are read from the file just like we have done before, and then the FileStream1 Position is set to 4 with
FileStream1.Position := 4;
and the Pnt1 (TPoint) variable is read from the file. You will see in the ShowMessage text that the Int2 and Pnt1.x values are the same, and the Int3 and Pnt1.y values are also the same. If you set the FileStream1 Position to 8 and read the Pnt1 variable, the Pnt1.x will equal the Int3 and the Pnt1.y will equal the Int4.
You can also set the FileStream1 Position with the Seek Method. If you use the soFromBeginning in the Origin parameter, then the Seek function is the same as the Position property. So

FileStream1.Seek(4, soFromBeginning);

FileStream1.Position := 4;

FileStream1.Seek(-12, soFromEnd);

Reading Different Data Out of File
I have been using integers and integer Records (TPoint, TRect). So as an example for you about data types in files, not as read methods, in this next code lets use some non-integer variables. There are 4 byte variables, 2 Word variables, 4 Char variables, and an Array of 4 Char, which will be read from the same file used before with 4 integers in it. Also, this time I will try to read data past the end of the file to show you what happens - -

procedure ReadFromFile; var FileStream1: TFileStream; Byte1, Byte2, Byte3, Byte4: Byte; Word1, Word2: Word; Ch1, Ch2, Ch3, Ch4: Char; aryChar1: Array[0..3] of Char; Int1: Integer; begin FileStream1 := TFileStream.Create('G:\Test1.file', fmOpenRead or fmShareDenyWrite); try FileStream1.ReadBuffer(Byte1, SizeOf(Byte1)); FileStream1.ReadBuffer(Byte2, SizeOf(Byte2)); FileStream1.ReadBuffer(Byte3, SizeOf(Byte3)); FileStream1.ReadBuffer(Byte4, SizeOf(Byte4)); FileStream1.ReadBuffer(Word1, SizeOf(Word1)); FileStream1.ReadBuffer(Word2, SizeOf(Word2)); FileStream1.ReadBuffer(Ch1, SizeOf(Ch1)); FileStream1.ReadBuffer(Ch2, SizeOf(Ch2)); FileStream1.ReadBuffer(Ch3, SizeOf(Ch3)); FileStream1.ReadBuffer(Ch4, SizeOf(Ch4)); FileStream1.ReadBuffer(aryChar1, SizeOf(aryChar1)); ShowMessage(IntToStr(FileStream1.Position)); if FileStream1.Read(Int1, SizeOf(Int1)) < SizeOf(Int1) then ShowMessage('Could not Read file past the end'); finally FileStream1.Free;; end; ShowMessage(IntToStr(Byte1)+' '+IntToStr(Byte4)+ ' '+IntToStr(Word1)+' '+IntToStr(Word2)); ShowMessage(Ch1+Ch2+Ch3+Ch4+' '+aryChar1); end;

All of these non-integer variables are also read out of the integer file without warning from the compiler, because a TFileStream can NOT type check any variable that is read from a file, and the Buffer parameter is an UnTyped variable, so YOUR CODE is the only thing that determines what the bytes read from a file are used for. The Byte and Word variables will read the bytes out of a Part of the integer values in the file, the Char variables will read one byte of the integer value and translate that into a the Char Letter for that byte value, after reading the file, the four Char variables should be set to 'C', 'h', 'a', 'r', which is why the Int3 value was 1918986307 when we wrote the file. The aryChar1 variable is read from the file using the same method as a Char or integer variable, because it is a Fixed Length Array, and the Charaters read from this integer file in the aryChar1 should be 'Size' because the Int4 was written as 1702521171. If a String or Dynamic Array (variable length) is used, then a different method is used to write and read variables with data that is NOT a fixed memory size, like dynamic Arrays, Strings, PChar, and Bitmaps. I will show these methods later in the Using Non-Fixed Size Variables in Files.

Reading past the End of File
In this example above I changed the last file read method to Read( ), when the TFileStream tries to use the Read( ) method past the end of the file, it does NOT throw an exception, as ReadBuffer( ) would, the TfileStream.Read( ) is a function with a Result of the number of bytes acually read from the file, so the test -

if FileStream1.Read(Int1, SizeOf(Int1)) < SizeOf(Int1) then

if FileStream1.Read(Int1, SizeOf(Int1)) < SizeOf(Int1) then
    ShowMessage('Could not Read file past the end');

FileStream1.ReadBuffer(Int1, SizeOf(Int1));

USE   ReadBuffer( ) and WriteBuffer( )For most of the code that Delphi programmers write, the - ReadBuffer( ) WriteBuffer( ) procedures are better for them to use. These procedures offer a method of protection for file access errors, like reading past the end of the file. Although you can produce code using the functions Read( ) and Write( ) , and you can test your code and it will work for you, but if your code is used on an incorrect file later outside of testing, then it may try and read past the end of a file and not do anything for that error. The exceptions that the ReadBuffer( ) and WriteBuffer( ) procedures create are like so many other Delphi exception methods, that you should use the ReadBuffer( ) and WriteBuffer( ) procedures, unless you have a special reason to test and catch the file access errors yourself. If you do use the Read( ) or Write( ) functions, be sure to have your own tests for file access errors.

Do the Math
All files are a collection of bytes, and all files use mathematic methods (add, subtract, multiply) to know how to write and read what is in the file. If you are storing several different data segments in one file you must account for the position in the file bytes where the data segment for each piece of different data is located, and the size of the byte block for that data. In my code examples so far, the WriteBuffer( ) and ReadBuffer( ) procedures automatically move the file position the amount of the file write or read. So in your code you do not have to set the file position, or do any math operations for position or size of data segments. In the code examples below there are some methods shown to create some muti-data files, but if you are making your own muti-data files, and your file data blocks becomes more complex, you must "Do the Math" for your data arangement. You have to know, and plan, and count, and calculate, the variables or data you need to store in your file, and be able to place any information in your file that is required to read it out of the file. Although for many files you will not need to to do math calculations for data arrangement

How to test
What I always do, is to start with just a few of the most important Data variables, and create the file and write the data in it. Then I have a file reader procedure, which I will read those data blocks out, and I always test what has been read to see if the is data correct. If there are access errors or the data is not correct, you can place a ShowMessage( ) to find where the error is, Place a -
    ShowMessage( 'Int1 '+IntToStr(Int1) )
at different places just after a read out of a data block, to see where the error happens, and try different code to correct the error. At first you may know what to do if there is an error in file write or read. Often you may forget to place a data length segment, or you will have an incorrect value of the "Data Size" written or read on file. . . . . If these data reads are all correct, then I add a few more variables and write them all to file, and then read and test the added ones. I keep adding new variables and testing until I have all of the information I need in the file.

One thing you must do is to have the correct amount of bytes to write or read for the "Count" parameter. For many variable types (with unchanging data length) you can use the SizeOf( ) function. But if you are getting errors in your file reads, then most likely you have some data length or data position error in your code.

Fixed Size Variable Example
Next is an example for how to Write and Read several fixed size variables in a file, which is for methods you may really use. This uses a variable (FixStr1) with the String[15] Type, this is a Fixed Length String and can be used like an Integer for reading and writing. There is a TMyRec Record defined, this is made up of Fixed Size variables and can be used like the other fixed size variables for file read and write.

Writing the file. . Please Notice that in all of the Write functions, the Count parameter is always set to the SizeOf(Var) for the variable that is being written. You can only use the SizeOf  for Fixed Size variables, it will NOT work correctly for Non-Fixed size variables like a Long String or TBitmap.

procedure WriteToFile; type TMyRec = Record aInt: Integer; aRect: TRect; asStr28: String[28]; end; var FileStream1: TFileStream; Char1: Char; Int1: Integer; Pnt1: TPoint; Rect1: TRect; aryChar1: Array[0..9] of Char; FixStr1: String[15]; MyRec1: TMyRec; begin Char1 := 'C'; Int1 := 100; Pnt1.x := 500; Pnt1.y := -20; Rect1 := Rect(100,200,300,400); aryChar1 := 'Char Array'; FixStr1 := 'Fixed String'; MyRec1.aInt := 44; MyRec1.aRect := Rect(1,2,3,4); MyRec1.asStr28 := 'Some Text'; FileStream1 := TFileStream.Create('G:\Test two.data', fmCreate or fmOpenWrite or fmShareDenyWrite); try FileStream1.WriteBuffer(Char1, SizeOf(Char1)); FileStream1.WriteBuffer(Int1, SizeOf(Int1)); FileStream1.WriteBuffer(Pnt1, SizeOf(Pnt1)); FileStream1.WriteBuffer(Rect1, SizeOf(Rect1)); FileStream1.WriteBuffer(aryChar1, SizeOf(aryChar1)); FileStream1.WriteBuffer(FixStr1, SizeOf(FixStr1)); FileStream1.WriteBuffer(MyRec1, SizeOf(MyRec1)); finally FileStream1.Free;; end; end;

Reading from this file uses the same method for every variable read, as you can see in the following code. Please Notice that the variables are read in the same exact order that they were written to the file. . Also on the Last Variable Read (MyRec1) there is a Test to see if the Bytes Read are less than the SizeOf(MyRec1), if the Error message is shown, then you know that you have not correctly written, or read the file.

procedure ReadFromFile; type TMyRec = Record aInt: Integer; aRect: TRect; asStr28: String[28]; end; var FileStream1: TFileStream; Char1: Char; Int1: Integer; Pnt1: TPoint; Rect1: TRect; aryChar1: Array[0..9] of Char; FixStr1: String[15]; MyRec1: TMyRec; begin FileStream1 := TFileStream.Create('G:\Test two.data', fmOpenRead or fmShareDenyWrite); try FileStream1.Read(Char1, SizeOf(Char1)); FileStream1.Read(Int1, SizeOf(Int1)); FileStream1.Read(Pnt1, SizeOf(Pnt1)); FileStream1.Read(Rect1, SizeOf(Rect1)); FileStream1.Read(aryChar1, SizeOf(aryChar1)); FileStream1.Read(FixStr1, SizeOf(FixStr1)); if FileStream1.Read(MyRec1, SizeOf(MyRec1)) < SizeOf(MyRec1) then ShowMessage('ERROR - - Could not Read data from file'); finally FileStream1.Free;; end; ShowMessage(IntToStr(Int1)+' '+ IntToStr(Pnt1.x)+' '+ IntToStr(Rect1.Left)+' '+ IntToStr(MyRec1.aInt)); ShowMessage(aryChar1+' '+FixStr1+' '+MyRec1.asStr28); end;

You could subtitute the ReadBuffer procedure for all of the Read functions in the code above, and if there were any file read errors you would get an Exception, and the Try and Finally block would close the file and Free the FileStream1.

Saving Arrays of Records to File
You can have Arrays of records, using records containg Fixed Size Variables and write these arrays to File. You can NOT use the same methods for the Static and Dymanic Arrays availible in Delphi Pascal. With the dynamic array, the SizeOf(DynamicArray) will NOT give you the corret size. For the next examples I will use a TDemo Record defined as -

type
  TOfDemo = (odOpen, odRead, odWrite, odFind, odClose);

  TDemo = record
    aByte: Byte;
    aInt: Integer;
    FixStr1: String[16];
    aOfDemo: TOfDemo;
    aReal: Real;
    aRect: TRect;
    WriteTime: TFileTime;
    aSet: Set of TOfDemo;
    end;

Code for procedure to write array of TDemo records -

procedure SaveAryFile; var aryDemo: Array[0..5] of TDemo; FStm: TFileStream; i: Integer; begin ShowMessage(IntToStr(SizeOf(aryDemo))); aryDemo[0].FixStr1 := 'First String'; aryDemo[0].aOfDemo := odRead; aryDemo[0].aSet := [odWrite, odClose]; aryDemo[5].FixStr1 := 'Last String'; aryDemo[5].aOfDemo := odClose; aryDemo[5].aSet := [odRead, odFind]; FStm := TFileStream.Create('G:\the Demo.aryDemo', fmCreate or fmOpenWrite or fmShareDenyWrite); try i := High(aryDemo); FStm.WriteBuffer(i, SizeOf(i)); for i := 0 to High(aryDemo) do FStm.WriteBuffer(aryDemo[i], SizeOf(TDemo)); finally FStm.Free; end; end;

I have a six member array   Array[0..5] of TDemo; , which I will write to a file. I place some data in the first and last TDemo records just for this demo to read out later. Since I am writting this file, I will know that this array has 6 members (6 TDemo records) in it, but I will place the High Index of this array as the first data segment of the file. That way I can read this value (data) out of the file and test to see if it is the correct amount of array members needed to read into the array of TDemo. And then I have a FOR Loop to run through the array and write all of it's TDemo records to file using the TFileStream WriteBuffer method with the SizeOf(TDemo) as the Count parameter.

Code to read this array file -

procedure LoadRecAry; var aryDemo: Array[0..5] of TDemo; FStm: TFileStream; i: Integer; begin FStm := TFileStream.Create('G:\the Demo.aryDemo', fmOpenRead or fmShareDenyWrite); try FStm.ReadBuffer(i, SizeOf(i)); if i <> High(aryDemo) then begin ShowMessage('ERROR - File does NOT have correct array amount'); Exit; end; FStm.ReadBuffer(aryDemo[0], SizeOf(aryDemo)); finally FStm.Free; end; if aryDemo[0].aSet = [odWrite, odClose] then ShowMessage(aryDemo[5].FixStr1); * end;

Here I create the TFileStream and read one integer from the file, I test this integer to see if it is the same as the High Index of the array I want to load into. If it is, then I then Read the TFileStream for the array data. But PLEASE NOTICE, I use a different method to read this array, I do NOT have a FOR Loop that will read each TDemo record, , instead I read the entire array from the file at one time. With the line -
    FStm.ReadBuffer(aryDemo[0], SizeOf(aryDemo));
I do not need to FOR Loop an array from file, if it only contains Fixed size variables. I could have used the FOR Loop code -
    for i := 0 to High(aryDemo) do
          FStm.ReadBuffer(aryDemo[i], SizeOf(TDemo));
And I would have gotten the correct data out. . .

Also, I could have used different code to write the array to the file -
    FStm.WriteBuffer(aryDemo[0], SizeOf(aryDemo));
And would also have written the file susccesfully. I hope you can see that even though the variable aryDemo is defined as an array, it is just one continuous block of memory, the size of 6 TDemo records. So you can write or read this array from file in one operation. But if you have any changing size variables (String, PChar) in your record type, you can NOT write or read the array in one operation. . . . .

With Dymanic Arrays you can NOT use the SizeOf( ) function, instead you will need to calulate the "Size" of the memory block with math, you can multiply the Length of the array by the Size of the Record, like this -
    FStm.WriteBuffer(aryDemo[0], Length(aryDemo) * SizeOf(TDemo);

You should know enough now about TFileStream to experiment and try writting and reading your own files with several different fixed size variables in them. You should try making your own file write and read procedures and change the types of Fixed-Size variables and their order. Create your own Record type with Fixed-Size variables and write and read it in a file. Remember to use the same exact sequence of reading the variables as you used to write the file.

  File Extentions -
I will be using several different File Extentions in the code examples below, these file extentions DO NOT affect the way a file is read or used in code, they are a method to have some way to detect what data type the file may have in it. You should use a file extention that gives a "Hint" as to what the file data contains, , , like .BMP is used for a Bitmap file or .EXE is used for an Executable file. If your file will only be used by your programs, then I would use a file extention with more than 3 charaters, maybe 5 charaters, like - .aryIn - or - .input - so it may be something that is not used by other programs for their types of files. You should be familar with some of the commom file extentions, such as -
.TXT .DOC .BMP .WAV .EXE .SYS .ICO .JPG .HTM .MP3 .INI .INF .LOG
You should try and avoid using common file extentions like these on your custom file. I have seen many file writting instructions use the .DAT file extention, you may want to use this extention if you are not sure about file extentions and their use. . . HOWEVER, you should NOT use the .DAT extention if you use it as the registered file extention for your programs special file (double Click on your file to open your program).
Also many the common file extentions are just 3 characters (Left over from the old DOS days), but ALL 32 bit windows systems can have file extention of more than 3 characters, so you should really consider using 4 or 5 character extentions for your special files.

Using Non-Fixed Size Variables (like String) in Files

We have seen that you can use a Fixed Size variable with a TFileStream by setting the "Count" parameter to "SizeOf(Var)", but if you use this method with a Non-Fixed Size Variable, like a standard Delphi Long String, it will NOT work. If you create a FileStream1 and have the variable MyString as a String, then put this line in your code -

FileStream1.Write(MyString, SizeOf(MyString));

FileStream1.Write(MyString, SizeOf(MyString));

procedure WriteToFile2;
var
MyString: String;
FileStream1: TFileStream;
begin
MyString := 'this is a string with several words '+
            'in it to be in a file';
FileStream1 := TFileStream.Create('G:\MyString.string',
                 fmCreate or fmOpenWrite or fmShareDenyWrite);
try
  FileStream1.WriteBuffer(MyString[1], Length(MyString));
  finally
  FileStream1.Free;
  end;
end;

procedure ReadFromFile2;
  var
  FileStream1: TFileStream;
  MyString: String;
begin
FileStream1 := TFileStream.Create('G:\MyString.string',
                 fmOpenRead or fmShareDenyWrite);
try
  if FileStream1.Size = 0 then Exit;
  SetLength(MyString, FileStream1.Size);
  FileStream1.ReadBuffer(MyString[1], FileStream1.Size);
  finally
  FileStream1.Free;;
  end;
ShowMessage(MyString);
end;

procedure WriteToFile2;
var
MyString: String;
FileStream1: TFileStream;
begin
MyString := 'this is a string with several words '+
            'in it to be in a file';

if @Mystring[1] = PChar(MyString) then
  Showmessage('Is the Same Memory Address');

FileStream1 := TFileStream.Create('G:\MyString.string',
                 fmCreate or fmOpenWrite or fmShareDenyWrite);
try
  FileStream1.WriteBuffer(PChar(MyString)^, Length(MyString));
  finally
  FileStream1.Free;
  end;
end;

if @Mystring[1] = PChar(MyString) then
  Showmessage('Is the Same Memory Address');

procedure WriteToFile2;
var
FileStream1: TFileStream;
StrOne, StrTwo, StrThree: String;
Len1: Cardinal;
begin
StrOne := 'First string in this file';
StrTwo := 'the Second file string';
StrThree := 'String number three of this file';

FileStream1 := TFileStream.Create('E:\Strings.msf',
                 fmCreate or fmOpenWrite or fmShareDenyWrite);
try
  Len1 := Length(StrOne);
  FileStream1.WriteBuffer(Len1, SizeOf(Len1));
  FileStream1.WriteBuffer(StrOne[1], Len1);

  Len1 := Length(StrTwo);
  FileStream1.WriteBuffer(Len1, SizeOf(Len1));
  FileStream1.WriteBuffer(StrTwo[1], Len1);

  Len1 := Length(StrThree);
  FileStream1.WriteBuffer(Len1, SizeOf(Len1));
  FileStream1.WriteBuffer(StrThree[1], Len1);
  finally
  FileStream1.Free;
  end;
end;

procedure ReadFromFile2;
var
  FileStream1: TFileStream;
  StrOne, StrTwo, StrThree: String;
  Len1: Cardinal;

begin
FileStream1 := TFileStream.Create('E:\Strings.msf',
                 fmOpenRead or fmShareDenyWrite);
try
  FileStream1.ReadBuffer(Len1, SizeOf(Len1));
  if Len1 > 2048 then Exit;
  SetLength(StrOne, Len1);
  FileStream1.ReadBuffer(StrOne[1], Len1);

  FileStream1.ReadBuffer(Len1, SizeOf(Len1));
  if Len1 > 2048 then Exit;
  SetLength(StrTwo, Len1);
  FileStream1.ReadBuffer(StrTwo[1], Len1);

  FileStream1.ReadBuffer(Len1, SizeOf(Len1));
  if Len1 > 2048 then Exit;
  SetLength(StrThree, Len1);
  FileStream1.ReadBuffer(StrThree[1], Len1);

  finally
  FileStream1.Free;;
  end;
ShowMessage(StrOne);
ShowMessage(StrTwo);
ShowMessage(StrThree);
end;

if Len1 > 2048 then Exit;

procedure WriteToFile2;
var
FileStream1: TFileStream;
arrayString: Array of String;
Len1, c: Cardinal;
begin
SetLength(arrayString, 4);
arrayString[0] := 'First string in this Array';
arrayString[1] := 'the Second Array string';
arrayString[2] := 'String number three of this Array';
arrayString[3] := 'this is the fourth String';

FileStream1 := TFileStream.Create('E:\Array Str1.aryS4',
                 fmCreate or fmOpenWrite or fmShareDenyWrite);

try
  c := Length(arrayString);
  FileStream1.WriteBuffer(c, SizeOf(c));
  FOR c := 0 to High(arrayString) do
    begin
    Len1 := Length(arrayString[c]);
    FileStream1.WriteBuffer(Len1, SizeOf(Len1));
    if Len1 > 0 then
    FileStream1.WriteBuffer(arrayString[c][1], Len1);
    end;
  finally
  FileStream1.Free;
  end;
end;

c := Length(arrayString);
FileStream1.Write(c, SizeOf(c));

procedure ReadFromFile2;
  var
  FileStream1: TFileStream;
  arrayString: Array of String;
  Len1, c: Cardinal;

begin
FileStream1 := TFileStream.Create('E:\Array Str1.aryS4',
                 fmOpenRead or fmShareDenyWrite);
try
  FileStream1.ReadBuffer(Len1, SizeOf(Len1));
  if (Len1 = 0) or (Len1 > 1000) then Exit;
  SetLength(arrayString, Len1);
  FOR c := 0 to Len1-1 do
    begin
    FileStream1.ReadBuffer(Len1, SizeOf(Len1));
    if Len1 > 2048 then Exit;
    SetLength(arrayString[c], Len1);
    FileStream1.ReadBuffer(arrayString[c][1], Len1);
    end;
  finally
  FileStream1.Free;;
  end;
ShowMessage(arrayString[0]);
ShowMessage(arrayString[High(arrayString)]);
end;

The TGraphic Classes like TBitmap and TIcon, need a different method to write and read them to a Multi-Data File than we used with the Strings. Just like the Strings would save the "Length" of the string to file, we will also need to save the "Size" of the TGraphic to the FileStream. There are several classes of TGraphic, including - TBitmap, TMetafile, TIcon, TJPEGImage, , , , All of these Graphic Classes have a "SaveToStream" method, which is what I will use to get the "Size" of the Graphic's Data Segment and write and read it to FileStream. I will be using a TBitmap for these examples, but you can subtitute any TGraphic that has the "SaveToStream" and "LoadFromStream" methods. You can also subtitute any VCL type that has the "SaveToStream" and "LoadFromStream" methods, such as TStrings, TStringList, TBlobField, and TCustomTreeView.

The TBitmap does NOT have a "Length" or "Size" property to get the amount of bytes that would be in that Bitmaps File size. Since we will need to record the Size in bytes for the File's Bitmap Data-Segment, we will need a method to find this "Size" value. It will be nessary to Create a TMemoryStream and then use the TBitmap's "SaveToStream" to write this Bitmap file into the MemoryStream. Once the Bitmap file is in the MemoryStream, we can use the TMemortStream "Size" property to get the number of bytes we will be writing to the FileStream for the Bitmap Data-Segment. And since the Bitmap file is now in the MemoryStream, we can just write this MemoryStream into the TFileStream. This first example will use a Dynamic Array of TBitmap, with 4 Bitmaps in the Array, just like the example above for the Array of Strings, we will record the Length of the Array as the first thing in the FileStream. Next we will use a FOR loop to go through all of the Bitmaps in the array. Unlike the example with strings, I will create a TMemoryStream and use the TBitmap's SaveToStream method to place the Bitmap file in the MemoryStream. Then in the FOR loop I can get the "Size" of the Bitmap's Data Segment from the Size property of the MemoryStream and write it to the FileStream.

procedure WriteToFile2; var FileStream1: TFileStream; MemStream1: TMemoryStream; aryBitmap: Array of TBitmap; Len1, c: Cardinal; begin SetLength(aryBitmap, 4); For c := 0 to High(aryBitmap) do begin {this FOR loop just creates the Bitmaps in the Array} aryBitmap[c] := TBitmap.Create; if c = 0 then aryBitmap[c].Canvas.Brush.Color := clAqua else aryBitmap[c].Canvas.Brush.Color := clYellow; aryBitmap[c].Width := 110+ (C*3); aryBitmap[c].Height := 86+ (C*3); aryBitmap[c].Canvas.TextOut(5,5, 'Bitmap '+IntToStr(c)); end; try FileStream1 := TFileStream.Create('E:\Array Bitmap.abt', fmCreate or fmOpenWrite or fmShareDenyWrite); MemStream1 := TMemoryStream.Create; try Len1 := Length(aryBitmap); FileStream1.WriteBuffer(Len1, SizeOf(Len1)); for c := 0 to High(aryBitmap) do begin aryBitmap[c].SaveToStream(MemStream1); {save aryBitmap[c] to the Memory stream so we can find out the Size of the Bitmap File} Len1 := MemStream1.Size; {it is VERY important to get the size of bitmap bytes in Len1, or you will not be able to get the Bitmap out of the file} FileStream1.WriteBuffer(Len1, SizeOf(Len1)); {remember that the MemStream1 position is now at the END of the Stream and we need to SaveToStream From the Beginning of the MemStream1, so we need to set the Position to zero} MemStream1.Position := 0; MemStream1.SaveToStream(FileStream1); MemStream1.Clear; {IMPORTANT, to must empty the MemStream1 with Clear, or the next SaveToStream will add the bitmap to the ones already there} end; finally FileStream1.Free; MemStream1.Free; end; finally for c := 0 to High(aryBitmap) do aryBitmap[c].Free; {you need to Free all TGraphics that you create} end; end;

You need to look at the way each bitmap is saved to the Memory Stream and then how the MemStream1 is used to get the Size of the Data-Segment. The Len1 is set to the "Size" of the MemStream1 and written to the FileStream1. Now we will use the CopyFrom TStream method to put the Bitmap Data in the FileStream, however, remember that all TStream read and write methods advance the Stream Position to where that operation ended. So after the   aryBitmap[c].SaveToStream(MemStream1);   , , the MemStream1 Position is at the End of the Stream. And if we use the   MemStream1.SaveToStream(FileStream1); , , Nothing will be written to the FileStream1, because the stream Position is at the end of the stream. First we need to set the MemStream1 Position to the begining of that Stream with Position := 0; , , Also we will be using the Same MemStream1 for all of the Bitmaps, so we need to Empty that Stream before we put the next Bitmap in it. I use the TStream "Clear" method to do that.

the next example Reads the Bitmaps out of the file into an Array of TBitmap -

procedure ReadFromFile2; var FileStream1: TFileStream; MemStream1: TMemoryStream; aryBitmap: Array of TBitmap; Len1, c: Cardinal; begin FileStream1 := TFileStream.Create('E:\Array Bitmap.abt', fmOpenRead or fmShareDenyWrite); MemStream1 := TMemoryStream.Create; try FileStream1.ReadBuffer(Len1, SizeOf(Len1)); if (Len1 = 0) or (Len1 > 1024) then Exit; SetLength(aryBitmap, Len1); for c := 0 to Len1-1 do begin aryBitmap[c] := TBitmap.Create; FileStream1.ReadBuffer(Len1, SizeOf(Len1)); MemStream1.CopyFrom(FileStream1, Len1); {copy the MemStream1 from the FileStream1, you need to do this because any TGraphics LoadFromStream will need a stream that ONLY has that graphic in it, remember that the MemStream1 position is now at the END of the Stream, and it needs to be at the begining} MemStream1.Position := 0; aryBitmap[c].LoadFromStream(MemStream1); {If your file read Position was incorrect for the MemStream1.CopyFrom then you will get an Exception here in this TBitmap LoadFromStream for an incompatable graphic type} MemStream1.Clear; end; finally FileStream1.Free; MemStream1.Free; end; Form1.Canvas.Draw(7, 7, aryBitmap[0]); Form1.Canvas.Draw(207, 7, aryBitmap[High(aryBitmap)]); For c := 0 to High(aryBitmap) do aryBitmap[c].Free; end;

You should experiment and create your own Muti-Data TGraphics Files, try and change the TBitmap Array to a TJPEGImage Array and create your Jpegs and save and read them from a file.

You can also "move through" a muti-segment file like the bitmap file above and not read any of the bitmap image data. In all of the file reading above, I have read ALL of the data segments into a variable until it gets to the end of the file. But if you need to get only ONE bitmap from the file above, you can read the bitmap data segment size and then reset the file read position to the next segment size integer. In For Loop code below, the FileStream1 is created for reading and uses the same code in the ReadFromFile2 procedure above, Except in the "For Loop". To read just One Bitmap use this - For Loop - code, like this -

for c := 0 to Len1-1 do
  begin
  FileStream1.ReadBuffer(Len1, SizeOf(Len1));
  if i = 2 then // get the third bitmap
    begin
    // code here reads out only one bitmap
    Bmp1 := TBitmap.Create;
    MemStream1.CopyFrom(FileStream1, Len1);
    MemStream1.Position := 0;
    Bmp1.LoadFromStream(MemStream1);
    Break; // end loop once bitmap is read
    end;
{IMPORTANT, you must advance the file position, from
 it's current place, to the amount of Len1, the
 data segment size}
  FileStream1.Seek(Len1, soFromCurrent);
  end;

File ID - - A Very Important File Addition
Many of these File Headers will begin with a "File Type" identifier and a Version number (if the file type can have more than one version). For instance the Bitmap file .BMP will always have the ASCII characters 'B' and 'M' as the first two bytes in the file, as a File Type identifier (no version info in a Bitmap file, only one version). So when a bitmap file reader starts to read the file it will check and see if the first 2 bytes are 66 (for B) and 77 (for M), and only continue to read the file if these 2 bytes are correct. I ALWAYS place a file identifier as the first thing in any custom Multi-Data file that I create. Your File ID should be at least 2 bytes, I ususlly use an Integer (4 bytes) as a File identifier and version number. I will write this ID number as the first thing in the file, and then when I begin reading this file, I check this ID number, and if it does Not match, I will Not load the file. You must consider that there may be files with the same file extention as the file type you want to read. And these other files will NOT have the data in them you will try and read, so you need a File ID for safety. The code might look like this -

var
FileStream1 : TFileStream;
ID_ver: Integer;

begin
ID_ver := 73485201;
FileStream1 := TFileStream.Create(FileName, fmCreate or 
                  fmOpenWrite or fmShareDenyWrite);
try
  FileStream1.WriteBuffer(ID_ver, SizeOf(ID_ver));

var
FileStream1 : TFileStream;
ID_ver: Integer;

begin
ID_ver := 0;
FileStream1 := TFileStream.Create(FileName,fmOpenRead or 
                                  fmShareDenyWrite);
try
FileStream1.ReadBuffer(ID_ver, SizeOf(ID_ver));
if ID_ver <> 73485201 then
  begin
  ShowMessage('ERROR - This is NOT a valid file for this'+
               ' version, and will NOT be loaded');
  Exit;
  end;

var
FileStream1 : TFileStream;
cID_ver: Array[0..4] of Char;

begin
cID_ver := 'FILE1';
FileStream1 := TFileStream.Create(FileName, fmCreate or 
                  fmOpenWrite or fmShareDenyWrite);
try
  FileStream1.WriteBuffer(cID_ver, SizeOf(cID_ver));

Access a Single Data Segment
I will now create a multi-Bitmap File that has the Data Segment Positions as part of the File Header, allowing easier access to individual Data Segments. In the previous examples all of the file reads were done by reading the entire file, and loading all of the Data Segments at the same time. If we place the Data Segment's file Positions in the File Header we can read just One Data Segment out of the file (a Bitmap in this case). I will make a Record that has some information about the Bitmap (width and height) And has it's file position and data size in it, and place one Record for each Bitmap in the file header. The record will have 4 elements, all of fixed-size variables (fixed-size makes it easier) -

TBmp_Rec = Record
   FilePos, bmp_Size: Cardinal;
   width, height: Integer;
   Description: String[15];
   end;

FileStream1.Position := SizeOf(ID_ver)+SizeOf(Len1)+
           (c * SizeOf(Bmp_Rec1));

FileStream1.Position := 8 + (c * SizeOf(Bmp_Rec1));

procedure WriteToFile3;
type
 TBmp_Rec = Record
   FilePos, bmp_Size: Cardinal;
   width, height: Integer;
   Description: String[15];
{this record will be written as part of the File Header
only the FilePos and bmpSize are required for file write
and read, the width and height are just extra Bmp info
and the Description is for the ListBox}
   end;

var
FileStream1 : TFileStream;
BmpStream: TMemoryStream;
ID_ver: Integer;
Bmp_Rec1: TBMP_rec;
aryBitmap: Array of TBitmap;
Len1, c, FilePos: Cardinal;
FileName: String;
begin
ID_ver := 5211801;
FileName := 'E:\Bmp Rec1.brf';
SetLength(aryBitmap, 5);
FOR c := 0 to High(aryBitmap) do
  begin
{this FOR loop just creates the Bitmaps.
Normally you would have the user load his own bitmaps from file}
  aryBitmap[c] := TBitmap.Create;
  aryBitmap[c].PixelFormat := pf8Bit;
  if c = 0 then
  aryBitmap[c].Canvas.Brush.Color := clAqua
  else
  aryBitmap[c].Canvas.Brush.Color := clYellow;
  aryBitmap[c].Width := 110+ (C*3);
  aryBitmap[c].Height := 86+ (C*3);
  aryBitmap[c].Canvas.TextOut(5,5, 'Bitmap '+IntToStr(c+1));
  end;


try
  FileStream1 := TFileStream.Create(FileName,
                 fmCreate or fmOpenWrite or fmShareDenyWrite);
  BmpStream := TMemoryStream.Create;
  try
    FileStream1.WriteBuffer(ID_ver, SizeOf(ID_ver));
{IMPORTANT, you should write the file ID as the
first thing in the File}

    Len1 := Length(aryBitmap);
    FileStream1.WriteBuffer(Len1, SizeOf(Len1));
{record the number of Bitmaps in this File which is the
Length(aryBitmap)}

    for c := 0 to High(aryBitmap) do
      begin
{as part of a File Header, I will write ONE TBmp_Rec for
each Bitmap in this file}
      Bmp_Rec1.FilePos := 0;
      Bmp_Rec1.bmp_Size := 0;
{Notice that I set the values of FilePos and bmp_Size
to zero, at this point of the file write, the FilePos
and bmp_Size are not availible, they will be written
later, when we are writing each bitmap and know it's
position and size}
      Bmp_Rec1.width := aryBitmap[c].Width;
      Bmp_Rec1.height := aryBitmap[c].Height;
{the width and height fields are not nessary for file
writting and reading, they are here just to show you
that you can include some extra info in the TBmp_Rec}
      Bmp_Rec1.Description := IntToStr(c+1)+' bitmap';
{the Bmp_Rec1.Description will be placed in a ListBox
when this file is Read}
      FileStream1.WriteBuffer(Bmp_Rec1, SizeOf(Bmp_Rec1));
      end;

{after the above FOR loop, we are finished writting the
File Header, and we will now write the Data Segments}

    for c := 0 to High(aryBitmap) do
      begin
      FilePos := FileStream1.Position;
{IMPORTANT, you must get the current File Position, to write
it to File and to come Back to this Position to write
the Data Segment (Bitmap)}
      FileStream1.Position := SizeOf(ID_ver)+SizeOf(Len1)+
           (c * SizeOf(Bmp_Rec1));
{The file Position is Set above with a Mathamatical formular,
we need to go to the Bmp_Rec1 for the corresponding Bitmap
and set the 2 fields of the Record for the FilePos and bmp_Size,
first we add the size of the 2 Cardinal Values
ID_ver and Len1, which are the first 2 things in this file.
Next the Bmp_Rec1 position is calculated by multiplying the
SizeOf(Bmp_Rec1) by the record index c }

      FileStream1.WriteBuffer(FilePos, SizeOf(FilePos));
{the Write above will place this Cardinal, FilePos, in the
Bmp_Rec1.FilePos for that index Record}

      aryBitmap[c].SaveToStream(BmpStream);
{save aryBitmap[c] to the Memory stream so we can find
out the Size of the Bitmap File}
      Len1 := BmpStream.Size;
{it is VERY important to get the size of bitmap bytes in Len1,
and save to file or you will not be able to get the image out of the file}
      FileStream1.Write(Len1, SizeOf(Len1));
{the Write above will place this Cardinal, Len1 in the
Bmp_Rec1.bmp_Size for that index Record}

      FileStream1.Position := FilePos;
{IMPORTANT, you MUST reset the file Position back to FilePos,
so the next Write will be at the end of the file}

{remember that the BmpStream position is now at the END of the Stream
  and we need to SaveToStream From the Beginning of the BmpStream}
      BmpStream.Position := 0;
      BmpStream.SaveToStream(FileStream1);
      BmpStream.Clear;
      end;
    finally
    FileStream1.Free;
    BmpStream.Free;
    end;
  finally
  for c := 0 to High(aryBitmap) do
    aryBitmap[c].Free;
  end;
end;

The next code will open this file for Reading, and read all of the TBmp_Rec in the file Header, placing it's Description into a TListBox Item. No Bitmaps are loaded, and no Bitmap Data is read from the file, the only things that is read from the file are the TBmp_Rec records in the header.

procedure ReadToListBox; type TBmp_Rec = Record FilePos, bmp_Size: Cardinal; width, height: Integer; Description: String[15]; end; var FileStream1 : TFileStream; ID_ver: Integer; Bmp_Rec1: TBmp_Rec; Len1, c: Cardinal; FileName: String; begin FileName := 'E:\Bmp Rec1.brf'; if Not FileExists(FileName) then begin ShowMessage('File does not Exist, can not load'); Exit; end; FileStream1 := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite); try FileStream1.ReadBuffer(ID_ver, SizeOf(Integer)); if ID_ver <> 5211801 then begin {ALWAYS check your ID, if you try to load a file with incorrect data BAD THINGS can happen} ShowMessage('This is NOT a valid file for this version,'+ 'can not load'); Exit; end; FileStream1.ReadBuffer(Len1, SizeOf(Len1)); if (Len1 = 0) or (Len1 > 300) then Exit; {you can increase or leave out the test above, after you get this file access working} ListBox1.Clear; FOR c := 0 to Len1-1 do begin FileStream1.ReadBuffer(Bmp_Rec1, SizeOf(Bmp_Rec1)); {read each TBmp_Rec into the Bmp_Rec1} ListBox1.Items.Add(Bmp_Rec1.Description+ ' width '+IntToStr(Bmp_Rec1.width)); {now add the Discription and width to the ListBox Items} end; finally FileStream1.Free; end; ListBox1.ItemIndex := 0; end;

This procedure will read the File Header and get a Description from each of the TBmp_Rec records in the header. It will add this description and the width of the bitmap to ListBox1, so the user can choose the bitmap to load from ListBox1.




In the next Code the ListBox1 ItemIndex is used to Load Only One Bitmap from this muti-Bitmap file. You will see that the ListBox1 ItemIndex is used to calculate to file Position of the TBmp_Rec in the file header for that Bitmap index number, with this code -

FileStream1.Position := 8 + (ListBox1.ItemIndex * SizeOf(Bmp_Rec1));

FileStream1.Position := Bmp_Rec1.FilePos;

procedure ReadOneBMP;
type
 TBmp_Rec = Record
   FilePos, bmp_Size: Cardinal;
   width, height: Integer;
   Description: String[15];
   end;

var
FileStream1 : TFileStream;
BmpStream: TMemoryStream;
ID_ver: Integer;
Bmp_Rec1: TBMP_rec;
Bmp1: TBitmap;
Len1, c: Cardinal;
FileName: String;
begin
if ListBox1.ItemIndex < 0 then Exit;
{test the ItemIndex}
FileName := 'E:\Bmp Rec1.brf';
if Not FileExists(FileName) then
  begin
  ShowMessage('File does not Exist, can not load');
  Exit;
  end;

FileStream1 := TFileStream.Create(FileName, 
                    fmOpenRead or fmShareDenyWrite);
BmpStream := TMemoryStream.Create;
try
  FileStream1.Read(ID_ver, SizeOf(Integer));
  if ID_ver <> 5211801 then
    begin
{ALWAYS check your file ID}
    ShowMessage('This is NOT a valid file for this '+
                 'version, can not load');
    Exit;
    end;

  FileStream1.ReadBuffer(Len1, SizeOf(Len1));
  if (Len1 = 0) or (Len1 > 300) or 
      (ListBox1.ItemIndex > Len1-1) then Exit;
{make sure ItemIndex is in the file}
  FileStream1.Position := 8 + (ListBox1.ItemIndex * SizeOf(Bmp_Rec1));
{calculate the TBmp_Rec position for the index by 
adding 8 (ID_ver and Len1) and multiplying 
the index by the SizeOf(Bmp_Rec1)}
  FileStream1.ReadBuffer(Bmp_Rec1, SizeOf(Bmp_Rec1));
{Read the Bmp_Rec1 from the index Position}
  if (Bmp_Rec1.FilePos <> 0) and 
      (Bmp_Rec1.FilePos < FileStream1.Size) then
    begin
    FileStream1.Position := Bmp_Rec1.FilePos;
{set the file Position to the byte that is the 
begining of the Bitmap file Data Segment}
    Bmp1 := TBitmap.Create;
    try
      BmpStream.CopyFrom(FileStream1, Bmp_Rec1.bmp_Size);
{copy the BmpStream from the FileStream, 
remember that the Bmp_Rec1.bmp_Size has the number of bytes 
that you need to copy, the BmpStream position is now at 
the END of the Stream so we need to set it to zero}
      BmpStream.Position := 0;
      Bmp1.LoadFromStream(BmpStream);
      Form1.Canvas.Draw(6,6, Bmp1);
      finally
      Bmp1.Free;
      end;
    end;

  finally
  FileStream1.Free;
  BmpStream.Free;
  end;
end;

Please notice that by using a file header with the file position and data segment size in it, you can then get a single data segment's position and size, and load only a single Bitmap. This does not use a "Search" the whole file for a data segment, method for finding a single bitmap and loading it. I have seen some others use muti-data file retrival methods that place a "File Marker" in front of a data segment, and then search through the whole file for this File Marker, to locate the data segment. This search method can work, but is an extreamly Non-Efficient way to do data segment positioning. Beleive me, in your Email program, they do Not search through all of the emails in it's data base to find one email to read. A file header with data segment position is the basic building method for many multi data files, and is the idea used for most (maybe all) Data-Base file storage.

Using Data Segment IDs to Separate Data

If you need to create a file with several different types of data in it and you want have a different number of segments in each file, you can use a "Data Segment ID" method. Sometimes you will need to have a more flexible way to write data segments to the file, so you can have a different order and amount of data segments in each file you create. You can use a Data Segment ID number, to identify what type of Data (TRect, TBitmap, String, TMyRec) the following data segment contains, then when you are reading that file you would read the segment ID number and execute code nessary for that type of Data. This also allows you to place your data segments into the file in ANY order, and in ANY amount. Each file will be different in the number and types of data segments it contains.

Using Data Segments Identifiers
Here is some code that will write a file with Strings, Bitmaps and Icons in it. There can be any number of Strings, Bitmaps, and Icons in this file, and they can be in any order in this file. I use a File ID and Version number as a File header. There is a variable segID which I will use as the data segment Identifier I have it as a Word type, but you could use an Integer or Cardinal type. You could also use and array of Char for a segment ID, like 'Strg' or 'ICON', if you want to read it in a Hex Editor. I will use Hex expressions to designate values for this segID number, if you use HEX, then you can see what each Byte value is in your number. But you can use decimal expressions, it makes no difference to the code. The value I use for a "String" ID is $FCC0, the first Byte of this Word value is "FC" and the second byte is "C0". The value I use for a "Bitmap" ID is $FCC1, and for an Icon ID is $FCC2. Although I do not use or test the first byte "FC" in the code below, if you have complex data types with sub-types you could set the first byte "FC" to the Type and the second byte "C0" to the sub-type. Although you could use decimal expressions, it is very difficult (for me) to see the "Byte" relationships in decimal. And since file writing and reading is in a "Byte", it may be useful to know what the byte values are in your Identifiers.

There are several many different ways to test for the end of a file in a LOOP file read, which I will use in the read code for this file. The way I use to test for the end of the file is to place a segment ID with the "End of File" number and when this number is read, I exit the read LOOP. The End of File number I use here is $EEEE.

Your filestream writting will depend on the systems ability to read and write to the disk, a common disk write error is filling up a disk so there is no longer any free space to write data to. As I have said before, I might use the WriteBuffer( ), instead of the Write( ) method, so any file write error will exception out of the code progression. In the code below, I have included a BadWrite function and switched to the Write( ) function, to catch errors in file writting. Look at the code for BadWrite below. You can see that this function takes the filestream "Write" parameters and will use the filestream "Write" function and test it's results to see if all of the bytes were written. If the bytes written are incorrect, then it shows an error message and returns False, so the code progression will stop and exit. Also notice that there is a IsBad boolean variable set to "True" if there is a Bad write. Look in the last finally block of code, you will see a test for the IsBad variable, and if it is True, then this file with a write error will be Deleted. You should always make some effort to Delete a File that is Not properly written to disk.

I will put one bitmap in this file, using the methods I have used before with a TMemoryStream. The TMemoryStream SaveToStream procedure will throw an exception if there is a file write error, so I use a Try, except block of code so I can set the IsBad to True, and I just use raise; to raise that exception.
Here is the code for writting a file with Data Segment ID's -

procedure WriteSegIDFile;
var
MultiFile: TFileStream;
MemStream1: TMemoryStream;
FileName, Str1: String;
Bmp1: TBitmap;
segID: Word;
Len1: Cardinal;
verID: Integer;
IsBad: Boolean;

  function BadWrite(const Data1; Count1, ErrorNum: Integer): Boolean;
  begin
  {when writing to a file, you should have a way to test and exit your
  code if there is a file write error, like not enough disk space.
  this function tests the File write and if it does not write the full
  Count1 bytes, it will result in a False}
  Result := True;
  if MultiFile.Write(Data1, Count1) = Count1 then
    Result := False else
      begin
      Str1 := SysErrorMessage(GetLastError);
      IsBad := True; // set IsBad to True, to delete the file in the finally
      FreeAndNil(Bmp1); // Make sure you free all of the objects you created
      MessageBox(Form1.Handle, PChar('ERROR '+IntToStr(ErrorNum)+
              ' - Unable to complete the File Write, Disk may be Full'#10+Str1),
              'ERROR, INCOMPLETE FILE WRITE', MB_OK or MB_ICONERROR);
      end;
  end;

begin
IsBad := False;
 {the IsBad will be tested in the finally code, and if IsBad is True,
the Bad file will be deleted}
Str1 := 'This is File Data Segmemt string number one';
Bmp1 := TBitmap.Create;
Bmp1.Width := 300;
Bmp1.Height := 270;
Bmp1.Canvas.TextOut(6,25, 'Bitmap ONE data Segment');

FileName := 'N:\many.DataSeg';
MultiFile := TFileStream.Create(FileName, fmCreate or fmOpenWrite or fmShareDenyWrite);
MemStream1 := TMemoryStream.Create;
{I do Not use a LOOP to write this file, I just do ONE data segment at a time}
try
  verID := 7138201;  // File Type and version ID
  if BadWrite(verID, SizeOf(Integer), 1) then  Exit;
  {BadWrite will return True if all of the Bytes in Count1 can NOT be
  written to the file, so you Exit this procedure, and the finally code
  will be executed, where the file will be deleted}

  segID := $FCC0; // $FCC0 is the segment ID for a String
  if BadWrite(segID, SizeOf(segID), 2) then  Exit;
  Len1 := Length(Str1);
  if BadWrite(Len1, SizeOf(Len1), 3) then  Exit;
  if Len1 > 0 then
    if BadWrite(Str1[1], Len1, 4) then  Exit;

{the next string write is commented Out of this code, but you can remove the
comments and place this into the code, but you WILL NOT need to change the
code in your Read procedure, because as long as you place the correct segID
before your data segment, you can write as many data segments as you want}

  {Str1 := 'Commented Out string write';
  segID := $FCC0;
  if BadWrite(segID, SizeOf(segID), 2) then  Exit;
  Len1 := Length(Str1);
  if BadWrite(Len1, SizeOf(Len1), 3) then  Exit;
  if Len1 > 0 then
    if BadWrite(Str1[1], Len1, 4) then  Exit;}

  segID := $FCC1; // $FCC1 is the segment ID for a Bitmap
  if BadWrite(segID, SizeOf(segID), 5) then  Exit;
  Bmp1.SaveToStream(MemStream1);
  Len1 := MemStream1.Size;
  if BadWrite(Len1, SizeOf(Len1), 6) then  Exit;
  MemStream1.Position := 0;
  try
  {SaveToStream error will throw an exception}
    MemStream1.SaveToStream(MultiFile);
    except
    FreeAndNil(Bmp1);
    IsBad := True;
    raise;
    end;
  MemStream1.Clear;
  FreeAndNil(Bmp1);

  Str1 := 'String number TWO';
  segID := $FCC0;
  if BadWrite(segID, SizeOf(segID), 7) then  Exit;
  Len1 := Length(Str1);
  if BadWrite(Len1, SizeOf(Len1), 8) then  Exit;
  if Len1 > 0 then
    if BadWrite(Str1[1], Len1, 9) then  Exit;

  segID := $FCC2; // $FCC2 is the segment ID for an Icon
  if BadWrite(segID, SizeOf(segID), 10) then  Exit;
  Application.Icon.SaveToStream(MemStream1);
  Len1 := MemStream1.Size;
  if BadWrite(Len1, SizeOf(Len1), 11) then  Exit;
  MemStream1.Position := 0;
  try
    MemStream1.SaveToStream(MultiFile);
    except
    IsBad := True;
    raise;
    end;
  MemStream1.Clear;

  segID := $FCC2;
  if BadWrite(segID, SizeOf(segID), 12) then  Exit;
  MainForm1.Icon.SaveToStream(MemStream1);
  Len1 := MemStream1.Size;
  if BadWrite(Len1, SizeOf(Len1), 13) then  Exit;
  MemStream1.Position := 0;
  try
  MemStream1.SaveToStream(MultiFile);
  except
    IsBad := True;
    raise;
    end;
  MemStream1.Clear;

  Str1 := 'Last data Segment';
  segID := $FCC0;
  if BadWrite(segID, SizeOf(segID), 14) then  Exit;
  Len1 := Length(Str1);
  if BadWrite(Len1, SizeOf(Len1), 15) then  Exit;
  if Len1 > 0 then
    if BadWrite(Str1[1], Len1, 16) then  Exit;

  {IMPORTANT
  you must put a Marker to indicate the End of the File, because
  you will Read this file in a LOOP and this segID of $EEEE will
  end the LOOP}
  segID := $EEEE;
  if BadWrite(segID, SizeOf(segID), 17) then  Exit;
// write $EEEE a second time for safty
  if BadWrite(segID, SizeOf(segID), 17) then  Exit;

  finally
  FreeAndNil(MultiFile);
  FreeAndNil(MemStream1);
  {if there is a File Write error, IsBad will be set to True,
   and this File will be Deleted}
  if IsBad then
  DeleteFile(FileName);
  end;
end;

Reading a Data Segment ID File
The methods used to read this file are similar to what was used to write the file. In this file read code there is a BadRead function, because the system may Not be able to read all of the file or the file may be corrupted or cut off. So BadRead will test the file read for the amount of bytes read from the file, and set a IsBad Boolean variable to True. The IsBad variable is tested in the finally block of code so all of the Bitmaps and Icons can be Freed. Unlike the write procedure, this read procedure uses a Loop to keep reading the file until the End of File Segment ID $EEEE comes up. Since there can be any number of data segments, I use 3 dynamic arrays, one for strings, one for bitmaps, and one for icons. In the while loop, the SegID is tested and code is executed to read a string, a bitmap or an icon. It is important to always Free bitmaps so in the finally code block, there is a test of IsBad and all of the bitmaps and Icons are Freed.

procedure ReadSegIDFile;
var
MultiFile: TFileStream;
MemStream1: TMemoryStream;
aryStr: Array of String;
aryBmp: Array of TBitmap;
aryIcon: Array of TIcon;
// Arrays above will add a member for each String, Bmp or Icon in the file
segID: Word;
Len1: Integer;
verID: Integer;
IsBad: Boolean;

  function BadRead(var Data1; Count1, ErrorNum1: Integer): Boolean;
  begin
  {This BadRead function will will show an Error Message if the system
  can NOT read all of the bytes from a file, the IsBad variable set to
  True, so all of the Bitmaps and Icons will be freed in the finally}
  Result := True;
  if MultiFile.Read(Data1, Count1) = Count1 then
    Result := False else
      begin
      IsBad := True;  // IsBad as True will Free all Bitmaps and Icons
      MessageBox(Form1.Handle, PChar('ERROR '+IntToStr(ErrorNum1)+
              ' - Incorrect File Read, Read will END'#10+SysErrorMessage(GetLastError)),
              'ERROR, INCOMPLETE FILE READ', MB_OK or MB_ICONERROR);
      end;
  end;

begin
IsBad := False;
MultiFile := TFileStream.Create('E:\many.DataSeg', fmOpenRead or fmShareDenyWrite);
MemStream1 := TMemoryStream.Create;
try
  MultiFile.ReadBuffer(verID, SizeOf(verID));
{I use ReadBuffer for the first read, because I want this to
exception out if there is less than 4 bytes in this file}
  if verID <> 7138201 then
    begin
{ALWAYS check your file ID}
    ShowMessage('This is NOT a valid file or version for this '+
                 'version, can not load this file');
    Exit;
    end;

  if BadRead(segID, SizeOf(segID), 1) then Exit;
  // Use BadRead to check All of the file reads

  {this while loop will test the segID and execute code for the type of data
  the segment ID number represents, I use Hex for the segID because you
  can see each Byte of the Word value. The value for the End of File segID is
  $EEEE, and this will end the while loop}

  while segID <> $EEEE do // $EEEE is the segment ID for end of file
    begin
    // Application.ProcessMessages; //you may want to include a ProcessMessages
    if segID = $FCC0 then // $FCC0 id the ID for a String
      begin
      if BadRead(Len1, SizeOf(Len1), 2) then Break; // Break loop for error
      if Len1 > 0 then
        begin
        SetLength(aryStr, Length(aryStr)+1);
        SetLength(aryStr[High(aryStr)], Len1);
        if BadRead(aryStr[High(aryStr)][1], Len1, 3) then Break;
        end;
      end else
    if segID = $FCC1  then // $FCC1 is the ID for a Bitmap
      begin
      if BadRead(Len1, SizeOf(Len1), 3) then Break;
      if Len1 > 0 then
        begin
        if MemStream1.CopyFrom(MultiFile, Len1) < Len1 then
          begin
        {test the CopyFrom function for a Bad Read}
          IsBad := True;
          MessageBox(Form1.Handle, PChar('ERROR 4'+
              ' - Incorrect File Read, Read will END'#10+
              SysErrorMessage(GetLastError)),
              'ERROR, INCOMPLETE FILE READ', MB_OK or MB_ICONERROR);
          Break;
          end;
        SetLength(aryBmp, Length(aryBmp)+1);
        aryBmp[High(aryBmp)] := TBitmap.Create;
        MemStream1.Position := 0;
        try
          aryBmp[High(aryBmp)].LoadFromStream(MemStream1);
          except
          {LoadFromStream will throw an Exception for a Bad file read}
          IsBad := True;
          //raise;
          MessageBox(Form1.Handle, PChar('ERROR 5'+
              ' - Incorrect File Read, Read will END'),
              'ERROR, INCOMPLETE FILE READ', MB_OK or MB_ICONERROR);
          Break;
          end;
        MemStream1.Clear;
        end;
      end else
    if segID = $FCC2  then // $FCC2 is the ID for an Icon
      begin
      if BadRead(Len1, SizeOf(Len1), 6) then Break;
      if Len1 > 0 then
        begin
        if MemStream1.CopyFrom(MultiFile, Len1) < Len1 then
          begin
          IsBad := True;
          MessageBox(Form1.Handle, PChar('ERROR 7'+
              ' - Incorrect File Read, Read will END'),
              'ERROR, INCOMPLETE FILE READ', MB_OK or MB_ICONERROR);
          Break;
          end;
        SetLength(aryIcon, Length(aryIcon)+1);
        aryIcon[High(aryIcon)] := TIcon.Create;
        MemStream1.Position := 0;
        try
          aryIcon[High(aryIcon)].LoadFromStream(MemStream1);
          except
          IsBad := True;
          MessageBox(Form1.Handle, PChar('ERROR 8'+
              ' - Incorrect File Read, Read will END'),
              'ERROR, INCOMPLETE FILE READ', MB_OK or MB_ICONERROR);
          Break;
          end;
        MemStream1.Clear;
        end;
      end else // segID is NOT a recognized number
      begin
      IsBad := True;
      MessageBox(Form1.Handle, PChar('ERROR 10'+
              ' - Incorrect File Read, Read will END'),
              'ERROR, INCOMPLETE FILE READ', MB_OK or MB_ICONERROR);
      Break;
      end;

    if BadRead(segID, SizeOf(segID), 11) then Break;
    // get the segID after each data segment read
    end;
  finally
  FreeAndNil(MultiFile);
  FreeAndNil(MemStream1);
  //Test for IsBad and Free all Bitmaps and Icons
  if IsBad then
    begin
    for verID := 0 to High(aryBmp) do
      FreeAndNil(aryBmp[verID]);
    for verID := 0 to High(aryIcon) do
      FreeAndNil(aryIcon[verID]);
    SetLength(aryStr, 0);
    end;
  end;

for verID := 0 to High(aryBmp) do
  Form1.Canvas.Draw(6+(verID*60), 4, aryBmp[verID]);

for verID := 0 to High(aryIcon) do
  Form1.Canvas.Draw(6+(verID*32), 104, aryIcon[verID]);

for verID := 0 to High(aryBmp) do
  FreeAndNil(aryBmp[verID]);
for verID := 0 to High(aryIcon) do
  FreeAndNil(aryIcon[verID]);
if High(aryStr) > -1 then
ShowMessage(aryStr[High(aryStr)]);
end;

if MultiFile.Position = MultiFile.Size then break;

you could also put a Data Segment Count in the file header and break the loop when the count is equal to the data segments read. You might want to experiment with some ways to end the file read.

You can also use this segment ID method for the "Header" of your file, some kinds of files (like the JPEG - JFIF image files) have file headers that are NOT a fixed size, , since the information needed for the header may change. So if you need a flexible file information header, you can start your file header with your File ID, and then place a header data segment ID (like $FF11) followed by your header information, and you can place as few or as many header data segments as that special file requires. The JPEG file use this method of header writting because their file headers can have different amount of header data segments in different positions, and each can change in their size (bytes of data in the segment), so they have a header segment ID, followed by a data size byte or Word value.

There is another Delphi-Zeus about file access, using the window's API functions, like CreateFile( ), you can see this page at lesson 15 - Writing and Reading Files. You may consider using the API file access instead of the TFileStream, since the difficulty with file access is less with the access functions, than with how to arrange, identify and sort the bytes of a file.