来自MSDN-2001-OCT: Visual Tools and Languages/Visual Studio 6.0 Documentation/Visual Basic Documentation/Using Visual Basic/Programmer’s Guide/Part 2: What Can You Do With Visual Basic/Processing Drives,Folders,and Files/

1. Processing Drives,and Files

(1) Visual Basic allows you to process drives,folders,and files in two different ways: through traditional methods such as the Open statement,Write#,and so forth,and through a new set of tools,the File System Object (FSO) object model.

(2) The FSO object model gives your applications the ability to create,alter,move,and delete folders,or to detect if particular folders exist,and if so,where. It also enables you to gain information about folders,such as their names,the date they were created or last modified,and so forth.

(3) The FSO object model,which is contained in the Scripting type library (Scrrun.Dll),supports text file creation and manipulation through the TextStream object.

It does not as yet,however,support the creation or manipulation of binary files. To manipulate binary files,use the Open command with the Binary flag.

(4) While you can store data in a database,such as Jet or sql,it adds a significant amount of overhead to your application. For many reasons,you may not want to have such an overhead,or your data access requirements may not require all the extra features associated with a full-featured database. In this case,storing your data in a binary or text file is the most efficient solution.

2. The File System Objects

3. Working with Drives and Folders

(1) To gain access to an existing drive,file,or folder,use the appropriate "get" method of the FileSystemObject object: GetDrive,GetFolder,GetFile. For example:

Note,that you don't need to use the "get" methods for newly-created objects,since the "create" functions already return a handle to the newly-created object.

(2) The Drive object allows you to gain information about the varIoUs drives attached to a system,either physically or over a network.

(3) If you use the CurDir function,the ChDrive and ChDir statements,or the Path property (App.Path),be aware that they may return a UNC path (that is,//Server/Share…) rather than a drive path (such as E:/Folder),depending on how you run your program or project.

多用户局域网共享程序的时候，需要特别的处理。

(4)

4. Working With Files

(1) There are two major categories of file manipulation: a) Creating,adding,or removing data,and reading files; b) Moving,copying,and deleting files.

(2) There are three ways to create a sequential text file (sometimes referred to as a "text stream"). One way is to use the CreateTextFile method. To create an empty text file:

Another way is to use either the OpenTextFile method of the FileSystemObject object with the ForWriting flag set:

Or you can use the OpenAsTextStream method with the ForWriting flag set:

(3) Adding Data to the File: Once the text file is created,you can add data to it in three steps: a) Open the text file for the writing of data. b) Write the data. c) Close the file.

To open the file,you can use either of two methods: the OpenAsTextStream method of the File object,or the OpenTextFile method of the FileSystemObject object.

To write data to the open text file,use either the Write or WriteLine methods of the TextStream object. The only difference between Write and WriteLine is that WriteLine adds newline characters to the end of the specified string.

If you want to add a newline to the text file,use the WriteBlankLines method.

To close an open file,use the Close method of the TextStream object.

(4) Reading Files with File System Objects: To read data from a text file,use the Read,ReadLine,or ReadAll methods of the TextStream object.

If you use the Read or ReadLine method and you want to skip to a particular portion of data,you can use the Skip or SkipLine method.

(5) The vbNewLine constant contains a character or characters (depending on the operating system) to advance the cursor to the beginning of the next line (carriage-return/lineFeed). Be aware that the ends of some strings may have such nonprinting characters.

(6) The FSO object model has two methods each for moving,and deleting files.

5. Processing Files with Older File I/O Statements and Functions

(1) In Visual Basic,there are three types of file access: a) Sequential — For reading and writing text files in continuous blocks. b) Random — For reading and writing text or binary files structured as fixed-length records. c) Binary — For reading and writing arbitrarily structured files.

(2) Sequential access is designed for use with plain text files. Each character in the file is assumed to represent either a text character or a text formatting sequence,such as a newline character (NL). Data is stored as ANSI characters.

Sequential access works best when you want to process files consisting only of text,such as the files created with a typical text editor — that is,files in which data is not divided into a series of records. Sequential access may not be well suited for storing long series of numbers,because each number is stored as a character string. A four-digit number would require 4 bytes of storage instead of the 2 bytes it requires to store the same number as an integer.

(3) It is assumed that a file opened for random access is composed of a set of identical-length records. You can employ user-defined types to create records made up of numerous fields — each can have different data types. Data is stored as binary information.

(4) Binary access allows you to use files to store data however you want. It is similar to random access,except there are no assumptions made about data type or record length. However,you must know precisely how the data was written to the file to retrieve it correctly.

(5) 这里有个完整的列表of File Access Functions and Statements

6. Using Sequential File Access

(1) It is recommended that you use File System Objects to create text files.

(2) Open pathname For [Input | Output | Append] As filenumber [Len = buffersize]

(3) If you want to edit a file,first read its contents to program variables,then change the variables,and finally,write the variables back to the file.

(4) To retrieve the contents of a text file,open the file for sequential Input. Then use the Line Input #,Input( ),or Input # statement to copy the file into program variables.

(5) To store the contents of variables in a sequential file,open it for sequential Output or Append,and then use the Print # statement.

Visual Basic also supports the Write # statement,which writes a list of numbers and/or string expressions to a file. It automatically separates each expression with a comma and puts quotation marks around string expressions.

If you are using Write # and Input # with sequential access,consider using random or binary access instead,because they are better suited to record-oriented data.

7. Using Random File Access

(1) The bytes in random-access files form identical records,each containing one or more fields. A record with one field corresponds to any standard type,such as an integer or fixed-length string. A record with more than one field corresponds to a user-defined type.

(2) Because all records in a random-access file must have the same length,it is often useful for string elements in a user-defined type to have a fixed length.

If you use variable-length strings,the total size of any record stored with Put or retrieved with Get must not exceed the record length specified in the Open statement’s Len clause.

(3) Open pathname [For Random] As filenumber Len = reclength

Note that every string variable in Visual Basic stores a Unicode string and that you must specify the byte length of that Unicode string.

RecLength = LenB(Employee)

(4) Use the Put statement to add or replace records into files opened for random access.

(5) You could delete a record by clearing its fields,but the record would still exist in the file. Usually you don’t want empty records in your file,because they waste space and interfere with sequential operations. It is better to copy the remaining records to a new file,and then delete the old file.

8. Using Binary File Access

(1) Binary access gives you complete control over a file,because the bytes in the file can represent anything. For example,you can conserve disk space by building variable-length records. Use binary access when it is important to keep file size small.

(2) Note When writing binary data to a file,use a variable that is an array of the Byte data type,instead of a String variable. Strings are assumed to contain characters,and binary data may not be properly stored in String variables.

(3) The drawback to binary input/output with variable-length fields is that you can’t access records randomly — you must access records sequentially to learn the length of each record.