Opening and closing files

To begin our work on files we will look at some commands that are common to both Sequential and Random files. After that we will look at the specific processing commands for each type of file.

The first command to include in a program that needs to work with files is the Open command. Open assigns the file to a numbered file handle, also called a channel, or sometimes a buffer. The format of the command is:



For example:

• MyFile.txt is the name of the file in the disk directory.
• For Random means that access to the records can be random; if access is not specified, For random is the default value.
• Read restricts access to Read-only - the user cannot write or change the records.
• Lock Read means that only the person reading the record can have access to it at any given time; it is not shared among users.
• As #1 means the file is assigned file handle #1; for all processing in the program, it will always be refered to as #1, not its Filename.

AccessRestriction and LockType are parameters that are used mostly with files in a network environment. You use them when you want the file to be shared or not, and you want to prevent certain users from changing or deleting things that they shouldn't. For the rest of this lesson we will not be using those parameters.

Access Mode

For Mode in the Open statement indicates how the file will be used. There are five access modes:

• Input: open for sequential input; the file will be read sequentially starting at the beginning.
  
  
• Output: open for sequential output; records will be written sequentially starting at the beginning; if the file does not exist, it is created; if it does exist, it is overwritten.
  
  
• Random: open for random read and write; any specific record can be accessed.
  
  
• Append: sequential output to the end of an existing file; if the file does not exist it is created; it does not overwrite the file.
  
  
• Binary: open for binary read and write; access is at byte level.

If access mode is not specified in the Open statement, For Random is used by default.


Once processing is finished, you need to Close all the files that have been opened. The format for the Close statement is:


You can close any number of files with one Close statement. Eg:


The following statement closes all open files:

Writing and Reading a Sequential file

There are two commands that allow you to write data to a sequential file: Print and Write. They work in almost the same way but, the Print command does not separate the fields in the file in quite the same way which makes the data harder to read afterwards. There is really no valid reason to use Print when creating a sequential file. In the rest of this lesson we will use Write exclusively.

The format of the Write command is:



where FileNumber is the number the file was opened with and OutputList is one or more variables you want to write to the file.

Address Book Example

In this exercise we will create a simple address book file to keep track of people's names, addresses and phone numbers.

To handle the various forms that we have to use, we will develop a new technique for these lessons: the use of a Menu of choices. Note that that is not the same as a Menu bar used in a form. In this case we are just going to line-up a series of buttons for the different forms that have to be called. There has also been a small change to the display format - from now on all the forms are maximized (they occupy the full screen) - this is often easier for the user to work with, rather than have a number of different forms overlapping on the screen. To get the form to run maximized, change the Form property WindowState -> 2 - Maximized.

This is what the menu should look like:



The code for the menu consists of loading and showing the various forms. The Exit button exits the Menu itself. Any open files are closed by the individual forms.

File design

It has been determined that the file will store 7 fields of information. First and last names could be together and we could have a work phone number but, the Analyst (who gets paid big bucks to think this stuff up) has determined that 7 is what is required. It has also been decided that the file will be called "AdrsBook.txt" and will be stored in "C:\VBApps" - we need to know this for the Open statement.

It must also be determined, before we start to code, what the File mode is going to be when we output to the file. We could use "Output" but that would mean that every time that we want to add a new listing, we wipe-out the file. Not very practical! Therefore, we will use "Append" so that all new entries are added to the end of the existing file.

Finally, once the controls are in place on the form, we have to finalize the order in which we Tab through them when working from the keyboard. That is called the Tab order. To set the tab order, we use the TabIndex property for each control. It starts at 0 and goes up for every control in order. When the form opens, the control with TabIndex=0 gets focus; when you tab from that, focus goes to TabIndex=1, and so on. Controls that don't get focus - Labels, Pictures, etc. - do have a TabIndex but their TabStop property is set to False. If you don't want Tab to stop on a control, set its TabStop to False.

Here is what the Sequential Output form will look like when we use it:



Once the file has been created we can use Notepad to look at it. Notice that the last entry, the one on the form above, is not yet in the file. It gets written only when you hit the Write button. Each field entered is stored as a separate line in the file. When we read them, we read in the same order as that in which they were written.

Creating the Sequential Output form

The form SAdresOut is used to capture data from the user and then output that data to the AdrsBook.txt file. The design of the form is what you see in the diagram above.

As you can see, we need 7 TextBox controls to capture the 7 fields. To simplify the code, we will use a technique we haven't used before in these lessons: the Control Array. You may have seen that come up before if you tried to copy and paste controls. What we do is: create one TextBox control, give it a name - we call it "txt_field" -, and then copy that control and paste it 6 times on the form. When you paste a control, since it has the same name as the existing one, the editor asks whether you want to give it a new name or create a control array. In this case we tell it to create the control array. This means that, instead of 7 different TextBoxes, we will have an array of TextBoxes, named txt_field(0) to txt_field(6). As you can see from the code, this allows us to use For ... Next loops to do things like clear the controls and write to the file.

The Cancel button simply clears all the TextBoxes and does not executes a Write operation. The Exit button closes the open files and unloads the form which returns us automatically to the Menu form. There is no End statement, as that would cause the program to end.



The code to write to the file is fairly straightforward. Once information has been entered into the 7 TextBoxes, we use a FOR ... NEXT loop to execute the Write command. The reason for this is that the Write command outputs only one field at a time. So, we have to do 7 writes to output the whole record. After the TextBoxes have been written-out, we clear them to create the next record.

Working with a Random file

For this exercise we will use the same Menu form that we started with but we'll create a new output file which we will call "PhoneBook.txt". Since this file format is different from the sequential, we can't use the same file to test the code. The PhoneBook file will have almost the same content as the AdresBook file. The only difference is that we'll add a field for PersonId at the beginning of each record. That will allow us to retrieve records using a record number.

User-defined data type

In addition to data types like String, Integer, Date and so on, you can also define your own data type. This type is called structure or structs in other languages. We will use it in our application to simplify our I/O operations since our I/O commands, Put and Get only handle one field at a time. What we do with the user-defined data type is to create a new variable which contains a whole record.

The user-defined variable must be declared in a module. That's a program at the application level, not tied to any specific event. To create a module: Menu bar --> Project --> Add module --> Open. When you save the module, it will take the .BAS extension. The information contained in modules is available to all the forms in the application. This is what your first module should contain:



The Type statement creates a new data type; in this case, it's PhoneRec. Once it's been defined, the new type can be used like any other type, String or Integer, etc. to declare a variable:



The individual fields in the structured variable can be accessed using dot notation:



When you define the fields within the new type, it's important to determine the length of each string. Random access is sensitive about record lengths. When you define a String field like: Fname As String * 15 you determine that the size of the field will always be 15 characters. This is important for the processing to work properly! Just make sure that the size you assign is big enough to handle most situations. You do not have to worry about the Integer field because its size is standard.

Writing and Reading records

The command to write records to the Random file is Put. Its format is:

Put #Filenumber, [RecordNumber], Variable

RecordNumber is optional and, if it's omitted, variable is written in Next record position after last Put or Get statement.

The command to read records from a Random file is: Get. Its format is:

Get #FileNumber, [RecordNumber], Variable

If RecordNumber is omitted, next record is read from the file.

Creating the Random file

To create the PhoneBook file, we will need a new form which is just a copy of the SAdresOut form with the additional Person number TextBox, which is in fact the record number. Then we'll write the code, making use of the user-defined data type "PhoneRec" described earlier. This form, "RAdresOut", obtains the next record number from the file, accepts input from the user and writes- the record out to the file.







To read records from the file, we have to specify a record number. This number is accepted into the Person number TextBox and then used to locate the appropriate record in the file.

The error-trapping routine is useful in this procedure because you are almost certain to encounter the "Reading past End-of-file" error when you enter a Person number that does not exist.