Arrays, Files and Exceptions in C#

7. Arrays, Files and Exceptions in C# C# makes handling arrays and files extremely easy and introduces exceptions to simplify error handling. Arrays In C#, all arrays are zero based. If you declare an array as int[] x = new int[10]; such arrays have 10 elements, numbered from 0 to 9. Thus, arrays are in line with the style used in C, C++ and Java. const int MAX = 10; float[] xy = new float[MAX]; for (int i = 0; i < MAX; i++ ) { xy[i] = i; } You should get into the habit of looping through arrays to the array bounds minus one as we did in the above example. All array variables have a length property so you can find out how large the array is: float[] z = new float[20]; for (int j = 0; j< z.Length ; j++) { z[j] = j; } Arrays in C# are dynamic and space can be reallocated at any time. To create a reference to an array and allocate it later within the class, use the syntax: float z[]; //declare here z = new float[20]; //create later Collection Objects The System.Collections namespace contains a number of useful variable length array objects you can use to add and obtain items in several ways. ArrayLists The ArrayList object is essentially a variable length array that you can add items to as needed. The basic ArrayList methods allow you to add elements to the array and fetch and change individual elements: float[] z = {1.0f, 2.9f, 5.6f}; ArrayList arl = new ArrayList (); for (int j = 0; j< z.Length ; j++) { arl.Add (z[j]); } The ArrayList has a Count property you can use to find out how many elements it contains. You can then move from 0 to that count minus one to access these elements, treating the ArrayList just as if it were an array: for (j = 0; j < arl.Count ; j++) { Console.WriteLine (arl[j]); } You can also access the members of ArrayList object sequentially using the foreach looping construct without needing to create an index variable or know the length of the ArrayList: foreach (float a in arl) { Console.WriteLine (a); } You can also use the methods of the ArrayList shown in Table 7-1. Clear Clears the contents of the ArrayList Contains(object) Returns true if the ArrayList contains that value CopyTo(array) Copies entire ArrayList into a one-dimensional array. IndexOf(object) Returns the first index of the value Insert(index, object) Insert the element at the specified index. Remove(object) Remove element from list. RemoveAt(index) Remove element from specified position Sort Sort ArrayList Table 7-1- ArrayList methods An object fetched from an ArrayList is always of type object. This means you usually need to cast the object to the correct type before using it: float x = (float) arl[j]; Hashtables A Hashtable is a variable length array where every entry can be referred to by a key value. Typically, keys are strings of some sort, but they can be any sort of object. Each element must have a unique key, although the elements themselves need not be unique. Hashtables are used to allow rapid access to one of a large and unsorted set of entries, and can also be used by reversing the key and the entry values to create a list where each entry is guaranteed to be unique. Hashtable hash = new Hashtable (); float freddy = 12.3f; hash.Add ("fred", freddy); //add to table //get this one back out float temp = (float)hash["fred"]; Note that like the ArrayList, we must cast the values we obtain from a Hashtable to the correct type. Hashtables also have a count property and you can obtain an enumeration of the keys or of the values. SortedLists The SortedList class maintains two internal arrays, so you can obtain the elements either by zero-based index or by alphabetic key. float sammy = 44.55f; SortedList slist = new SortedList (); slist.Add ("fred", freddy); slist.Add ("sam", sammy); //get by index float newFred = (float)slist.GetByIndex (0); //get by key float newSam = (float)slist["sam"]; You will also find the Stack and Queue objects in this namespace. They behave much as you’d expect, and you can find their methods in the system help documentation. Exceptions Error handling in C# is accomplished using exceptions instead of other more awkward kinds of error checking. The thrust of exception handling is that you enclose the statements that could cause errors in a try block and then catch any errors using a catch statement. try { //Statements } catch (Exception e) { //do these if an error occurs } finally { //do these anyway } Typically, you use this approach to test for errors around file handling statements, although you can also catch array index out of range statements and a large number of other error conditions. The way this works is that the statements in the try block are executed and if there is no error, control passes to the finally statements if any, and then on out of the block. If errors occur, control passes to the catch statement, where you can handle the errors, and then control passes on to the finally statements and then on out of the block. The following example shows testing for any exception. Since we are moving one element beyond the end of the ArrayList, an error will occur: try { //note- one too many for(int i = 0; i <= arl.Count ; i++) Console.WriteLine (arl[i]); } catch(Exception e) { Console.WriteLine (e.Message ); } This code prints out the error message and the calling locations in the program and then goes on. 0123456789Index was out of range. Must be non-negative and less than the size of the collection. Parameter name: index at System.Collections.ArrayList.get_Item(Int32 index) at arr.Form1..ctor() in form1.cs:line 58 By contrast, if we do not catch the exception, we will get an error message from the runtime system and the program will exit instead of going on. Some of the more common exceptions are shown in Table 6-2. AccessException Error in accessing a method or field of a class. ArgumentException Argument to a method is not valid. ArgumentNullException Argument is null ArithmeticException Overflow or underflow DivideByZeroException Division by zero IndexOutOfRangeException Array index out of range FileNotFoundException File not found EndOfStreamException Access beyond end of input stream (such as files) DirectoryNotFoundException Directory not found NullReferenceException The object variable has not been initialized to a real value. Multiple Exceptions You can also catch a series of exceptions and handle them differently in a series of catch blocks. try { for(int i =0; i<= arl.Count ; i++) { int k = (int)(float)arl[i]; Console.Write(i + " "+ k / i); } } catch(DivideByZeroException e) { printZErr(e); } catch(IndexOutOfRangeException e) { printOErr(e); } catch(Exception e) { printErr(e); } This gives you the opportunity to recover from various errors in different ways. Throwing Exceptions You don’t ha ve to deal with exceptions exactly where they occur: you can pass them back to the calling program using the Throw statement. This causes the exception to be thrown in the calling program: try { //statements } catch(Exception e) { throw(e); //pass on to calling program } Note that C# does not support the Java syntax throws , that allows you to declare that a method will throw an exception and that you therefore must provide an exception handler for it. File Handling The file handling objects in C# provide you with some fairly flexible methods of handling files. The File Object The File object represents a file, and has useful methods for testing for a file’s existence as well as renaming and deleting a file. All of its methods are static, which means that you do not ( and cannot) create an instance of File using the new operator. Instead, you use its methods directly. if (File.Exists ("Foo.txt")) File.Delete ("foo.txt"); You can also use the File object to obtain a FileStream for reading and writing file data: //open text file for reading StreamReader ts = File.OpenText ("foo1.txt"); //open any type of file for reading FileStream fs = File.OpenRead ("foo2.any"); Some of the more useful File methods are shown in the table below: Static method Meaning File.FileExists(filename) true if file exists File.Delete(filename) File.AppendText(String) File.Copy(fromFile, toFile) File.Move(fromTile, toFile) Delete the file Append text Copy a file Move a file, deleting old copy Return file extension true if file has an extension. File.GetExtension(filename) File.HasExtension(filename) Reading Text File To read a text file, use the File object to obtain a StreamReader object. Then use the text stream’s read methods: StreamReader ts = File.OpenText ("foo1.txt"); String s =ts.ReadLine (); Writing a Text File To create and write a text file, use the CreateText method to get a StreamWriter object. //open for writing StreamWriter sw = File.CreateText ("foo3.txt"); sw.WriteLine ("Hello file"); If you want to append to an existing file, you can create a StreamWriter object directly with the Boolean argument for append set to true: //append to text file StreamWriter asw = new StreamWriter ("foo1.txt", true); Exceptions in File Handling A large number of the most commonly occurring exceptions occur in handling file input and output. You can get exceptions for illegal filenames, files that do not exist, directories that do not exist, illegal filename arguments and file protection errors. Thus, the best way to handle file input and output is to enclose file manipulation code in Try blocks to assure yourself that all possible error conditions are caught, and thus prevent embarrassing fatal errors. All of the methods of the various file classes show in their documentation which methods they throw. You can assure yourself that you catch all of them by just catching the general Exception object, but if you need to take different actions for different exceptions, you can test for them separately. For example, you might open text files in the following manner: try { //open text file for reading StreamReader ts = File.OpenText ("foo1.txt"); String s =ts.ReadLine (); } catch(Exception e ) { Console.WriteLine (e.Message ); } Testing for End of File There are two useful ways of making sure that you do not pass the end of a text file: looking for a null exception and looking for the end of a data stream. When you read beyond then end of a text file, no error occurs and no end of file exception is thrown. However, if you read a string after the end of a file, it will return as a null value. You can use this to create an end-of-file function in a file reading class: private StreamReader rf; private bool eof; //-----------public String readLine () { String s = rf.ReadLine (); if(s == null) eof = true; return s; } //-----------public bool fEof() { return eof; } The other way for making sure you don’t read past then end of a file is to peek ahead using the Stream’s Peek method. This returns the ASCII code for the next character, or a –1 if no characters remain. public String read_Line() { String s = "" if (rf.Peek() > 0) { s = rf.ReadLine (); } else eof=true; return s; } A csFile Class It is sometimes convenient to wrap these file methods in a simpler class with easy to use methods. We have done that here in the csFile class. We’ll be using this convenience class in some of the examples in later chapters. Ee can include the filename and path in the constructor or we can pass it in using the overloaded OpenForRead and OpenForWrite statements. public class csFile { private string fileName; StreamReader ts; StreamWriter ws; private bool opened, writeOpened; //----------public csFile() { init(); } //----------private void init() { opened = false; writeOpened = false; } //----------public csFile(string file_name) { fileName = file_name; init(); } We can open a file for reading using either of two methods, once including the filename and one which uses a filename in the argument. public bool OpenForRead(string file_name){ fileName = file_name; try { ts = new StreamReader (fileName); opened=true; } catch(FileNotFoundException e) { return false; } return true; } //----------public bool OpenForRead() { return OpenForRead(fileName); } You can then read data from the text file using a readLine method: public string readLine() { return ts.ReadLine (); } Likewise, the following methods allow you to open a file for writing and write lines of text to it. public void writeLine(string s) { ws.WriteLine (s); } //----------public bool OpenForWrite() { return OpenForWrite(fileName); } //----------public bool OpenForWrite(string file_name) { try{ ws = new StreamWriter (file_name); fileName = file_name; writeOpened = true; return true; } catch(FileNotFoundException e) { return false; } } We’ll use this simplified file method wrapper class in some of the following chapters, whenever we need to read in a file. 119 Part 2. Creational Patterns With the foregoing description of objects, inheritance, and interfaces in hand, we are now ready to begin discussing design patterns in earnest. Recall that these are merely recipes for writing better object-oriented programs. We have divided them into the Gang of Four’s three groups: creational, structural and behavioral. We’ll start out in this section with the creational patterns. All of the creational patterns deal with ways to create instances of objects. This is important because your program should not depend on how objects are created and arranged. In C#, of course, the simplest way to create an instance of an object is by using the new operator. Fred fred1 = new Fred(); //instance of Fred class However, this really amounts to hard coding, depending on how you create the object within your program. In many cases, the exact nature of the object that is created could vary with the needs of the program, and abstracting the creation process into a special “creator” class can make your program more flexible and general. The Factory Method pattern provides a simple decision-making class that returns one of several possible subclasses of an abstract base class, depending on the data that are provided. We’ll start with the Simple Factory pattern as an introduction to factories and then introduce the Factory Method Pattern as well. The Abstract Factory pattern provides an interface to create and return one of several families of related objects. The Builder pattern separates the construction of a complex object from its representation so that several different representations can be created, depending on the needs of the program. 120 The Prototype pattern starts with an instantiated class and copies or clones it to make new instances. These instances can then be further tailored using their public methods. The Singleton pattern is a class of which there can be no more than one instance. It provides a single global point of access to that instance.