29: Details on File Processing

Exception Handling in File Processing

Finally

So far, to handle exceptions, we were using the try, catch, and throw keywords. These allowed us to perform normal assignments in a try section and then handle an exception, if any, in a catch block. We also mentioned that, when you create a stream, the operating system must allocate resources and dedicate them to the file processing operations. Additional resources may be provided for the object that is in charge of writing to, or reading from, the stream. We also saw that, when the streaming was over, we should free the resources and give them back to the operating system. To do this, we called the Close() method of the variable that was using resources.

More than any other assignment, file processing is in prime need of exception handling. During file processing, there are many things that can go wrong. For this reason, the creation and/or management of streams should be performed in a try block to get ready to handle exceptions that would occur. Besides actually handling exceptions, you can use the finally keyword to free resources.

The finally keyword is used to create a section of an exception. Like catch, a finally block cannot exist by itself. It can be created following a try section. The formula used would be:

try
{
}
finally
{
}

Based on this:

The finally section has a body of its own, delimited by its curly brackets
Like catch, the finally section is created after the try section
Unlike catch, finally never has parentheses and never takes arguments
Unlike catch, the finally section is always executed

Because the finally clause always gets executed, you can include any type of code in it but it is usually appropriate to free the resources that were allocated such as those used during streaming. Here is an example:

using namespace System;
using namespace System::IO;

int main()
{
    String ^ NameOfFile = L"Members.clb";
	
    FileStream ^ fstPersons = gcnew FileStream(NameOfFile, FileMode::Create);
    BinaryWriter ^ wrtPersons = gcnew BinaryWriter(fstPersons);
        
    try 
    {
        wrtPersons->Write(L"James Bloch");
        wrtPersons->Write(L"Catherina Wallace");
        wrtPersons->Write(L"Bruce Lamont");
        wrtPersons->Write(L"Douglas Truth");
    }
    finally
    {
        wrtPersons->Close();
        fstPersons->Close();
    }

    return 0;
}

In the same way, you can use a finally section to free resources used when reading from a stream:

using namespace System;
using namespace System::IO;

int main()
{
/*    String ^ NameOfFile = L"Members.clb";
	
    FileStream ^ fstPersons = gcnew FileStream(NameOfFile, FileMode::Create);
    BinaryWriter ^ wrtPersons = gcnew BinaryWriter(fstPersons);
        
    try 
    {
        wrtPersons->Write(L"James Bloch");
        wrtPersons->Write(L"Catherina Wallace");
        wrtPersons->Write(L"Bruce Lamont");
        wrtPersons->Write(L"Douglas Truth");
    }
    finally
    {
        wrtPersons->Close();
        fstPersons->Close();
    }*/

	String ^ NameOfFile = L"Members.clb";
    String ^ strLine = nullptr;
        
    FileStream ^ fstMembers = gcnew FileStream(NameOfFile, FileMode::Open);
    BinaryReader ^ rdrMembers = gcnew BinaryReader(fstMembers);

    try
    {
        strLine = rdrMembers->ReadString();
        Console::WriteLine(strLine);
        strLine = rdrMembers->ReadString();
        Console::WriteLine(strLine);
        strLine = rdrMembers->ReadString();
        Console::WriteLine(strLine);
        strLine = rdrMembers->ReadString();
        Console::WriteLine(strLine);
    }
    finally
    {
        rdrMembers->Close();
        fstMembers->Close();
    }

    return 0;
}

Of course, since the whole block of code starts with a try section, it is used for exception handling. This means that you can add the necessary and appropriate catch section(s) but you don't have to.

Practical Learning: Finally Releasing Resources

Start Microsoft Visual C++ and create a CLR Console Application named IceCream4
To create a new class, on the main menu, click Project -> Add Class...
In the Add Class dialog box, in the Templates list, click C++ Class and click Add
Set the Name to CIceCream
Make sure the Managed check box is selected and click Finish

Change the file as follows:

#pragma once

using namespace System;
using namespace System::IO;

public ref class CIceCream sealed
{
    // This is the base price of an ice scream
    // Optional values may be added to it
public:
    static const double BasePrice = 1.55;

    // These arrays are used to build the components 
    // of various ice creams
private:
    array<String ^> ^ Flavor;
    array<String ^> ^ Container;
    array<String ^> ^ Ingredient;

    // Additional factor used to process an ice scream order
    int Scoops;
    double TotalPrice;

    // Variables that will hold the user's choice
    // These are declared "globally" so they can be 
    // shared among methods
    int ChoiceFlavor;
    int ChoiceContainer;
    int ChoiceIngredient;

    // This default constructor is the best place for 
    // us to initialize the array
public:
    CIceCream(void);
};

Access the IceCream.cpp file and change the constructor as follows:

#include "StdAfx.h"
#include "IceScream.h"

CIceCream::CIceCream(void)
{
        Flavor = gcnew array<String ^>(10);
        Flavor[0] = L"Vanilla";
        Flavor[1] = L"Cream of Cocoa";
        Flavor[2] = L"Chocolate Chip";
        Flavor[3] = L"Organic Strawberry";
        Flavor[4] = L"Butter Pecan";
        Flavor[5] = L"Cherry Coke";
        Flavor[6] = L"Chocolate Brownies";
        Flavor[7] = L"Caramel Au Lait";
        Flavor[8] = L"Chunky Butter";
        Flavor[9] = L"Chocolate Cookie";

        Ingredient = gcnew array<String^>(4);
        Ingredient[0] = L"No Ingredient";
        Ingredient[1] = L"Peanuts";
        Ingredient[2] = L"M & M";
        Ingredient[3] = L"Cookies";

        Container = gcnew array<String^>(3);
        Container[0] = L"Cone";
        Container[1] = L"Cup";
        Container[2] = L"Bowl";
}

In the Class View, right-click CIceCream -> Add -> Add Function
Set the Return Type to void
Set the Function Name to ChooseFlavor and click Finish

In the IceCream.cpp source file, implement the ChooseFlavor method as follows:

// This method requests a flavor from the user and
// returns the choice
void CIceCream::ChooseFlavor(void)
{
    // Make sure the user selects a valid number 
    //that represents a flavor...
    do {
        // In case the user types a symbol that 
        // is not a number
        try {
            Console::WriteLine(L"What type of flavor do you want?");
            for (int i = 0; i < Flavor->Length; i++)
                Console::WriteLine(L"{0} - {1}", i + 1, Flavor[i]);
            Console::Write(L"Your Choice? ");
	    ChoiceFlavor = int::Parse(Console::ReadLine());
        }
        catch(FormatException ^) // display an appropriate message
        {
            Console::WriteLine(L"You must enter a valid number "
                               L"and no other character!");
        }

        // If the user typed an invalid number out of the 
        // allowed range
        // let him or her know and provide another chance
        if( (ChoiceFlavor < 1) || (ChoiceFlavor > Flavor->Length) )
            Console::WriteLine(L"Invalid Choice - Try Again!\n");
    } while (ChoiceFlavor < 1 || ChoiceFlavor > Flavor->Length);
}

In the Class View, right-click CIceCream -> Add -> Add Function
Set the Return Type to void
Set the Function Name to ChooseContainer and click Finish

In the IceCream.cpp source file, implement the ChooseContainer method as follows:

void CIceCream::ChooseContainer(void)
{
    // Make sure the user selects a valid number that 
    // represents a container
    do {
        // If the user types a symbol that is not a number
        try {
            Console::WriteLine(L"What type of container do you want?");
            for (int i = 0; i < Container->Length; i++)
                 Console::WriteLine(L"{0} - {1}", i + 1, Container[i]);
            Console::Write(L"Your Choice? ");
	    ChoiceContainer = int::Parse(Console::ReadLine());
        }
        catch(FormatException ^) // display an appropriate message
        {
            Console::WriteLine(L"You must enter a valid "
                               L"number and no other character!");
        }

        // If the user typed an invalid number out of the 
        // allowed range
        // let him or her know and provide another chance
        if( (ChoiceContainer < 1) ||
            (ChoiceContainer > Container->Length) )
            Console::WriteLine(L"Invalid Choice - Try Again!");
    } while( (ChoiceContainer < 1) ||
             (ChoiceContainer > Container->Length) );
}