Along with the five classes outlined in the previous section, .NET also includes a helper class named Path in the same System.IO namespace. The Path class doesn't include any real file management functionality. It simply provides a few shared methods that are useful when manipulating strings that contain file and directory paths.

For example, the Path class includes a GetFileName() method that pulls the file name out of a full string. Here's an example:

Dim file As String = Path.GetFileName( _
  "c:DocumentsUploadUsersJamesX
esume.doc")
' file now contains "resume.doc"

The Path class also includes a Combine() method that can tack a relative path on the end of an absolute path. Here it is at work, fusing two strings together:

Dim absolutePath As String = "c:UsersMyDocuments"
Dim subPath As String = "Sarahworksheet.xls"
Dim combined As String = Path.Combine(absolutePath, subPath)
' combined now contains "c:UsersMyDocumentsSarahworksheet.xls"

You could perform all of these tasks on your own, but the Path class is a great way to avoid errors. Table 17-1 lists the methods of the Path class.

The Directory and File classes provide a number of useful shared methods. Table 17-2 and Table 17-3 show an overview of the most important methods. Most of these methods take the same parameter: a fully qualified path name identifying the directory or file you want the operation to act on. A few methods, such as Delete() and Move(), take additional parameters.

The File class also includes some methods that allow you to create and open files as streams. You'll explore these features in the "Reading and Writing with Streams" section of this chapter. The only feature the File class lacks (and the FileInfo class provides) is the ability to retrieve the size of a specified file.

The File and Directory methods are quite intuitive. For example, consider the code for a simple page that displays some information about the files in a specific directory. You might use this code to create a simple admin page that allows you to review the contents of an FTP directory (see Figure 17-1). Clients could use this page to review their documents and remove suspicious files.

Figure 17.1. An admin page with file information

You should begin by importing the namespace that has the IO classes:

Imports System.IO

The code for this page is as follows:

Public Partial Class ViewFiles
    Inherits System.Web.UI.Page

    Private ftpDirectory As String

    Protected Sub Page_Load(ByVal sender As Object, _
      ByVal e As EventArgs) Handles Me.Load
        ftpDirectory = Path.Combine(Request.PhysicalApplicationPath, "FTP")
        If Not Me.IsPostBack Then
            CreateFileList()
        End If
    End Sub

    Private Sub CreateFileList()

' Retrieve the list of files, and display it in the page.
        ' This code also disables the delete button, ensuring the
        ' user must view the file information before deleting it.
        Dim fileList() As String = Directory.GetFiles(ftpDirectory)
        lstFiles.DataSource = fileList
        lstFiles.DataBind()
        lblFileInfo.Text = ""
        cmdDelete.Enabled = False
    End Sub

    Protected Sub cmdRefresh_Click(ByVal sender As Object, _
      ByVal e As EventArgs) Handles cmdRefresh.Click
        CreateFileList()
    End Sub

    Protected Sub lstFiles_SelectedIndexChanged(ByVal sender As Object, _
      ByVal e As EventArgs) Handles lstFiles.SelectedIndexChanged

        ' Display the selected file information.
        ' Use the StringBuilder for the fastest way to build the string.
        Dim fileName As String = lstFiles.SelectedItem.Text
        Dim displayText As New System.Text.StringBuilder
        displayText.Append("<b>")
        displayText.Append(fileName)
        displayText.Append("</b><br /><br />")
        displayText.Append("Created: ")
        displayText.Append(File.GetCreationTime(fileName).ToString())
        displayText.Append("<br />Last Accessed: ")
        displayText.Append(File.GetLastAccessTime(fileName).ToString())
        displayText.Append("<br />")

        ' Show attribute information. GetAttributes can return a combination
        ' of enumerated values, so you need to evaluate it with the
        ' And keyword.
        Dim Attr As FileAttributes = File.GetAttributes(fileName)
        If (Attr And FileAttributes.Hidden) = FileAttributes.Hidden Then
            displayText.Append("This is a hidden file.<br />")
        End If
        If (Attr And FileAttributes.ReadOnly) = FileAttributes.ReadOnly Then
            displayText.Append("This is a read-only file.<br />")

            cmdDelete.Enabled = False
        Else
            cmdDelete.Enabled = True
        End If

        ' Display the information.
        lblFileInfo.Text = displayText.ToString()
    End Sub

    Protected Sub cmdDelete_Click(ByVal sender As Object, _
      ByVal e As EventArgs) Handles cmdDelete.Click
        File.Delete(lstFiles.SelectedItem.Text)
        CreateFileList()

End Sub

End Class

The DirectoryInfo and FileInfo classes mirror the functionality in the Directory and File classes. In addition, they make it easy to walk through directory and file relationships. For example, you can easily retrieve the FileInfo objects for the files in a directory represented by a DirectoryInfo object.

Note that while the Directory and File classes expose only methods, DirectoryInfo and FileInfo provide a combination of properties and methods. For example, while the File class had separate GetAttributes() and SetAttributes() methods, the FileInfo class includes an Attributes property.

Another nice thing about the DirectoryInfo and FileInfo classes is that they share a common set of properties and methods because they derive from the common FileSystemInfo base class. Table 17-4 describes the members they have in common.

In addition, the FileInfo and DirectoryInfo classes have a few unique members, as indicated in Table 17-5 and Table 17-6.

When you create a DirectoryInfo or FileInfo object, you specify the full path in the constructor:

Dim myDirectory As New DirectoryInfo("c:Temp")
Dim myFile As New FileInfo("c:Temp
eadme.txt")

This path may or may not correspond to a real physical file or directory. If it doesn't, you can always use the Create() method to create the corresponding file or directory:

' Define the new directory and file.
Dim myDirectory As New DirectoryInfo("c:TempTest")
Dim myFile As New FileInfo("c:TempTest
eadme.txt")

' Now create them. Order here is important.
' You can't create a file in a directory that doesn't exist yet.
myDirectory.Create()
myFile.Create()

The DriveInfo class allows you to retrieve information about a drive on your computer. Just a few pieces of information will interest you. Typically, the DriveInfo class is merely used to retrieve the total amount of used and free space.

Table 17-7 shows the DriveInfo members. Unlike the FileInfo and DriveInfo classes, there's no Drive class with instance versions of these methods.

You can use methods such as DirectoryInfo.GetFiles() and DirectoryInfo.GetDirectories() to create a simple file browser. The following example shows you how. Be warned that, although this code is a good example of how to use the DirectoryInfo and FileInfo classes, it isn't a good example of security. Generally, you wouldn't want a user to be able to find out so much information about the files on your web server.

The sample file browser program allows the user to see information about any file in any directory in the current drive, as shown in Figure 17-2.

Figure 17.2. A web server file browser

The code for the file browser page is as follows:

Public Partial Class FileBrowser
    Inherits System.Web.UI.Page

    Protected Sub Page_Load(ByVal sender As Object, _
      ByVal e As EventArgs) Handles Me.Load
        If Not Me.IsPostBack Then
            Dim startingDir As String = "c:"
            lblCurrentDir.Text = startingDir
            ShowFilesIn(startingDir)
            ShowDirectoriesIn(startingDir)
        End If
    End Sub

    Private Sub ShowFilesIn(ByVal dir As String)
        lblFileInfo.Text = ""

lstFiles.Items.Clear()

        Try
            Dim dirInfo As New DirectoryInfo(dir)
            For Each fileItem As FileInfo In dirInfo.GetFiles()
                lstFiles.Items.Add(fileItem.Name)
            Next
        Catch err As Exception
            ' Ignore the error and leave the list box empty.
        End Try
    End Sub

    Private Sub ShowDirectoriesIn(ByVal dir As String)
        lstDirs.Items.Clear()

        Try
            Dim dirInfo As New DirectoryInfo(dir)
            For Each dirItem As DirectoryInfo In dirInfo.GetDirectories()
                lstDirs.Items.Add(dirItem.Name)
            Next
        Catch err As Exception
            ' Ignore the error and leave the list box empty.
        End Try
    End Sub

    Protected Sub cmdBrowse_Click(ByVal sender As Object, _
      ByVal e As EventArgs) Handles cmdBrowse.Click
        ' Browse to the currently selected subdirectory.
        If lstDirs.SelectedIndex <> −1 Then
            Dim newDir As String = Path.Combine(lblCurrentDir.Text, _
              lstDirs.SelectedItem.Text)
            lblCurrentDir.Text = newDir
            ShowFilesIn(newDir)
            ShowDirectoriesIn(newDir)
        End If
    End Sub

    Protected Sub cmdParent_Click(ByVal sender As Object, _
      ByVal e As EventArgs) Handles cmdParent.Click
        ' Browse up to the current directory's parent.
        ' The Directory.GetParent method helps us out.
        Dim newDir As String
        If Directory.GetParent(lblCurrentDir.Text) Is Nothing Then
            ' This is the root directory; there are no more levels.
            Exit Sub
        Else
            newDir = Directory.GetParent(lblCurrentDir.Text).FullName
        End If

        lblCurrentDir.Text = newDir
        ShowFilesIn(newDir)
        ShowDirectoriesIn(newDir)
    End Sub

Protected Sub cmdShowInfo_Click(ByVal sender As Object, _
      ByVal e As EventArgs) Handles cmdShowInfo.Click
        ' Show information for the currently selected file.
        If lstFiles.SelectedIndex <> −1 Then
            Dim fileName As String = Path.Combine(lblCurrentDir.Text, _
              lstFiles.SelectedItem.Text)

            Dim displayText As New StringBuilder()
            Try
                Dim selectedFile As New FileInfo(fileName)
                displayText.Append("<b>")
                displayText.Append(selectedFile.Name)
                displayText.Append("</b><br />Size: ")
                displayText.Append(selectedFile.Length)
                displayText.Append("<br />")
                displayText.Append("Created: ")
                displayText.Append(selectedFile.CreationTime.ToString())
                displayText.Append("<br />Last Accessed: ")
                displayText.Append(selectedFile.LastAccessTime.ToString())
            Catch err As Exception
                displayText.Append(err.Message)
            End Try

            lblFileInfo.Text = displayText.ToString()
        End If
    End Sub

End Class

You can write to a file and read from a file using a StreamWriter and a StreamReader—dedicated classes that abstract away the process of file interaction. There really isn't much to it. You can create the StreamWriter and StreamReader classes on your own, or you can use one of the helpful shared methods included in the File class, such as CreateText() or OpenText().

Here's an example that gets a StreamWriter for writing data to the file c:myfile.txt:

' Define a StreamWriter (which is designed for writing text files).
Dim w As StreamWriter

' Create the file, and get a StreamWriter for it.
w = File.CreateText("c:myfile.txt")

When you call the CreateText() method, you create the file and receive the StreamWriter object. At this point, the file is open and ready to receive your content. You need to write your data to the file and then close it as soon as possible.

Using the StreamWriter, you can call the WriteLine() method to add information to the file. The WriteLine() method is overloaded so it can write many simple data types, including strings, integers, and other numbers. These values are essentially all converted into strings when they're written to a file and must be converted back into the appropriate types manually when you read the file.

w.WriteLine("This file generated by ASP.NET")   ' Write a string.
w.WriteLine(42)                                 ' Write a number.

When you finish with the file, you must make sure to close it by calling the Close() or Dispose() method. Otherwise, the changes may not be properly written to disk, and the file could be locked open.

w.Close()

Finally, when you're debugging an application that writes to files it's always a good idea to look at what you wrote using a text editor like Notepad. Figure 17-3 shows the contents that are created in c:myfile.txt with the simple code you've considered.

Figure 17.3. A sample text file

To read the information, you use the corresponding StreamReader class. It provides a ReadLine() method that gets the next available value and returns it as a string. ReadLine() starts at the first line and advances the position to the end of the file, one line at a time.

Dim r As StreamReader = File.OpenText("c:myfile.txt")
Dim inputString As String
inputString = r.ReadLine()     ' = "This file generated by ASP.NET"
inputString = r.ReadLine()     ' = "42"

ReadLine() returns a null reference when there is no more data in the file. This means you can read all the data in a file using code like this:

' Read and display the lines from the file until the end
' of the file is reached.
Dim line As String
Do
    line = r.ReadLine()
    If line IsNot Nothing Then
        ' (Process the line here.)
    End If
Loop Until line Is Nothing

As when writing to a file, you must close the file once you're finished:

r.Close()

The code you've seen so far opens a file in single-user mode. If a second user tries to access the same file at the same time, an exception will occur. You can reduce this problem when opening files using the more generic four-parameter version of the File.Open() method instead of File.OpenText(). You must specify FileShare.Read for the final parameter. Unlike the OpenText() method, the Open() method returns a FileStream object, and you must manually create a StreamReader that wraps it.

Here's the code you need to create a multiuser-friendly StreamReader:

Dim fs As FileStream
fs = File.Open("c:myfile.txt", FileMode.Open, _
  FileAccess.Read, FileShare.Read)
Dim r As New StreamReader(fs)

You can also read and write to binary files. Binary data uses space more efficiently but also creates files that aren't human-readable. If you open a file in Notepad, you'll see a lot of extended ASCII characters (politely known as gibberish).

To open a file for binary writing, you need to create a new BinaryWriter object. The constructor accepts a stream, which you can retrieve using the File.OpenWrite() method. Here's the code to open the file c:inaryfile.bin for binary writing:

Dim fs As FileStream = File.OpenWrite("c:inaryfile.bin")
Dim w As New BinaryWriter(fs)

.NET concentrates on stream objects, rather than the source or destination for the data. This means you can write binary data to any type of stream, whether it represents a file or some other type of storage location, using the same code. In addition, writing to a binary file is almost the same as writing to a text file.

Dim str As String = "ASP.NET Binary File Test"
Dim int As Integer = 42
w.Write(str)
w.Write(int)
w.Close()

Reading data from a binary file is easy, but not quite as easy as reading data from a text file. The problem is that you need to know the data type of the data you want to retrieve. To retrieve a string, you use the ReadString() method. To retrieve an integer, you must use ReadInt32(). That's why the preceding code example writes variables instead of literal values. If the value 42 were hard-coded as the parameter for the Write() method, it wouldn't be clear if the value would be written as a 16-bit integer, 32-bit integer, decimal, or something else. Unfortunately, you may need to micromanage binary files in this way to prevent errors.

Dim r As New BinaryReader(File.OpenRead("c:inaryfile.bin"))

Dim str As string
Dim int As Integer
str = r.ReadString()
int = r.ReadInt32()

r.Close()

Once again, if you want to use file sharing, you need to use File.Open() instead of File.OpenRead(). You can then create a BinaryReader by hand, as shown here:

Dim fs As FileStream
fs = File.Open("c:inaryfile.bin", FileMode.Open, _
  FileAccess.Read, FileShare.Read)
Dim r As New BinaryReader(fs)

.NET includes functionality for turbo-charging your file writing and reading. This functionality comes from several shared methods in the File class that let you read or write an entire file in a single line of code.

For example, here's a quick code snippet that writes a three-line file and then retrieves it into a single string:

Dim lines() As String = {"This is the first line of the file.", _
  "This is the second line of the file.", _
  "This is the third line of the file."}

' Write the file in one shot.
File.WriteAllLines("c:	estfile.txt", lines)

' Read the file in one shot (into a variable named content).
Dim content As String = File.ReadAllText("c:	estfile.txt")

Table 17-8 describes the full set of quick file access methods. All of these are shared methods.

The quick file access methods are certainly convenient for creating small files. They also ensure a file is kept only for as short a time as possible, which is always the best approach to minimize concurrency problems. But are they really practical? It all depends on the size of the file. If you have a large file (say, one that's several megabytes), reading the entire content into memory at once is a terrible idea. It's much better to read one piece of data at a time and process the information bit by bit. Even if you're dealing with medium-sized files (say, several hundreds of kilobytes), you might want to steer clear of the quick file access methods. That's because in a popular website you might have multiple requests dealing with files at the same time, and the combined overhead of keeping every user's file data in memory might reduce the performance of your application.

The next example demonstrates the file access techniques described in the previous sections to create a simple guest book. The page actually has two parts. If there are no current guest entries, the client will see only the controls for adding a new entry, as shown in Figure 17-4.

Figure 17.4. The initial guest book page

When the user clicks Submit, a file will be created for the new guest book entry. As long as at least one guest book entry exists, a GridView control will appear at the top of the page, as shown in Figure 17-5.

Figure 17.5. The full guest book page

The GridView that represents the guest book is constructed using data binding, which you explored in Chapters 15 and 16. Technically speaking, the GridView is bound to a collection that contains instances of the BookEntry class. The BookEntry class definition is included in the code-behind file for the web page and looks like this:

Public Class BookEntry
    Private _author As String
    Private _submitted As Date
    Private _message As String

    Public Property Author() As String
        Get
            Return _author
        End Get
        Set(ByVal Value As String)
            _author = Value
        End Set

End Property

    Public Property Submitted() As Date
        Get
            Return _submitted
        End Get
        Set(ByVal Value As Date)
            _submitted = Value
        End Set
    End Property

    Public Property Message() As String
        Get
            Return _message
        End Get
        Set(ByVal Value As String)
            _message = Value
        End Set
    End Property
End Class

The GridView uses a single template column, which fishes out the values it needs to display. Here's what it looks like (without the style details):

<asp:GridView ID="GuestBookList" runat="server" AutoGenerateColumns="False">
  <Columns>
      <asp:TemplateField HeaderText="Guest Book Comments">
        <ItemTemplate>
          Left By:
          <%# Eval("Author") %>
          <br />
          <b><%# Eval("Message") %></b>
          <br />
          Left On:
          <%# Eval("Submitted") %>
      </ItemTemplate>
    </asp:TemplateField>
  </Columns>
</asp:GridView>

It also adds some style information that isn't included here (because it isn't necessary to understand the logic of the program). In fact, these styles were applied in Visual Studio using the GridView's Auto Format feature.

As for the entries, the guest book page uses the subfolder (App_DataGuestBook) to store a collection of files. Each file represents a separate entry in the guest book. By putting the GuestBook folder in the App_Data folder, the web application ensures that the user can't access any of the guest book files directly, because the web server won't allow it. However, an even better approach would usually be to create a GuestBook table in a database and make each entry a separate record.

The code for the web page is as follows:

Public Partial Class GuestBook
    Inherits System.Web.UI.Page

Private guestBookName As String

    Protected Sub Page_Load(ByVal sender As Object, _
      ByVal e As EventArgs) Handles MyBase.Load
        guestBookName = Server.MapPath("~/App_Data/GuestBook")

        If Not Me.IsPostBack Then
            GuestBookList.DataSource = GetAllEntries()
            GuestBookList.DataBind()
        End If
    End Sub

    Protected Sub cmdSubmit_Click(ByVal sender As Object, _
      ByVal e As EventArgs) Handles cmdSubmit.Click
        ' Create a new BookEntry object.
        Dim newEntry As New BookEntry()
        newEntry.Author = txtName.Text
        newEntry.Submitted = DateTime.Now
        newEntry.Message = txtMessage.Text

        ' Let the SaveEntry procedure create the corresponding file.
        Try
            SaveEntry(newEntry)
        Catch err As Exception
            ' An error occurred. Notify the user and don't clear the
            ' display.
            lblError.Text = err.Message & " File not saved."
            Exit Sub
        End Try

        ' Refresh the display.
        GuestBookList.DataSource = GetAllEntries()
        GuestBookList.DataBind()

        txtName.Text = ""
        txtMessage.Text = ""
    End Sub

    Private Function GetAllEntries() As List(Of BookEntry)
        ' Return a collection that contains BookEntry objects
        ' for each file in the GuestBook directory.
        ' This method relies on the GetEntryFromFile method.
        Dim entries As New List(Of BookEntry)()

        Try
            Dim guestBookDir As New DirectoryInfo(guestBookName)

            For Each fileItem As FileInfo In guestBookDir.GetFiles()
                Try
                    entries.Add(GetEntryFromFile(fileItem))
                Catch
                    ' An error occurred when calling GetEntryFromFile().
                    ' Ignore this file because it can't be read.
End Try

Next
        Catch err As Exception
            ' An error occurred when calling GetFiles().
            ' Ignore this error and leave the entries collection empty.
        End Try

        Return entries
    End Function

    Private Function GetEntryFromFile(ByVal entryFile As FileInfo) _
      As BookEntry
        ' Turn the file information into a BookEntry object.
        Dim newEntry As New BookEntry()
        Dim r As StreamReader = entryFile.OpenText()
        newEntry.Author = r.ReadLine()
        newEntry.Submitted = DateTime.Parse(r.ReadLine())
        newEntry.Message = r.ReadLine()
        r.Close()

        return newEntry
    End Function

    Private Sub SaveEntry(ByVal entry As BookEntry)
        ' Create a new file for this entry, with a file name that should
        ' be statistically unique.
        Dim random As New Random()
        Dim fileName As String = guestBookName & ""
        fileName &= DateTime.Now.Ticks.ToString() & random.Next(100).ToString()
        Dim newFile As New FileInfo(fileName)
        Dim w As StreamWriter = newFile.CreateText()

        ' Write the information to the file.
        w.WriteLine(entry.Author)
        w.WriteLine(entry.Submitted.ToString())
        w.WriteLine(entry.Message)
        w.Close()
    End Sub

End Class

Fortunately, ASP.NET includes a control that allows website users to upload files to the web server. Once the web server receives the posted file data, it's up to your application to examine it, ignore it, or save it to a back-end database or a file on the web server. The FileUpload control does this work, and it represents the <input type="file"> HTML tag.

Declaring the FileUpload control is easy. It doesn't expose any new properties or events you can use through the control tag:

<asp:FileUpload ID="Uploader" runat="server" />

The <input type="file"> tag doesn't give you much choice as far as user interface is concerned (it's limited to a text box that contains a file name and a Browse button). When the user clicks Browse, the browser presents an Open dialog box and allows the user to choose a file. This part is hardwired into the browser, and you can't change this behavior. Once the user selects a file, the file name is filled into the corresponding text box. However, the file isn't uploaded yet—that happens later, when the page is posted back. At this point, all the data from all input controls (including the file data) is sent to the server. For that reason, it's common to add a button to post back the page.

To get information about the posted file content, you can access the FileUpload.PostedFile object. You can save the content by calling the PostedFile.SaveAs() method:

Uploader.PostedFile.SaveAs("c:Uploads
ewfile")

Figure 17-6 shows a complete web page that demonstrates how to upload a user-specified file. This example introduces a twist—it allows the upload of only those files with the extensions .bmp, .gif, and .jpg.

Figure 17.6. A simple file uploader

Here's the code for the upload page:

Public Partial Class UploadFile
    Inherits System.Web.UI.Page

    Private uploadDirectory As String

    Protected Sub Page_Load(ByVal sender As Object, _
      ByVal e As EventArgs)  Handles Me.Load

        ' Place files in a website subfolder named Uploads.
        uploadDirectory = Path.Combine( _
          Request.PhysicalApplicationPath, "Uploads")
    End Sub

Protected Sub cmdUpload_Click(ByVal sender As Object, _
      ByVal e As System.EventArgs) Handles cmdUpload.Click

        ' Check that a file is actually being submitted.
        If Uploader.PostedFile.FileName = "" Then
            lblInfo.Text = "No file specified."
        Else
            ' Check the extension.
            Dim extension As String = _
              Path.GetExtension(Uploader.PostedFile.FileName)

            Select Case extension.ToLower()
                Case ".bmp", ".gif", ".jpg"
                    ' This is an allowed file type.
                Case Else
                    lblInfo.Text = "This file type is not allowed."
                    Return
            End Select

            ' Using this code, the saved file will retain its original
            ' file name when it's placed on the server.
            Dim serverFileName As String = _
              Path.GetFileName(Uploader.PostedFile.FileName)
            Dim fullUploadPath As String = _
              Path.Combine(uploadDirectory, serverFileName)

            Try
                Uploader.PostedFile.SaveAs(fullUploadPath)

                lblInfo.Text = "File " & serverFileName
                lblInfo.Text &= " uploaded successfully to "
                lblInfo.Text &= fullUploadPath
            Catch Err As Exception
                lblInfo.Text = err.Message
            End Try
        End If

    End Sub

End Class

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.web>
    <!-- Other settings omitted for clarity. -->
    <httpRuntime maxRequestLength="8192" />
  </system.web>
</configuration>