This listing starts by declaring a sorting class that will contain the Sort delegate. This class holds two static public variables in Lines 8–9 that will be used to
hold the two values to be sorted. These were declared as static to make the coding easier
in the rest of the listing. Line 11 contains the delegate definition, followed by the method 13 that will execute the delegated methods, DoSort, in Lines 13–16. As you can see, the
DoSort method receives a delegate object as its parameter. The delegate object is used in Line 15 as a method call using the same signature that was used with the delegate definition in Line 11.
The SortProgram class uses the Sort delegate. This class defines the methods that will be delegated—Ascendingand Descending. The class also contains a Main method that will perform the key logic. In Lines 43–44, two delegate objects are created; these are the up and down objects that you saw earlier.
450
Day 13
In Line 46, an object is created of type SortClass. This is necessary to use the DoSort method. In Lines 48 and 49, two values are set into the sorting variables. Line 51 prints these values to the console. Line 53 then calls the DoSort method, passing a delegate object. In this case, the up object is passed. This causes the Ascending method to be used. As the output from Line 57 shows, the sort was accomplished. Line 59 then calls the DoSort method again, this time with the down object. This causes the Descending method to be used, as can be seen by the final output.
You could actually get around declaring a doIT object in Line 46 by declaring the DoSort method as static. The DoSort method could then be accessed using the class name instead of an object:
SortClass.DoSort(...);
This example uses delegates with hard-coded values and with specific calls. The value of delegates becomes more apparent when you begin to create more dynamic programs. For example, Listing 13.2 could be modified to use data from a file or information entered by the user. This would give the sorting more value. Additionally, you could have your user enter a preference for sorting ascending, descending, or some other way. Based on what is entered, you could then make a single call to DoSort with the appropriate delegate object being passed.
Note
In today’s exercises, you are asked to create a delegate that can accept a method for sorting an array of integers. An answer for this will be provided. You could actually take the answer one step further by making the array work with objects. You could then create a delegate for sorting data of any type.
Working with Events
You will find that you will use delegates primarily when you are working with events. An event is a notification from a class that something has occurred. You—or, more appropriately, your other classes—can then do something based on this notification.
The most common example of event processing is within a Windows-based operating system. Within a system such as Microsoft Windows, a dialog box or window is displayed in which a users can do a number of different things: click a button, select a menu, enter text, and so forth. Whenever the user does one of these actions, an event occurs. Event handlers within Windows then react based on the event that occurred. For example, if a user selects a button, a ButtonClick event notification might occur. A ButtonClick event handler could then handle any actions that need to occur.
Making Your Programs React with Delegates, Events, and Indexers
451
Creating Events
Several steps are involved in creating and using an event. This includes setting up the delegate for the event, creating a class to pass arguments for the event handlers, declaring the code for the event, creating code that should occur when the event happens (the handler), and finally causing the event to occur.
Understanding an Event’s Delegate
The first step to working with events is to create a delegate for the event. The delegates that you create for an event follow a specific format:
EventHandlerName is the name of the delegate for the event handler. A delegate for an event always takes two parameters. The first parameter, object source, contains the source that raised the event. The second parameter, xxxEventArgs e, is a class containing data that can be used by a handler for the event. This class is derived from the EventArgs class, which is part of the System namespace.
The following line of code creates a delegate for an event. This event checks assigned characters. If a certain character is assigned, an event is executed. The delegate could be defined as follows:
This declares the delegate named CharEventHandler. From this declaration, you can see that a class named CharEventArgs needs to be created by deriving it from EventArgs.
Deriving from the EventArgs Class
The EventArgs class is used to pass data to an event handler. This class can be inherited into a new class that contains data members for any values that your new event may need. The format of a derived class should be as follows:
public
class xxxEventArgs : EventArgs
13
{
//
Data members
public xxxEventArgs( type name )
{
//Set up values
}
}
As you can see, xxxEventArgs inherits from EventsArgs. You can rename xxxEventArgs to any name you want; using a name that ends with EventArgs makes it obvious as to what this class is used for.
452
Day 13
Tip
Although you can name the xxxEventArgs class anything you want, you should end your class name with EventsArgs. This indicates the purpose of the classand is the more commonly accepted naming convention.
You can add data members to this derived class and add logic to initialize these values within the class’s constructor. This class is passed to the event handler. Any data that your event handler will need should be included in this class.
In the example from the previous section, you saw that a delegate was created named CharEventHandler. This delegate passed an object of class CharEventArgs. Code for
CharEventArgs follows:
public class CharEventArgs : EventArgs
{
public char CurrChar;
public CharEventArgs(char CurrChar)
{
this.CurrChar = CurrChar;
}
}
As you can see, CharEventArgs is a new class derived from EventArgs. Regardless of the event you are doing, you must create a class that is derived in the same fashion from EventArgs. This class contains a single char value, CurrChar, which is usable by the code that will be written to handle this event. This class also contains a constructor that receives a character when the class is created. The character passed to the constructor is assigned the data member within the class.
Working with the Event Class Code
A class can be created to kick off the event. This class contains a declaration for the event, which takes the following format:
public event xxxEventHandler EventName;
Here, xxxEventHandler is the delegate definition that was created for this event. EventName is the name of the event being declared. In summary, this line of code uses the event keyword to create an event instance named EventName that is a delegate of type xxxEventHandler. EventName will be used to assign methods to the delegate, as well as
to do the execution of the methods.
Making Your Programs React with Delegates, Events, and Indexers
453
Here is an example of creating an event class:
1:
class CharChecker
2:
{
3:
char curr_char;
4:
public event CharEventHandler TestChar;
5:
public char Curr_Char
6:
{
7:
get { return curr_char; }
8:
set
9:
{
10:
if (TestChar != null )
11:
{
12:
CharEventArgs args = new CharEventArgs(value);
13:
TestChar(this, args);
14:
curr_char = args.CurrChar;
15:
}
16:
}
17:
}
18:
}
This class contains the code that will kick off the event if the appropriate condition is
met. Your code can vary from this example; however, a couple of things are similar. In
Line 4, an event object is created using the delegate CharEventHandler, which was created
earlier. This event object will be used to execute any assigned event handlers. The next
section of this class is a properties definition for Curr_Char (Lines 5–17). As you can see,
a get property returns the value of the curr_char data member from this class (Line 7).
The set property in Lines 8–16 is unique. The first thing done is to verify that the
TestChar object is not equal to null (Line 10). Remember, the TestChar object was just
declared as an event. This event object will be null only if there are no event handlers
created. You’ll learn more about event handlers in the next section. If there is an event
handler, Line 12 creates a CharEventArgs object. As you learned in the previous section,
this object will hold any values needed for the event-handling routines. The value entered
into the set routine is passed to the CharEventArgs constructor. As you saw in the previous
13
section, for this example, this value is a character that will be available to the event han-
dlers.
Line 13 is the call to the event delegate. Using the event object created in Line 4, a call to the delegate is being made. Because this is an event, it checks for all the methods that have been associated with this event object. As you can see, two values are passed to this event object. The first is this, which is the object that is making the call to the event. The second value is args, which is the CharEventArgs object that you declared in the previous line.
454
Day 13
Line 14 is specific to this particular event. This line assigns the character that is in the CharEventArgs object back to the curr_char data member. If any event handlers called in Line 13 change the data, this makes sure that the event class has an updated value and is thus set—which is the purpose of the set property.
Creating Event Handlers
You have now created a delegate, created a structure to pass information to your event handlers, and created code to execute the event. Now you code what will get executed if an event happens. You need event handlers. Specifically, an event handler is a piece of code that gets notified when an event occurs. An event handler is a method created using the same format as your delegate. The format of the method is the following:
handlername is the name of the method that will be called when an event occurs. The two parameters being passed should look very familiar by this time. The first is the object that executed the event. The second is the class derived from EventArgs that contains the values for the event handler to use. The Event Handler code can be any code you want. If the event was a button click, this would be the code executed when the button is clicked. If it was a Cancel button, this code would do the logic for canceling. If it were an OK button, this code would do the logic for things being okay.
Going back to our Character event example, an event can be declared to replace the letter A whenever it is entered with an X. This is a goofy example, but it is easy to follow:
Console.WriteLine(“Don’t like ‘a’!”); e.CurrChar = ‘X’;
}
}
As you can see, this event handler receives the CharEventArgs parameter. The CurrChar value is retrieved from this object and checked for its value. If the user enters an A or an a, the event handler displays a message and changes the current character to an X instead. If it is any other character, nothing happens.
Making Your Programs React with Delegates, Events, and Indexers
455
Associating Events and Event Handlers
Now you have almost all the pieces. It’s time to associate your event handler with the
event—in case it happens. This occurs in your primary program.
To associate a handler with an event, you must first declare an object containing an
event. For the Character example, this is done by declaring a CharChecker object:
CharChecker tester = new CharChecker();
As you can see, this object is instantiated like any other object. When this object is cre-
ated, your event is available. Whenever the set logic of a CharChecker object is called, the
logic within it is followed, including the creation of the event and the execution of the
event object in its set statements.
Right now, however, you still have not associated your event handler with this object. To
associate an event handler with the object, you need to use the += operator. This is used
in the following format:
ObjectWithEventName.EventObj += new EventDelegateName(EventName);
Here, ObjectWithEventName is the object that you just declared using the event class. For
the example, this is tester. EventObj is the event object that you declared in the event
class. For the example, this is TestChar. The += operator follows as an indicator that the
following is an event to be added to the event handler. The new keyword indicates that the
following handler should be created. Finally, the name of the event handler, EventName, is
passed to the delegate, EventDelegateName. The final statement for the example is as fol-
lows:
tester.TestChar += new CharEventHandler(Drop_A);
Pulling It All Together
Whew! That is a lot to do. however, when this is completed, a line as simple as the fol-
lowing can be used to execute the event:
13
tester.Curr_Char = ‘B’;
Listing 13.3 pulls it all together.
LISTING 13.3 Events.cs—Using an Event and Event Handlers
If you look at this listing, it contains all the sections of code discussed in the pre- ANALYSIS vious sections. The only real new code is in the Main routine in Lines 44–54. This
code assigns characters to the Curr_Char value in the tester class. If an a or an A is found, a message is printed and the character is changed to an X. The change is shown by displaying the Curr_Char value using a Console.WriteLine call.
The event class can be any class that you want to create. For example, I could have changed the CharChecker class in this example to a class that stores a full name or other textual information. In other words, this example doesn’t do much: Your code can.
Multiple Event Handlers (Multicasting)
You can declare multiple event handlers for a single event with multicasting. Additional
event handlers should follow the same format of receiving an object and a derived object
13
of type EventArgs, as well as returning void. To add the additional events, you use the += operator in the same way you saw earlier. Listing 13.4 is a new version of Listing 13.3, with a second event handler added.
Lines 68–75 add a new event handler named Change_D. As you can see, it follows
ANALYSIS
the format required—it returns void and receives the appropriate two parameters.
This event checks for the letters D or d. If any is found, it converts each character to a Z
after displaying a message. It’s not exciting, but it’s effective.
13
This event handler is added to the event object in Line 43. As you can see, it is added in
the same manner as the original event, Drop_A. Now when a letter is assigned, both events
are executed.
Removing an Event Handler
Event handlers can be added, and they can also be removed. To remove an event, use
the -=operator instead of the += operator. Listing 13.5 contains a new Main routine for the
CharChecker program.
460
Day 13
Caution
LISTING 13.5
Listing 13.5 is not a complete listing; it is only the Main routine. You can substitute this code for the main routine in Listing 13.4 (Lines 38–56). Alternatively, you can obtain the listing, Events3.cs, from the source code available on the CD or online at www.TeachYourselfCSharp.com.
Events3.cs—Removing an Event
1:public static void Main()
2:{
3:CharChecker tester = new CharChecker();
5:tester.TestChar += new CharEventHandler(Drop_A);
6:tester.TestChar += new CharEventHandler(Change_D);
22:tester.TestChar -= new CharEventHandler(Change_D);
24: // Try D-a-d...
25:
26:tester.Curr_Char = ‘D’;
27:Console.WriteLine(“{0}”, tester.Curr_Char);
29:tester.Curr_Char = ‘a’;
30:Console.WriteLine(“{0}”, tester.Curr_Char);
32:tester.Curr_Char = ‘d’;
33:Console.WriteLine(“{0}”, tester.Curr_Char);
34:}
B
OUTPUT r
Don’t like ‘a’!
X
Making Your Programs React with Delegates, Events, and Indexers
461
D’s are good!
Z
Removing event handler....
D
Don’t like ‘a’! X
d
ANALYSIS As you can see by the output, when Line 22 is executed, the Change_D event is no longer active. However, the Change_A event handler continues to work.
Caution
If multiple event handlers are assigned to an event, there is no guarantee
for which will be executed first. In Listing 13.5, there is no guarantee that
Change_A will execute before Change_D.
Additionally, event handlers and events can throw exceptions and do all the
things other code can do. If an exception is thrown, there is no guarantee
that other event handlers will be executed.
Summary
In today’s lesson, you learned about some of the more complicated topics within C#. You
first learned about indexers. Indexers can be used with a class so that you can access the
class using index notation. This makes your classes “arraylike.”
You then learned about delegates. You learned that delegates are like interfaces: They
state a definition for accessing but don’t actually provide the implementation. Delegates
set up a format for using methods. You learned that a delegate can be used to dynami-
cally call different methods with a single method call.
The last part of today’s lesson focused on events. You learned that code can be created to
cause an event to happen. More important, you learned that code—event handlers—can
13
be created to react when an event happens.
Q&A
Q Today’s concepts were hard. How important is it to understand them?
AYou can do a lot with C# without understanding the concepts presented today; however, there is a lot more that you won’t be able to do. If you plan to program applications for Windows or other graphical environments, you will find that events are critical. And as you learned today, delegates are critical for working with events.
462
Day 13
Many of the C# editors, such as Visual Studio .NET, will help by automatically creating a lot of the code for you. For example, Visual Studio .NET adds code for many of the standard events.
QIn today’s lesson, events were declared in properties. Do they have to be declared in a property?
A No. You can declare an event call within a property or a method.
QMultiple event handlers were assigned to an event. Can multiple methods be assigned to a single delegate?
AYes. It is possible to assign more than one method to a single delegate so that multiple methods execute with a single call. This is also called multicasting.
Q What is a function pointer?
AIn languages such as C and C++, there is a construct called a function pointer. A function pointer is used to accomplish the same task as a delegate. A delegate, however, is type-safe and secure. In addition to being used to reference methods, delegates are used by events.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to provide you with experience in using what you’ve learned. Try to understand the quiz and exercise answers before continuing to tomorrow’s lesson. Answers are provided on the CD.
Quiz
1.You are in your living room and the phone rings. You get up and answer the phone. The ringing of the phone is best associated with which of the following concepts?
a.Indexer
b.Delegate
c.Event
d.Event handler
e.Exception handler
Making Your Programs React with Delegates, Events, and Indexers
463
2.Your answering the phone is best associated with which of the following concepts:
a.Indexer
b.Delegate
c.Event
d.Event handler
e.Exception handler
3.What is the point of an indexer?
4.When declaring an indexer, what keyword is used?
5.An indexer definition is similar to which of the following:
a.A class definition
b.An object definition
c.A property definition
d.A delegate definition
e.An event definition
6.What are the different steps to creating and using an event?
7.What operator is used to add an event handler?
8.What is it called when multiple event handlers are added to an event?
9.Which is true (note—None and Both are possible answers): An event is an instantiation based on a delegate.
A delegate is an instantiation based on an event.
10.Where within a class can an event be instantiated?
Exercises
1. Add an indexer to the following class. Use the class in a simple program.
public class SimpleClass
13
{
int[] numbers;
public SimpleClass(int size)
{
numbers = new int[size];
// declare size elements
for ( int x = 0; x < size; x++ )
// initialize values to 0.
numbers[x] = 0;
}
}
464
Day 13
2.Rewrite Listing 13.1 without using indexers.
3.Modify Listing 13.2 so that you don’t have to declare a doIT object.
4.Write a program using a delegate that sorts an array of integers. You can use Listing 13.2 as a starting point.
5.Add an event handler to the code in Listing 13.5. This event handler should change any lowercase vowels to uppercase.
WEEK 2
DAY 14
Making Operators
Do Your Bidding:
Overloading
In today’s lesson, you delve deeper into some of the functionality available when working with classes. This includes exploring overloading in much greater detail. You’ve seen method overloading earlier. Today you…
•Revisit method and constructor overloading.
•Learn about overloading operators.
•Discover how to overload unary, binary, relational, and logical operators.
•Understand the difference in overloading the logical operators.
•Review the individual operators that can and can’t be overloaded.
466
Day 14
Overloading Functions Revisited
On Day 8, “Advanced Method Access,” you learned that you can overload a method multiple times. The key issue with overloading a method is that you must ensure that each time you overload the method, it has a different signature. A signature is determined by the return type and parameters of a method. For example, all of the following are different signatures:
int mymethod( int x, int y ) int mymethod( int x )
int mymethod( long x )
int mymethod( char x, long y, long z ) int mymethod( char x, long y, int z )
On Day 8, you learned that you could overload constructors as well as regular methods. Today you go beyond overloading methods: You learn how to overload a class’s operators.
Overloading Operators
In addition to overloading constructors and accessors, many object-oriented languages give you the capability to overload operators. C# is no exception: It enables you to overload many of the mathematical operators—such as addition (+) and subtraction (-)—as well as many of the relational and logical operators.
Why would you want to overload these operators? You do not ever have to overload them. Sometimes, however, it can make your program’s code easier to follow and your classes easier to use.
The String class is a great example of a class that has an operator that is overloaded. Normally, the addition operator would not work on a class type, but in C#, you can actually add two strings with the addition operator. This addition does what you would expect: It concatenates two strings. For example:
“animal” + “ “ + “crackers”
results in this string:
“animal crackers”
To accomplish this, the String class and the string data type overload the addition operator.
Making Operators Do Your Bidding: Overloading
467
You will find that overloading operators can make some of your programs work better as well. Take a look at Listing 14.1. This listing gives you an error when you compile. The error is shown in the listing’s output.
Note
LISTING 14.1
This listing is not a great example of using operator overloading; however, it is simple so that you can focus on the concepts instead of trying to understand the code in a complex listing. A few of the later listings in today’s lesson are much more practical.
The following errors are generated when you try to compile this listing:
OUTPUT
over1a.cs(30,13): error CS0019: Operator ‘+’ cannot be applied tooperands of type ‘AChar’ and ‘int’
over1a.cs(31,13): error CS0019: Operator ‘-’ cannot be applied tooperands of type ‘AChar’ and ‘int’
This listing is easy to follow. A class is created named AChar. This class is not ANALYSIS practical, but its simplicity makes it easy to use as an illustration for overloading.
The AChar class stores a single character. The class has two constructors in Lines 10–11. The first is called when no arguments are provided; it sets the character value stored in a newly instantiated object to a space. The second constructor takes a single character that is placed in a new object’s private character variable. The class uses an accessor in Lines 13–17 to do the actual setting of the character value.
The AChar class is used in the myAppClass class. In Lines 25–26, two AChar objects are created. aaa will contain a, and bbb will contain b. In Line 33, these values are printed. In Line 30, the value of 3 is added to aaa. What would you expect would happen when you add 3 to an AChar object? Note that this is not a type char object or even a numeric object. It is an AChar object.
This listing is trying to add 3 to the actual object, not to a member of the object. The result, as you can see by the compiler output, is an error.
In Line 31, the value of 1 is subtracted from an AChar object. An error is produced because you can’t add or subtract from an object like this. If Lines 30–31 had worked, Line 33 would have printed their values.
You can make the addition work by manipulating an object’s members instead of the class itself. Changing Lines 30–31 to the following allows the listing to compile:
Although this works, it is not the ultimate solution. There is too much casting, and the code is not as simple as it could be. Another solution to make this clear is to add methods to the class that allow addition and subtraction—or other types of operations—to be done with the class’s objects. Listing 14.2 presents this approach.
Making Operators Do Your Bidding: Overloading
469
LISTING 14.2 over1b.cs—Operators for Mathematical Functions
1:// over1b.cs - Using methods for mathematic operations
This listing is better than the last listing—this one compiles! It also provides routines for doing mathematical operations on the class. This is accomplished with
the static methods Add and Subtract declared in Lines 19–24 and 25–30, respectively.
The Add method increments the original AChar character value (ch) by the number specified. In the myAppClass class, the AChar.Add method is called to increment aaa by 3, which results in an a becoming a d. The Add method returns a new AChar class that can overwrite the original. In this way, a number can be added to the class and returned to overwrite the original value. The Subtract method works in the same manner, except that the ch value is decremented by the given number.
This listing is relatively simple. If there were other data members as a part of the class, the Add and Subtract operations would become more complex; however, they would also become more valuable. Consider a few examples:
•A deposit class that contains members for the person making the deposit, an account number, and the value being deposited. In this case, the Add method could manipulate the value being deposited.
•A currency class that contains an enumeration value that indicates the type of currency and multiple numeric values to store different money types, such as dollars and cents.
•A salary class that contains an employee name, the employee ID number, the date of the last salary increase, and the actual salary for the employee.
Creating Overloaded Operators
Using methods such as those presented in Listing 14.2 is a perfectly acceptable way to increment and decrement values of a class. Sometimes, however, overloading an operator makes the class easier to use. The three examples given are such cases, as is the String concatenation example from earlier.
The AChar class is probably not a good class to overload the operators with. Simply put, if you overload an operator, it should be obvious to everyone using the class what the overloaded operator is doing. Consider the following lines of code. What would you expect the results to be? What would everyone else expect the results to be?
Salary = Salary + 1000;
MyChar = MyChar + 3;
MyChar = MyChar + ‘a’;
Deposit = Deposit - 300;
Making Operators Do Your Bidding: Overloading
471
The Salary and the Deposit lines should be obvious. The MyChar + 3 line might seem obvious, but is it? MyChar + ‘a’ is even more cryptic. The + operator could be overloaded for all of these cases, thus making these examples work. The MyChar example would be better using a descriptive named method instead of overloading an operator.
A number of operators can be overloaded. This includes the basic binary mathematics operators, most of the unary operators, the relational operators, and the logical operators.
Overloading the Basic Binary Mathematical Operators
The binary operators are operators that use two values. These operators include addition (+), subtraction (-), multiplication (*), division (/), and modulus (%). All of these can be overloaded within your classes. The total list of binary operators that can be overloaded is as follows:
+
-
*
/
%
&
|
^
<<
>>
Addition
Subtraction
Multiplication
Division
Modulus
AND
OR
Not
Shift left
Shift right
The format for overloading a binary operator is similar to the format for creating methods. The general format for overloading an operator is shown here:
public static return_type operator op ( type x, type y )
{
...
return return_type;
}
Here, return_type is the data type that is being returned by the overloaded operator. For the AChar class in the earlier example, return_type was the class type—AChar. The return
type is preceded by the public and static modifiers. An overloaded operator must always 14 be public so that it can be accessed. It also must always be static so that it can be
accessed at the class level rather than at an individual object level.
The term operator is then used to indicate that this is an operator-overloading method. The operator being overloaded (op) then is presented. If you were overloading the
472
Day 14
addition operator, for example, this would be a plus sign. Finally, the parameters for the operation are presented.
In this example, a binary operator is being overloaded, so there are two parameters. One of the parameters must be of the type of the class whose operator is being overloaded. The other parameter’s type can be of any type. When setting up operator overloading, you will often set these two types as the same. It is perfectly acceptable to make the second type a different type as well. In fact, if you are overloading an operator, you should be sure to set up overloaded methods for any possible data types that might be added to the original class.
Looking back at the AChar class, the following is the method header for overloading the addition operator so that you can add an integer value to an AChar value:
public static AChar operator+ (AChar x, int y)
Although x and y are used as the parameter names, you can use any variable names that you want. An integer value is the second parameter because that is what was added to the AChar objects in the earlier listings. Listing 14.3 presents the AChar class one more time. This time, however, the addition and subtraction operators are overloaded to allow an integer to be added to an AChar.
Note
LISTING 14.3
You may have noticed that the format description earlier had a space between the word operator and the op sign. In the example just presented for the AChar class, there is no space; the operator is connected to the word operator. Either format works.
