Please support our sponsor:
DirectX4VB.Com - All You Need For Multimedia Visual Basic Programming

Main Site Links Resources Tutorials
News VB Gaming Code Downloads DirectX 7
Contact Webmaster VB Programming Product Reviews DirectX 8
  General Multimedia Articles DirectX 9


Tips and Tricks: Binary File Access
Author: Jack Hoxley
Written: 3rd May 2001
Contact: [EMail]

Contents of this lesson
1. Introduction
2. How to use binary file access

1. Introduction

Depending on your experience with the visual basic language you may or may not have come across binary file access (you would know if you had!), but assuming you know anything about file input/output using VB you'll want to know about binary files.

As a particular example, games. Games are increasingly becoming data driven - which is a good thing in many ways (but not the topic of this article), but it means that vast amounts of data are stored in external files, this creates two problems, loading times have to be tuned perfectly if large amounts of data must be loaded, and large amounts of data must be stored (ie, lots of space required). Whilst there is never any perfect solution to the speed versus size problem, binary file access does a pretty good job at both.

Take the constant Pi for example, 3.1415926535898 (13 decimal places). using normal string output methods (Write# and Print#) it would logically take up 15 characters, where 1 character is 1 byte - 15 bytes have to be stored. However, you should also be aware that internally Pi would be of type "Single", a 32bit floating point number - 32bit indicating 4 bytes of memory (8 bits to a byte). So we have this large number taking up 4 bytes of system memory yet 15 bytes in our file. You don't need to be a genius to know that this isn't very efficient - the saved version is 3.75 times larger! You'll never guess what... Binary file access allows us to only save it as 4 bytes.

2. How to use binary file access

So you want to know how to play with this feature now! luckily for you it's extremely simple, first time around may be slightly confusing - but it's easy after that.

For this article, we are going to go about saving and loading two arrays - one 32bit floating point array (singles), the other 16bit integers (integer). Here's the amazingly complex code that does the trick:

Dim sngArr(0 To 999) As Single '4000 bytes
Dim intArr(0 To 999) As Integer '2000 bytes
Dim I As Long
'##Fill the arrays with stuff
For I = 0 To 999
    sngArr(I) = Rnd
    intArr(I) = CInt(Rnd * 30000)
Next I
Open "C:\Example.dat" For Binary Access Write As #19
    Put #19, , sngArr
    Put #19, , intArr
Close #19
Open "C:\Example.dat" For Binary Access Read As #21
    Get #21, , sngArr
    Get #21, , intArr
Close #21

greatly complicated isn't it! There are a few things to bare in mind; when writing the data VB will effectively dump the memory onto the hard drive, if the array is a 64mb monster, so will the file. The most important part is when reading the file - it has to be done in the correct order if you want the correct results, the "Get #21,,sngArr" line will read in the first 4000 characters in the file and convert them into 1000 singles, you're only going to get an error if there's not enough data, but you are going to get some funny results if the first 4000 characters were originally 2000 integers, you'll effectively end up with 2 integers stored in one single - leading to some strange numbers (compared with what you might of expected to get). Now we need to delve into the specifics:

All of the specific and extended details for this topic can be found in the MSDN/help files. highlight the word "Binary" and hit F1 - follow the links to the MSDN, and you'll get a full listing of everything you need to know. As a quick summary of what you need to know, I've drawn up the following list:

The missing parameter in the "Get" line is the byte offset into the file; if you know that you need to start reading the integers from character 2000 then you put that number in here, if it's left as nothing (like in our example) then reading begins at the current position (the beginning if the file was just opened, or the bytes after the previous one read).
Likewise, the missing parameter in the "Put" line indicates the position that writing starts from. You can use this to overwrite existing data.
The line that opens the file has many combinations of parameters, the "Access..." part can either be "Read", "Write" or "Read Write".
The filename must exist if reading, if it doesn't exist when you open a file for writing it will be created
The File number #21 or #19 used can be determined using the FreeFile statement, or you can guess a number between 1 and 511 (not very professional though)

There! Your whirlwind tour of binary file reading and writing is now complete, it wasn't too hard was it... As a side note, I ONLY ever use binary access, with the exception of log files, where the Print and Write statements are more useful. Binary files save lots and lots of space, and are much faster to load from...

DirectX 4 VB 2000 Jack Hoxley. All rights reserved.
Reproduction of this site and it's contents, in whole or in part, is prohibited,
except where explicitly stated otherwise.
Design by Mateo
Contact Webmaster
This site is hosted by Exhedra Solutions, Inc., the parent company of and