Home

Introduction to File Processing

 

Overview of File Processing and Definitions

 

Introduction

In Lesson 2, we saw that a piece of information used in an application was primarily represented as a group of bits. So far, if we requested information from the user, when the application exited, we lost all information that the user had entered. This is because such information was only temporarily stored in the random access memory (RAM). In some cases, you will want to "keep" information that the user has entered so you can make the information available the next time the user opens the application. In some other cases, whether you request information from the user or inherently provide it to the user, you may want different people working from different computers to use or share the same data. In these and other scenarios, you must store the information somewhere and retrieve it when necessary. This is the basis of file processing.

Files

A file is a series of bytes of data that are arranged in a particular manner to produce a usable document. For easy storage, location, and management, the bytes are stored on a medium such as a hard disc, a floppy disc, a compact disc, or any valid and supported type of storage. When these bytes belong to a single but common entity and hold values that are stored on a medium, the group is referred to as a file.

For greater management, files can be stored in a parent object called a directory or a folder. Since a file is a unit of storage and it stores information, it has a size, which is the number of bits it uses to store its values. To manage it, a file has a location also called a path that specifies where and/or how the file can be retrieved. Also, for better management, a file has attributes (characteristics) that indicate what can be done on the file or that provide specific information that the programmer or the operating system can use when dealing with the file.

Streams

File processing consists of creating, storing, and/or retrieving the contents of a file from a recognizable medium. For example, it is used to save word-processed files to a hard drive, to store a presentation on floppy disk, or to open a file from a CD-ROM. A stream is the technique or means of performing file processing. In order to manage files stored in a computer, each file must be able to provide basic pieces of information about itself. This basic information is specified when the file is created but can change during the lifetime of a file.

To create a file, a user must first decide where it would be located: this is a requirement. A file can be located on the root drive. Alternatively, a file can be positioned inside of an existing folder. Based on security settings, a user may not be able to create a file just anywhere in the (file system of the) computer. Once the user has decided where the file would reside, there are various means of creating files that the users are trained to use. When creating a file, the user must give it a name following the rules of the operating system combined with those of the file system. The most fundamental piece of information a file must have is a name.

Once the user has created a file, whether the file is empty or not, the operating system assigns basic pieces of information to it. Once a file is created, it can be opened, updated, modified, renamed, etc.

Streaming Prerequisites

 

Introduction

To support file processing, the .NET Framework provides the System.IO namespace that contains many different classes to handle almost any type of file operation you may need to perform. Therefore, to perform file processing, you can include the System.IO namespace in your project.

The parent class of file processing is Stream. With Stream, you can store data to a stream or you can retrieve data from a stream. Stream is an abstract class, which means that you cannot use it to declare a variable in your application. As an abstract class, Stream is used as the parent of the classes that actually implement the necessary operations. You will usually use a combination of classes to perform a typical operation. For example, some classes are used to create a stream object while some others are used to write data to the created stream.

Practical LearningPractical Learning: Introducing Streaming

  1. Start Microsoft Visual C# and create a Console Application named IceCream3
  2. To save the project, on the Standard toolbar, click the Save All button Save All
  3. Change the Solution Name to VendingMachine3
  4. Accept the Name of the project as IceCream3 and click Save
  5. To create a new class, on the main menu, click Project -> Add Class...
  6. Set the Name to IceCream and click Add
  7. Change the file as follows:
    using System;
    
    namespace IceCream3
    {
        delegate void Request();
    
        // This class is used to create and manage an Ice Cream
        // and to process an order
        public sealed class IceCream
        {
            // This is the base price of an Ice Cream
            // Optional values may be added to it
            public const decimal BasePrice = 1.55M;
    
            // These arrays are used to build the components 
            // of various Ice Creams
            // In C#, we can allocate an array's memory in 
            // the body of the class
            private string[] Flavor;
            private string[] Container;
            private string[] Ingredient;
    
            // Additional factor used to process an Ice Cream order
            private int Scoops;
            private decimal 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 IceCream()
            {
                Flavor = new string[10];
                Flavor[0] = "Vanilla";
                Flavor[1] = "Cream of Cocoa";
                Flavor[2] = "Chocolate Chip";
                Flavor[3] = "Organic Strawberry";
                Flavor[4] = "Butter Pecan";
                Flavor[5] = "Cherry Coke";
                Flavor[6] = "Chocolate Brownies";
                Flavor[7] = "Caramel Au Lait";
                Flavor[8] = "Chunky Butter";
                Flavor[9] = "Chocolate Cookie";
    
                Ingredient = new string[4];
                Ingredient[0] = "No Ingredient";
                Ingredient[1] = "Peanuts";
                Ingredient[2] = "M & M";
                Ingredient[3] = "Cookies";
    
                Container = new string[3];
                Container[0] = "Cone";
                Container[1] = "Cup";
                Container[2] = "Bowl";
            }
    
            // This method requests a flavor from the user and
            // returns the choice
            public void ChooseFlavor()
            {
                // 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("What type of flavor do you want?");
                        for (int i = 0; i < Flavor.Length; i++)
                            Console.WriteLine("{0} - {1}", i + 1, Flavor[i]);
                        Console.Write("Your Choice? ");
                        ChoiceFlavor = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)	// display an appropriate message
                    {
                        Console.WriteLine("You must enter a valid 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 (ChoiceFlavor < 1 || ChoiceFlavor > Flavor.Length)
                        Console.WriteLine("Invalid Choice - Try Again!\n");
                } while (ChoiceFlavor < 1 || ChoiceFlavor > Flavor.Length);
            }
    
            // This method allows the user to select a container
            public void ChooseContainer()
            {
                // 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("What type of container do you want?");
                        for (int i = 0; i < Container.Length; i++)
                            Console.WriteLine("{0} - {1}", i + 1, Container[i]);
                        Console.Write("Your Choice? ");
                        ChoiceContainer = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)	// display an appropriate message
                    {
                        Console.WriteLine("You must enter a valid " +
                                          "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("Invalid Choice - Try Again!");
                } while ((ChoiceContainer < 1) ||
                         (ChoiceContainer > Container.Length));
            }
    
            public void ChooseIngredient()
            {
                do
                {
                    try
                    {
                        Console.WriteLine("Do you want an ingredient or not");
                        for (int i = 0; i < Ingredient.Length; i++)
                            Console.WriteLine("{0} - {1}",
                                              i + 1,
                                              Ingredient[i]);
                        Console.Write("Your Choice? ");
                        ChoiceIngredient = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("You must enter a valid " +
                                          "number and no other character!");
                    }
    
                    if ((ChoiceIngredient < 1) ||
                        (ChoiceIngredient > Ingredient.Length))
                        Console.WriteLine("Invalid Choice - Try Again!");
                } while ((ChoiceIngredient < 1) ||
                         (ChoiceIngredient > Ingredient.Length));
            }
    
            public void SpecifyNumberOfScoops()
            {
                do
                {
                    try
                    {
                        Console.Write("How many scoops(1, 2, or 3)? ");
                        Scoops = int.Parse(Console.ReadLine());
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("You must enter a valid number " +
                                          "and no other character!");
                    }
    
                    if (Scoops < 1 || Scoops > 3)
                        Console.WriteLine("Invalid Choice - Try Again!");
                } while (Scoops < 1 || Scoops > 3);
            }
    
            // This method is used to process a customer order
            // It uses the values of the above methods
            public void ProcessAnOrder()
            {
                //			int ChoiceFlavor;
                //			int ChoiceContainer;
                //			int ChoiceIngredient;
                decimal PriceIngredient, PriceScoop;
    
                // Let the user know that this is a vending machine
                Console.WriteLine("=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=");
                Console.WriteLine("Ice Cream Vending Machine");
                Console.WriteLine("-----------------------------------");
    
                // Let the user select the components of the Ice Cream
                Request Get = new Request(ChooseFlavor);
                Get();
                Console.WriteLine("-----------------------------------");
                Get = new Request(ChooseContainer);
                Get();
                Console.WriteLine("-----------------------------------");
                Get = new Request(ChooseIngredient);
                Get();
                Console.WriteLine("-----------------------------------");
                Get = new Request(SpecifyNumberOfScoops);
                Get();
                Console.WriteLine("-----------------------------------");
    
                // If the user selects an ingredient instead of "No Ingredient",
                // add $0.50 to the order
                if ((ChoiceIngredient == 2) ||
                    (ChoiceIngredient == 3) ||
                    (ChoiceIngredient == 4))
                    PriceIngredient = 0.50M;
                else
                    PriceIngredient = 0.00M;
    
                // Instead of multiplying a number scoops to a value,
                // We will use an incremental value depending on 
                // the number of scoops
                if (Scoops == 1)
                    PriceScoop = 0.65M;
                else if (Scoops == 2)
                    PriceScoop = 1.05M;
                else
                    PriceScoop = 1.55M;
    
                // Calculate the total price of the Ice Cream
                TotalPrice = BasePrice + PriceScoop + PriceIngredient;
    
                // Create the Ice Cream...
    
                // And display a receipt to the user
                DisplayReceipt();
            }
    
            // This method is used to display a receipt to the user
            public void DisplayReceipt()
            {
                Console.WriteLine("\n=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=");
                Console.WriteLine("Ice Cream Order");
                Console.WriteLine("-----------------------------------");
                Console.WriteLine("Flavor:      {0}",
                                  Flavor[ChoiceFlavor - 1]);
                Console.WriteLine("Container:   {0}",
                                  Container[ChoiceContainer - 1]);
                Console.WriteLine("Ingredient:  {0}",
                                  Ingredient[ChoiceIngredient - 1]);
                Console.WriteLine("Scoops:      {0}", Scoops);
                Console.WriteLine("Total Price: {0:C}", TotalPrice);
                Console.WriteLine("=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=\n");
            }
        }
    }
  8. Access the Program.cs file and change it as follows:
    using System;
    
    namespace IceCream3
    {
        class Program
        {
            static int Main(string[] args)
            {
                IceCream ic = new IceCream();
                Request process = new Request(ic.ProcessAnOrder);
    
                process();
                return 0;
            }
        }
    }
  9. Execute the project and test it. Here is an example:
    =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
    Ice Cream Vending Machine
    -----------------------------------
    What type of flavor do you want?
    1 - Vanilla
    2 - Cream of Cocoa
    3 - Chocolate Chip
    4 - Organic Strawberry
    5 - Butter Pecan
    6 - Cherry Coke
    7 - Chocolate Brownies
    8 - Caramel Au Lait
    9 - Chunky Butter
    10 - Chocolate Cookie
    Your Choice? 3
    -----------------------------------
    What type of container do you want?
    1 - Cone
    2 - Cup
    3 - Bowl
    Your Choice? 5
    Invalid Choice - Try Again!
    What type of container do you want?
    1 - Cone
    2 - Cup
    3 - Bowl
    Your Choice? 3
    -----------------------------------
    Do you want an ingredient or not
    1 - No Ingredient
    2 - Peanuts
    3 - M & M
    4 - Cookies
    Your Choice? 8
    Invalid Choice - Try Again!
    Do you want an ingredient or not
    1 - No Ingredient
    2 - Peanuts
    3 - M & M
    4 - Cookies
    Your Choice? 4
    -----------------------------------
    How many scoops(1, 2, or 3)? 3
    -----------------------------------
    
    =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
    Ice Cream Order
    -----------------------------------
    Flavor:      Chocolate Chip
    Container:   Bowl
    Ingredient:  Cookies
    Scoops:      3
    Total Price: $3.60
    =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
    
    Press any key to continue . . .
  10. Close the DOS window

The Name of a File

Before performing file processing, one of your early decisions will consist of specifying the type of operation you want the user to perform. For example, the user may want to create a brand new file, open an existing file, or perform a routine operation on a file. In all or most cases, whether you are creating a new file or manipulating an existing one, you must specify the name of the file. You can do this by declaring a string variable but, as we will learn later on, most classes used to create a stream can take a string that represents the file.

If you are creating a new file, there are certainly some rules you must observe. The name of a file follows the directives of the operating system. On MS DOS and Windows 3.X (that is, prior to Microsoft Windows 9X), the file had to use the 8.3 format. The actual name had to have a maximum of 8 characters with restrictions on the characters that could be used. The user also had to specify three characters after a period. The three characters, known as the file extension, were used by the operating system to classify the file. That was all necessary for those 8-bit and 16-bit operating systems. Various rules have changed. For example, the names of folders and files on Microsoft Windows >= 95 can have up to 255 characters. The extension of the file is mostly left to the judgment of the programmer but the files are still using extensions. Applications can also be configured to save different types of files; that is, files with different extensions.

Author Note At the time of this writing, the rules for file names for Microsoft Windows were on the MSDN web site at Windows Development\Windows Base Services\Files and I/O\SDK Documentation\Storage\Storage Overview\File Management\Creating, Deleting, and Maintaining Files\Naming a File (because it is a web site and not a book, its pages can change anytime).

Based on this, if you declare a string variable to hold the name of the file, you can simply initialize the variable with the necessary name and its extension. Here is an example:

using System;

class Exercise
{
    static int Main()
    {
	string NameOfFile = "Employees.spr";

	return 0;
    }
}

Practical LearningPractical Learning: Specifying the Name of a File

  1. Access the IceCream.cs file and add a new public method named SaveOrder of type void as follows:
     
    using System;
    
    namespace IceCream3
    {
        // This class is used to create and manage an Ice Cream
        // and to process an order
        public sealed class IceCream
        {
    
            . . . No Change
    
            // This method is used to display a receipt to the user
            public void DisplayReceipt()
            {
                . . . No Change
            }
    
            public void SaveOrder()
            {
                string NameOfFile;
    
                Console.Write("Please enter your initials or the " +
    			  "name we will use to remember your order: ");
                NameOfFile = Console.ReadLine();
            }
        }
    }using System;
    
    namespace IceCream3
    {
        delegate void Request();
    
        // This class is used to create and manage an Ice Cream
        // and to process an order
        public sealed class IceCream
        {
            . . . No Change
    
            // This method is used to display a receipt to the user
            public void DisplayReceipt()
            {
                . . . No Change
            }
    
            public void SaveOrder()
            {
                string NameOfFile;
    
                Console.Write("Please enter your initials or the " +
                  "name we will use to remember your order: ");
                NameOfFile = Console.ReadLine();
            }
        }
    }
    
  2. Access the Program.cs file and change it as follows:
     
    using System;
    
    namespace IceCream3
    {
        class Program
        {
            static int Main(string[] args)
            {
                char answer = 'n';
                IceCream ic = new IceCream();
                Request process = new Request(ic.ProcessAnOrder);
    
                process();
    
                Console.Write("Do you want us to remember this " +
                              "order the next time you come to " +
                              "get your Ice Cream (y/n)? ");
                answer = char.Parse(Console.ReadLine());
    
                if (answer == 'y' || answer == 'Y')
                    ic.SaveOrder();
    
                return 0;
            }
        }
    }
  3. Execute the project and test it
  4. Close the DOS window

The Path to a File

If you declare a string as above, the file will be created in the folder as the application. Otherwise, you can create your new file anywhere in the hard drive or on another medium. To do that, you must provide a complete path where the file will reside. A path is a string that specifies the drive (such as A:, C:, or D:, etc). The sections of a complete path are separated by a backslash. For example, a path can be made of a folder followed by the name of the file. An example would be

C:\Palermo.tde 

A path can also consist of a drive followed by the name of the folder in which the file will be created. Here is an example:

C:\Program Files\Palermo.tde

A path can also indicate that the file will be created in a folder that itself is inside of another folder. In this case, remember that the names of folders must be separated by backslashes.

In Lesson 2, we saw that the backslash character is used to create or manage escape sequences and it can be included in a string value to make up an escape sequence. Because of this, every time you include a backslash in a string, the compiler thinks that you are trying to provide an escape sequence. In this case, if the combination of the backslash and the character that follows the backslash is not recognized as an escape sequence, you would get an error. To solve this problem, you have two alternatives. To indicate that the backslash must be considered as a character in its own right, you can double it. Here are examples:

using System;

class Exercise
{
    static int Main()
    {
	string NameOfFile = "C:\\Documents and " +
			    "Settings\\Business Records\\Employees.spr";

	return 0;
    }
}

Alternative, you can keep one backslash in each placeholder but precede the value of the string with the @ symbol. Here is an example:

using System;

class Exercise
{
	static int Main()
	{
		string NameOfFile = @"C:\Documents and " +
				     "Settings\Business Records\Employees.spr";

		return 0;
	}
}

In the same way, you can declare a string variable to represent the name of an existing file that you plan to use in your program. You can also represent its path.

When providing a path to the file, if the drive you specify doesn't exist or cannot be read, the compiler would consider that the file doesn't exist. If you provide folders that don't exist in the drive, the compiler would consider that the file doesn't exist. This also means that the compiler will not create the folder(s) (the .NET Framework provides all means to create a folder but you must ask the compiler to create it; simply specifying a folder that doesn't exist will not automatically create it, even if you are creating a new file). Therefore, it is your responsibility to make sure that either the file or the path to the file is valid. As we will see in the next section, the compiler can check the existence of a file or path.

 

Home Copyright © 2006 FunctionX, Inc. Next