Using Classes and Objects in C#

4. Using Classes and Objects in C# What Do We Use Classes For? All C# programs are composed of classes. The Windows forms we have just seen are classes, derived from the basic Form class and all the other programs we will be writing are made up exclusively of classes. C# does not have the concept of global data modules or shared data that is not part of classes. Simply put, a class is a set of public and private methods and private data grouped inside named logical units. Usually, we write each class in a separate file, although this is not a hard and fast rule. We have already seen that these Windows forms are classes, and we will see how we can create other useful classes in this chapter. When you create a class, it is not a single entity, but a master you can create copies or instances of, using the new keyword. When we create these instances, we pass some initializing data into the class using its constructor. A constructor is a method that has the same name as the class name, has no return type and can have zero or more parameters that get passed into each instance of the class. We refer to each of these instances as objects. In the sections that follow we’ll create some simple programs and use some instances of classes to simplify them. A Simple Temperature Conversion Program Suppose we wanted to write a visual program to convert temperatures between the Celsius and Fahrenheit temperature scales. You may remember that water freezes at zero on the Celsius scale and boils at 100 degrees, while on the Fahrenheit scale, water freezes at 32 and boils at 212. From these numbers you can quickly deduce the conversion formula that you may have forgotten. The difference between freezing and boiling on once scale is 100 and on the other 180 degrees or 100/180 or 5/9. The Fahrenheit scale is “offset” by 32, since water freezes at 32 on its scale. Thus, C = (F – 32)* 5/9 and F = 9/5 * C + 32 In our visual program, we’ll allow the user to enter a temperature and select the scale to convert it to as we see in Figure 4-1. Figure 4-1– Converting 35 Celsius to 95 Fahrenheit with our visual interface. Using the visual builder provided in Visual Studio.NET, we can draw the user interface in a few seconds and simply implement routines to be called when the two buttons are pressed. If we double click on the Convert button, the program generates the btConvert_Click method. You can fill it in to have it convert the values between temperature scales: private void btCompute_Click(object sender, System.EventArgs e) { float temp, newTemp; //convert string to input value temp = Convert.ToSingle (txEntry.Text ); //see which scale to convert to if(opFahr.Checked) newTemp = 9*temp/5 + 32; else newTemp = 5*(temp-32)/9; //put result in label text lbResult.Text =newTemp.ToString (); txEntry.Text =""; //clear entry field } The above program is extremely straightforward and easy to understand, and is typical of how some simple C# programs operate. However, it has some disadvantages that we might want to improve on. The most significant problem is that the user interface and the data handling are combined in a single program module, rather than being handled separately. It is usually a good idea to keep the data manipulation and the interface manipulation separate so that changing interface logic doesn’t impact the computation logic and vice-versa. Building a Temperature Class A class in C# is a module that can contain both public and private functions and subroutines, and can hold private data values as well. These functions and subroutines in a class are frequently referred to collectively as methods. Class modules allow you to keep a set of data values in a single named place and fetch those values using get and set functions, which we then refer to as accessor methods. You create a class module from the C# integrated development environment (IDE) using the menu item Project | Add class module. When you specify a filename for each new class, the IDE assigns this name as the class name as well and generates an empty class with an empty constructor. For example, if we wanted to create a Temperature class, the IDE would generate the following code for us: namespace CalcTemp { ///

/// Summary description for Temperatur. ///

public class Temperature { public Temperature() { // // TODO: Add constructor logic here // } } } If you fill in the “summary description” special comment, that text will appear whenever your mouse hovers over an instance of that class. Note that the system generates the class and a blank constructor. If your class needs a constructor with parameters, you can just edit the code. Now, what we want to do is with this class is to move all of the computation and conversion between temperature scales into this new Temperature class. One way to design this class is to rewrite the calling programs that will use the class module first. In the code sample below, we create an instance of the Temperature class and use it to do whatever conversions are needed: private void btCompute_Click(object sender, System.EventArgs e) { string newTemp; //use input value to create instance of class Temperature temp = new Temperature (txEntry.Text ); //use radio button to decide which conversion newTemp = temp.getConvTemp (opCels.Checked ); //get result and put in label text lbResult.Text =newTemp.ToString (); txEntry.Text =""; //clear entry field } The actual class is shown below. Note that we put the string value of the input temperature into the class in the constructor, and that inside the class it gets converted to a float. We do not need to know how the data are represented internally, and we could change that internal representation at any time. public class Temperature { private float temp, newTemp; //------------//constructor for class public Temperature(string thisTemp) temp = Convert.ToSingle(thisTemp); } //------------public string getConvTemp(bool celsius){ if (celsius) return getCels(); else return getFahr(); } //------------private string getCels() { newTemp= 5*(temp-32)/9; return newTemp.ToString() ; } //------------private string getFahr() { newTemp = 9*temp/5 + 32; return Convert.ToString(newTemp) ; } { } Note that the temperature variable temp is declared as private, so it cannot be “seen” or accessed from outside the class. You can only put data into the class and get it back out using the constructor and the getConvTemp method. The main point to this code rearrangement is that the outer calling program does not have to know how the data are stored and how they are retrieved: that is only known inside the class. The other important feature of the class is that it actually holds data. You can put data into it and it will return it at any later time. This class only holds the one temperature value, but classes can contain quite complex sets of data values. We could easily modify this class to get temperature values out in other scales without still ever requiring that the user of the class know anything about how the data are stored, or how the conversions are performed Converting to Kelvin Absolute zero on the Celsius scale is defined as –273.16 degrees. This is the coldest possible temperature, since it is the point at whic h all molecular motion stops. The Kelvin scale is based on absolute zero, but the degrees are the same size as Celsius degrees. We can add a function public string getKelvin() { newTemp = Convert.ToString (getCels() + 273.16) } What would the setKelvin me thod look like? Putting the Decisions into the Temperature Class Now we are still making decisions within the user interface about which methods of the temperature class. It would be even better if all that complexity could disappear into the Temperature class. It would be nice if we just could write our Conversion button click method as private void btCompute_Click(object sender, System.EventArgs e) { Temperature temper = new Temperature(txEntry.Text , opCels.Checked); //put result in label text lbResult.Text = temper.getConvTemp(); txEntry.Text =""; //clear entry field } This removes the decision making process to the temperature class and reduces the calling interface program to just two lines of code. The class that handles all this becomes somewhat more complex, however, but it then keeps track of what data as been passed in and what conversion must be done. We pass in the data and the state of the radio button in the constructor: public Temperature(string sTemp, bool toCels) temp = Convert.ToSingle (sTemp); celsius = toCels; { } Now, the celsius boolean tells the class whether to convert or not and whether conversion is required on fetching the temperature value. The output routine is simply public string getConvTemp(){ if (celsius) return getCels(); else return getFahr(); } //------------private string getCels() { newTemp= 5*(temp-32)/9; return newTemp.ToString() ; } //------------private string getFahr() { newTemp = 9*temp/5 + 32; return Convert.ToString(newTemp) ; } In this class we have both public and private methods. The public ones are callable from other modules, such as the user interface form module. The private ones, getCels and getFahr, are used internally and operate on the temperature variable. Note that we now also ha ve the opportunity to return the output temperature as either a string or a single floating point value, and could thus vary the output format as needed. Using Classes for Format and Value Conversion It is convenient in many cases to have a method for converting between formats and representations of data. You can use a class to handle and hide the details of such conversions. For example, you might design a program where you can enter an elapsed time in minutes and seconds with or without the colon: 315.20 3:15.20 315.2 and so forth. Since all styles are likely, you’d like a class to parse the legal possibilities and keep the data in a standard format within. Figure 4-2 shows how the entries “112” and “102.3” are parsed. Figure 4-2 – A simple parsing program that uses the Times class. Much of the parsing work takes place in the constructor for the class. Parsing depends primarily on looking for a colon. If there is no colon, then values greater than 99 are treated as minutes. public FormatTime(string entry) { errflag = false; if (! testCharVals(entry)) { int i = entry.IndexOf (":"); if (i >= 0 ) { mins = Convert.ToInt32 (entry.Substring (0, i)); secs = Convert.ToSingle (entry.Substring (i+1)); if(secs >= 60.0F ) { errflag = true; t = NT; } t = mins *100 + secs; } else { float fmins = Convert.ToSingle (entry) / 100; mins = (int)fmins; secs = Convert.ToSingle (entry) - 100 * mins; if (secs >= 60) { errflag = true; t = NT; } else t = Convert.ToSingle(entry); } } } Since illegal time values might also be entered, we test for cases like 89.22 and set an error flag. Depending on the kind of time measurements these represent, you might also have some non-numeric entries such as NT for no time or in the case of athletic times, SC for scratch or DQ for disqualified. All of these are best managed inside the class. Thus, you never need to know what numeric representations of these values are used internally. static public int NT = 10000; static public int DQ = 20000; Some of these are processed in the code represented by Figure 4-3. b Figure 4-3 – The time entry interface, showing the parsing of symbols for Scratch, Disqualification and No Time. Handling Unreasonable Values A class is also a good place to encapsulate error handling. For example, it might be that times greater than some threshold value are unlikely and might actually be times that were entered without a decimal point. If large times are unlikely, then a number such as 123473 could be assumed to be 12:34.73” public void setSingle(float tm) { t = tm; if((tm > minVal) && (tm < NT)) { t = tm / 100.0f; } } The cutoff value minVal may vary with the domain of times being considered and thus should be a variable. You can also use the class constructor to set up default values for variables. public class FormatTime { public FormatTime(string entry) errflag = false; minVal = 1000; { t = 0; A String Tokenizer Class A number of languages provide a simple method for taking strings apart into tokens, separated by a specified character. While C# does not exactly provide a class for this feature, we can write one quite easily us ing the Split method of the string class. The goal of the Tokenizer class will be to pass in a string and obtain the successive string tokens back one at a time. For example, if we had the simple string Now is the time our tokenizer should return four tokens: Now is the time The critical part of this class is that it holds the initial string and remembers which token is to be returned next. We use the Split function, which approximates the Tokenizer but returns an array of substrings instead of having an object interface. The class we want to write will have a nextToken method that returns string tokens or a zero length string when we reach the end of the series of tokens. The whole class is shown below. //String Tokenizer class public class StringTokenizer { private string data, delimiter; private string[] tokens; //token array private int index; //index to next token //---------public StringTokenizer(string dataLine) { init(dataLine, " "); } //---------//sets up initial values and splits string private void init(String dataLine, string delim) { delimiter = delim; data = dataLine; tokens = data.Split (delimiter.ToCharArray() ); index = 0; } //---------public StringTokenizer(string dataLine, string delim) { init(dataLine, delim); } //---------public bool hasMoreElements() { return (index < (tokens.Length)); } //---------public string nextElement() { //get the next token if( index < tokens.Length ) return tokens[index++]; else return ""; //or none } } The class is illustrated in use in Figure 4-4. Figure 4-4– The tokenizer in use. The code that uses the Tokenizer class is just: //call tokenizer when button is clicked private void btToken_Click(object sender, System.EventArgs e) { StringTokenizer tok = new StringTokenizer (txEntry.Text ); while(tok.hasMoreElements () ) { lsTokens.Items.Add (tok.nextElement()); } } Classes as Objects The primary difference between ordinary procedural programming and object-oriented (OO) programming is the presence of classes. A class is just a module as we have shown above, which has both public and private methods and which can contain data. However, classes are also unique in that there can be any number of instances of a class, each containing different data. We frequently refer to these instances as objects. We’ll see some examples of single and multiple instances below. Suppose as have a file of results from a swimming event stored in a text data file. Such a file might look, in part, like this: 1 2 3 4 5 6 Emily Fenn Kathryn Miller Melissa Sckolnik Sarah Bowman Caitlin Klick Caitlin Healey 17 16 17 16 17 16 WRAT WYW WYW CDEV MBM MBM 4:59.54 5:01.35 5:01.58 5:02.44 5:02.59 5:03.62 where the columns represent place, names, age, club and time. If we wrote a program to display these swimmers and their times, we’d need to read in and parse this file. For each swimmer, we’d have a first and last name, an age, a club and a time. An efficient way to keep the data for each swimmer grouped together is to design a Swimmer class and create an instance for each swimmer. Here is how we read the file and create these instances. As each instance is created we add it into an ArrayList object: private void init() { ar = new ArrayList (); //create array list csFile fl = new csFile ("500free.txt"); //read in liens string s = fl.readLine (); while (s != null) { //convert to tokens in swimmer object Swimmer swm = new Swimmer(s); ar.Add (swm); s= fl.readLine (); } fl.close(); //add names to list box for(int i=0; i < ar.Count ; i++) { Swimmer swm = (Swimmer)ar[i]; lsSwimmers.Items.Add (swm.getName ()); } } The Swimmer class itself parses each line of data from the file and stores it for retrieval using getXXX accessor functions: public class Swimmer { private string frName, lName; private string club; private int age; private int place; private FormatTime tms; //----------public Swimmer(String dataLine) { StringTokenizer tok = new StringTokenizer (dataLine); place = Convert.ToInt32 (tok.nextElement()); frName = tok.nextElement (); lName = tok.nextElement (); string s = tok.nextElement (); age = Convert.ToInt32 (s); club = tok.nextElement (); tms = new FormatTime (tok.nextElement ()); } //----------public string getName() { return frName+" "+lName; } //----------public string getTime() { return tms.getTime(); } } Class Containment Each instance of the Swimmer class contains an instance of the StringTokenizer class that it uses to parse the input string and an instance of the Times class we wrote above to parse the time and return it in formatted form to the calling program. Having a class contain other classes is a very common ploy in OO programming and is one of the main ways we can build up more complicated programs from rather simple components. The program that displays these swimmers is shown in Figure 4-5. Figure 4-5 – A list of swimmers and their times, using containment. When you click on any swimmer, her time is shown in the box on the right. The code for showing that time is extremely easy to write since all the data are in the swimmer class: private void lsSwimmers_SelectedIndexChanged( object sender, System.EventArgs e) { //get index of selected swimmer int i = lsSwimmers.SelectedIndex ; //get that swimmer Swimmer swm = (Swimmer)ar[i]; //display her time txTime.Text =swm.getTime (); } Initialization In our Swimmer class above, note that the constructor in turn calls the constructor of the StringTokenizer class: public Swimmer(String dataLine) { StringTokenizer tok = new StringTokenizer (dataLine); Classes and Properties Classes in C# can have Property methods as well as public and private functions and subs. These correspond to the kinds of properties you associate with Forms, but they can store and fetch any kinds of values you care to use. For example, rather than having methods called getAge and setAge, you could have a single age property which then corresponds to a get and a set method: private int Age; //age property public int age { get { return Age; } set { Age = value; } } Note that a property declaration does not contain parentheses after the property name, and that the special keyword value is used to obtain the data to be stored. To use these properties, you refer to the age property on the left side of an equals sign to set the value, and refer to the age property on the right side to get the value back. age = sw.Age; sw.Age = 12; //Get this swimmer’s age //Set a new age for this swimmer Properties are somewhat vestigial, since they originally applied more to Forms in the Vb language, but many programmers find them quite useful. They do not provide any features not already available using get and set methods and both generate equally efficient code. In the revised version of our SwimmerTimes display program, we convert all of the get and set methods to properties, and then allow users to vary the times of each swimmer by typing in new ones. Here is the Swimmer class public class Swimmer { private string frName, lName; private string club; private int Age; private int place; private FormatTime tms; //----------public Swimmer(String dataLine) { StringTokenizer tok = new StringTokenizer (dataLine); place = Convert.ToInt32 (tok.nextElement()); frName = tok.nextElement (); lName = tok.nextElement (); string s = tok.nextElement (); Age = Convert.ToInt32 (s); club = tok.nextElement (); tms = new FormatTime (tok.nextElement ()); } //----------public string name { get{ return frName+" "+lName; } } //----------public string time { get{ return tms.getTime(); } set { tms = new FormatTime (value); } } //------------------//age property public int age { get { return Age; } set { Age = value; } } } } Then we can type a new time in for any swimmer, and when the txTime text entry field loses focus, we can store a new time as follows: private void txTime_OnLostFocus( object sender, System.EventArgs e) { //get index of selected swimmer int i = lsSwimmers.SelectedIndex ; //get that swimmer Swimmer swm = (Swimmer)ar[i]; swm.time =txTime.Text ; } Programming Style in C# You can develop any of a number of readable programming styles for C#. The one we use here is partly influenced by Microsoft’s Hungarian notation (named after its originator, Charles Simonyi) and partly on styles developed for Java. We favor using names for C# controls such as buttons and list boxes that have prefixes that make their purpose clear, and will use them whenever there is more than one of them on a single form: Control name Buttons List boxes Radio (option buttons) Combo boxes Menus Text boxes Prefix bt ls op cb mnu tx Example btCompute lsSwimmers opFSex cbCountry mnuFile txTime We will not generally create new names for labels, frames and forms when they are never referred to directly in the code. We will begin class names with capital letters and instances of classes with lowercase letters. We will also spell instances and classes with a mixture of lowercase and capital letters to make their purpose clearer: swimmerTime Summary In this chapter, we’ve introduced C# classes and shown how they can contain public and private methods and can contain data. Each class can have many instances and each could contain different data values. Classes can also have Property methods for setting and fetching data. These Property methods provide a simpler syntax over the usual getXXX and setXX accessor methods but have no other substantial advantages.m Programs on the CD-ROM Termperature conversion \UsingClasses\CalcTemp Temperature conversion using classes \UsingClasses\ClsCalcTemp Temperature conversion using classes \UsingClasses\AllClsCalcTemp Time conversion \UsingClasses\Formatvalue String tokenizer \UsingClasses\TokenDemo Swimmer times \UsingClasses\SwimmerTokenizer