The Button element in Blend has a Content Property that you specify the label shown in the Button. If you named the Button in Blend, for example, you can type the Button name in code, type .Content =, and then type the value you want shown.

Simple stuff, right?

In Listing 10.2, you also called a Convert method and asked to convert the value to a string. There is no difference in calling the Convert method to using the .ToString() method, but it’s important to note that there is a way to convert between specific types.

You can convert many types to other types, but it needs to be a valid conversion. Otherwise, an exception results (that is, a big ugly message box appears, or your application may even crash).

An example of a valid string to int conversion is shown in the following code:

int MyValue = Convert.ToInt32("192");

An example of an invalid string to int conversion is shown in the following code:

int MyValue = Convert.ToInt32("A192");

This string is invalid because the compiler cannot convert the letter A into a number.

The compiler in .NET is very sophisticated, so most of the time, it will tell you what is wrong with your code. In the case of conversions, however, you won’t know it’s wrong until you run your application (runtime).

Figure 10.1. The property expected type in the ToolTip.

To rehash data types, take a moment and review the following:

In design time, you can build a class in Visual Studio by using the correct syntax and by providing public methods and properties that a user of the class can access in order to set or get information held within the class. During runtime, the class becomes an object when a new instance (called instantiation) occurs. This generally takes the following format:

ClassName InstanceName = new ClassName();

Similar to when you created a variable of the type int, you first specify the type (ClassName), then an identifier (InstanceName), and then you assign a new instance of the type to the identifier: = new ClassName();.

The concept of a class is similar to that of a blueprint, whereby you design an object to be a generic description of something.

A car is a pretty simple example.

You create a class that describes a car, which means that it needs to have properties that refer to the number of wheels on the car, the number of doors, or even an engine size.

When creating your class, create a generic blueprint of a car. When you have a separate instance of the blueprint, you can then create a specific type of car.

The following steps take you through creating a simple class:

  using System.Linq;

The concept of scope is one that either you get or you don’t. In coding terms, something that is “public” means that everything else in the code (other classes and so on) has access to that public item. The opposite to this is “private,” which means that only items that have a direct level of ownership can access the item.

To demonstrate this, the following sample creates a public and a private variable, similar to what you did with Data types.

private void btnMakeCar_Click(object sender, RoutedEventArgs e)
        {
            Car MyCar = new Car();
        }

You can see how the new Car is created. Now it’s time to see the effects of scope.

In Listing 10.3 you can see that a variable with the type “public” and an another one with the type “private” have been declared. Under the new instance of MyCar, type the word MyCar. (be sure to include the dot after it) to view the IntelliSense output (see Figure 10.3).

Figure 10.3. The IntelliSense for the MyCar object only displays “Public” member variables.

You should see that the member variable Doors is not present but Wheels is. This is because Wheels is public and Doors is not. The only way Doors can have a value is to set inside its own class. How can you get around this?

CLR (Common Language Runtime or .NET) properties are really very simple, but this simplicity comes at the cost of reduced functionality. Still, the following example shows the concept of Properties clearly:

    class Car
    {
        private int Wheels = 4;
        public int NumberOfWheels
        {
            get { return this.Wheels ;}
            set { this.Wheels = value;}
        }

        private int Doors = 4;
        public int NumberOfDoors
        {
            get { return this.Doors ; }
            set { this.Doors = value; }
        }

    }

Breaking this down, you can see that the int Wheels member is now private. This is called the private backing field. Being private now means that the member variables can only be assigned a new value by either the “set” of the public property accessor NumberOfWheels or somewhere else internally in the code of this class only.

If you remove the “set” altogether, the property effectively becomes read-only, because your user can get the value but can’t set it. If this is your intention, make sure you define a default value of the private backing field.

Go back to the code point where you created an instance of the Car class and again type MyCar. (Be sure to include the ending dot.) This time you should see both the properties to which you can assign values, as shown in Listing 10.6.

private void btnMakeCar_Click(object sender, RoutedEventArgs e)
        {
            Car MyCar = new Car();
            MyCar.NumberOfDoors = 2;
            MyCar.NumberOfWheels = 4;
        }

There you have it, nice and simple! You can now create properties of an object and control how the user of the object can interact with it using scope.

A DependencyProperty (DP) is not that dissimilar from a CLR property. In fact, a DP is an extension of the CLR property concept, allowing for much greater flexibility in control over the values contained by the property.

I explain the DP concept in two parts, the first being the “public” accessor (CLR wrapper) for the property, as shown in Listing 10.7.

        public int NumberOfSeats
        {
            get { return (int)GetValue(NumberOfSeatsProperty); }
            set { SetValue(NumberOfSeatsProperty, value); }
        }

Listing 10.7 shows you the slight changes to the “public” property interface compared with the CLR property.

You still have the get/set, which means that if you want to work with this property, you call it using exactly the same method as shown in Listing 10.6.

Internally, the get/set instances call the WPF property API by using GetValue/SetValue, as shown in Listing 10.7.

The second part is about the backing field. DPs also have a backing field, but instead of the field being a private member variable, the DependencyProperty type is the field, as shown in Listing 10.8.

        // Using a DependencyProperty as the backing store for NumberOfSeats. This
enables animation, styling, binding, etc...
        public static readonly DependencyProperty NumberOfSeatsProperty =
            DependencyProperty.Register("NumberOfSeats", typeof(int), typeof(Car));

This code contains quite a few changes and added complexity compared with the “private” backing field member used in CLR events. But the complexity is worth it considering the additional benefits, such as support for binding, animation, styling, property inheritance (the parent supplies the value), and the ability to modify or create your own metadata for the property.

Listing 10.8 shows the bare minimum code required to create a DependencyProperty to which the naming convention NumberOfSeatsProperty is very important, because it is the name of the property that is looked up by the WPF property system.

On creation you can also see that you are required to register the DependencyProperty details. As shown in Listing 10.8, at the minimum, three values are required:

To implement this property, as shown in Listings 10.7 and 10.8, you are required to also add a using statement at the top of the class file:

using System.Windows;

Remember how I mentioned previously that the .NET Framework has thousands of classes? DependencyProperty is one of those classes, and it lives in the System.Windows namespace.

Figure 10.4. Visual Studio offers a hand.

Your class must also be a DependencyObject, so you need to inherit from this type to enable the functionality DependencyObject provides, which happens to be the GetValue() and SetValue() methods in the public accessor. You will also want this class to be publicly accessible for other areas of the application to work, so please take note that the scope changes here as well.

Modify your class declaration to look like the following:

public class Car : DependencyObject

Until you add the using directive for System.Windows, your class will not know about the DependencyObject type either. Again, place the cursor at the end of the word (on the t in DependencyObject) and then select the small red underscore to add the using directive as required.

Back in the Window1.xaml.cs file, you can now set the property, as shown in Listing 10.9.

        private void btnMakeCar_Click(object sender, RoutedEventArgs e)
        {
            Car MyCar = new Car();
            MyCar.NumberOfDoors = 2;
            MyCar.NumberOfWheels = 4;
            MyCar.NumberOfSeats = 7;
        }

As shown in Listing 10.9, the code is no different from when you use a CLR property.

Using the properties in markup is a different scenario, however. For XAML you can only set a property if it is a DependencyProperty. If you want to include an instance of your Car in XAML, you need to convert all your properties to DPs to have access to them.

For more information on properties, especially WPF property types, visit http://msdn2.microsoft.com/en-us/library/ms753192.aspx or do a search on the web for DependencyProperties.

The generalized concept of the if-else is the following:

if(CONDITION)
... //do this
else
... //do this

The CONDITION is an evaluation that can either be true or false, so it is a Boolean evaluation.

Consider the following three variables:

            int a = 5;
            int b = 5;
            int c = 10;

Now consider the following:

These are all true statements that in code are written as follows:

            if (a == b)
            {
                //do something here
            }

            if ((a+b) == c)
            {
                //do something here
            }

            if (a != c)
            {
                //do something here
            }

Notice that not a single equals (=) sign is present.

a = c would mean that “a” would then contain a value of 10 (or as some people say “a gets c”)

whereas

a == c is a statement asking if “a” is equal to “c”

The second example shows that a mathematic equation should be contained within a set of parentheses, so the addition is performed to get a value to then compare against c.

The last example also shows that you can query if something is not equal to something else, using the != symbols.

You can also use additional mathematic notation for conditional determinations, such as < or > or even <= and >=.

You don’t have to rely on local values within variables for these conditional tests, however. You can also call methods that return a value that would then be tested. Imagine a method called GetNumberOfWheels exists in the Car class and returns the value of 4. To use this method in the if statement, you would write something like the following:

if (MyCar.GetNumberOfWheels() == 4)
            {
                //Do this is the car has 4 wheels
            }

At the moment you don’t have this method in the car class, but because the DependencyProperty NumberOfWheels does exist, you could also just call the property value for a return such as the following:

            if (MyCar.NumberOfWheels == 4)
            {
                //Do this is the car has 4 wheels
            }

The else statement allows you to deal with the scenario that a CONDITION is either a true or a false, or vice versa.

            if (MyCar.NumberOfWheels == 4)
            {
                //Do this if the car has 4 wheels
            }
            else
            {
                //Do something here if the car has more or less than 4 wheels
            }

The preceding example also raises additional questions, such as, “What if there are three or five wheels?”

You can use the else statement with additional if conditional testing to deal with multiple scenarios, as demonstrated in the following code:

if (MyCar.NumberOfWheels == 3)
            {
                //Do this if the car has 3 wheels
            }
            else if (MyCar.NumberOfWheels == 4)
            {
                //Do this if the car has 4 wheels
            }
            else if (MyCar.NumberOfWheels == 5)
            {
                //Do this if the car has 5 wheels
            }
            else
            {
                //Do something here if the car has
                //less than 3 or more than 5 wheels
            }

Within your code you can use numerous other conditional statements, such as do while loops and switch logic (which is discussed shortly). Each method has its positives and negatives, but essentially all are about allowing you to determine what should occur “if” something happens.

Starting simple here, consider the example of the days of the week as a concept of how to declare an enum type.

A day-of-the-week enum would be declared similarly to Listing 10.10.

        enum DayOfTheWeek
        {
            Sunday,
            Monday,
            Tuesday,
            Wednesday,
            Thursday,
            Friday,
            Saturday
        }

Except for the last value, notice that all the values have a comma after them.

Now that the enum is defined, elsewhere in your code you could create a member of this type.

Recall that you previously added private members for use as the backing fields in the CLR property types. Now you can create a member using this enum as the data type as well.

The last paragraph should now have you thinking about properties. You should now understand that the enum is a type, just the same as a string, an int, or a bool (just specific about the values that can be set to it). You use the type in exactly the same way.

Consider an int type declared as a global member variable:

private int MyIQ = 64;//Oh dear...

Notice the similarities of using your enum as the data type, as shown in the following:

private DayOfTheWeek CurrentDay = DayOfTheWeek.Saturday;

The difference is that with the int member, you are free to set its value at whatever valid integer you please, whereas with the DayOfTheWeek type member, you must set its value to one of the values as defined within the enum.

Moving back to the Car class, create the enum type, as shown in Listing 10.11.

public enum CarModel
       {
            Mustang,
            Bronco,
            Escort,
            Fairlane,
            Mondeo
        }

Now add the code shown in Listing 10.12 to create a DependencyProperty of type CarModel. Pay close attention to how the default value of the property is set.

        public CarModel Model
        {
            get { return (CarModel)GetValue(ModelProperty); }
            set { SetValue(ModelProperty, value); }
        }

        public static readonly DependencyProperty ModelProperty =
            DependencyProperty.Register("Model", typeof(CarModel), typeof(Car), new
PropertyMetadata(CarModel.Fairlane));

Return to the Window1.xaml.cs file. Set this new property using the following syntax:

MyCar.Model = Car.CarModel.Mustang;

The switch statement is really another form of conditional coding and is extremely well suited to the use of enums because the value required for a switch must be a constant, which enum values are. You can’t add more values to an enum in runtime, so the ones you declare are implicitly constant.

The switch statement looks like a really fancy if statement, and the logic reads similarly. The following is a sample to demonstrate the concept, using a member variable CurrentDay, which is of enum type DayOfWeek as previously shown in Listing 10.10.

            switch (CurrentDay)
            {
                case DayOfTheWeek.Sunday:
                    //Should be asleep
                    ... do something here
                    break;
                case DayOfTheWeek.Monday:
                    //Get up early :-(
                    ... do something here
                    break;
                case DayOfTheWeek.Tuesday:
                    //Feel ok, getting used to being up early
                    ... do something here
                    break;
                case DayOfTheWeek.Wednesday:
                    //Hump day.. looking forward to weekend
                    ... do something here
                    break;
                case DayOfTheWeek.Thursday:
                    //Start winding down.. can't overdo it now
                    ... do something here
                    break;
                case DayOfTheWeek.Friday:
                    //Pretty much a standard holiday day.. don't tell the boss
                    ... do something here
                    break;
                case DayOfTheWeek.Saturday:
                    //Hangover from Friday
                    ... do something here
                    break;
                default:
                    //Should never get here
                    ... do something here - log or throw an error
                    break;
            }

The code is a little sarcastic, but the idea is that you test for the current value in the case and exit from the switch logic by using a break; at the end of each case.

Add another button to your test application, calling it btnCarDetails (see Figure 10.5).

Figure 10.5. The application layout.

Add a Click event handler for the new button to return to Visual Studio.

In the previous button click handler, you created a new instance of the Car class (MyCar) and set its property values. While doing this, you created an instance that was only local to that particular handling method, so now that you have a new click handler, you will be unable to access the MyCar instance.

To change the scope of the declared MyCar instance from local to global, take out the declaration of the previous handler and place it above the click handler, as shown in Listing 10.13.

        //Make the MyCar instance global in scope
        private Car MyCar = new Car();

        private void btnMakeCar_Click(object sender, RoutedEventArgs e)
        {
            MyCar.NumberOfDoors = 2;
            MyCar.NumberOfWheels = 4;
            MyCar.NumberOfSeats = 7;

            MyCar.Model = Car.CarModel.Mustang;
        }

Note that the scope declaration of private was added to the front of the declaration. Although this is not required (by default, all global member variables are private in .NET C#), it is good practice to declare the scope, as shown.

Now add the code in Listing 10.14, which makes use of the MyCar instance now being accessible as a global and demonstrates a usage of the switch statement.

        private void btnCarDetails_Click(object sender, RoutedEventArgs e)
        {
            switch (this.MyCar.Model)
            {
                case Car.CarModel.Mustang:
                    MessageBox.Show("The car is a Mustang");
                    break;
                case Car.CarModel.Bronco:
                    MessageBox.Show("The car is a Bronco");
                    break;
                case Car.CarModel.Escort:
                    MessageBox.Show("The car is an Escort");
                    break;
                case Car.CarModel.Fairlane:
                    MessageBox.Show("The car is a Fairlane");
                    break;
                case Car.CarModel.Mondeo:
                    MessageBox.Show("The car is a Mondeo");
                    break;
                default:
                    MessageBox.Show("Error.. the car model is not set");
                    break;
            }
        }

Note that the value being tested is written like so:

           switch (this.MyCar.Model)

The this. says that the MyCar instance is a member of this class. This is not required, but it can make readability a lot better in complex code because you can instantly tell that MyClass is local to the class.

The case statements cover every possible combination of the enum type that the member variable Model also represents. It is quite easy to follow the code through when reading it.

Enums have other benefits and are quite often used to track the state of objects and where the user is within the application. Enums are great and reduce the potential for logical errors, so I advise that you use them as often as possible.

In code, you use what is called a dot (or period) notation to call a method. A method belongs to the object where it is written in, so in the case that you added the methods shown in Listing 10.16, you could call them from a button click handler like the following:

this.DoCalculation_Divide();

Alternatively, the second method would be called as follows:

this.DoCalculation_Multiply();

If these methods were written inside a different class object, for example, the Car class, you would call them either as

this.MyCar.DoCalculation_Divide();

or

this.MyCar.DoCalculation_Multiply();

Looking at the following code (the first method from Listing 10.16), you see a simple yet well defined method.

        public int AddTwoNumbers(int NumberOne, int NumberTwo)
        {
            int Result = NumberOne + NumberTwo;
            return Result;
        }

Let’s start with the first line of this method:

        public int AddTwoNumbers(int NumberOne, int NumberTwo)

The word public represents the scope of the method, or who can use it. This again means that if this method was inside the Car class, it would need to be public—the same as the properties—in order to use it outside of the code of the class.

Next you see that an int is declared. This states that this method must return a value of type int.

The method has a name to be referred by: AddTwoNumbers. This is an ideal name for the method because, just by looking at the name, you know what the method does. You should try to implement meaningful names to every area of your code, because anyone else looking at it might otherwise find it difficult to understand what you are trying to achieve.

Next is an open parenthesis, followed by a parameter declaration (int NumberOne), a comma separating the first parameter from the second (int NumberTwo), and then a closing parenthesis.

The next line creates the opening brace, or {, for which you will see a closing brace, or }, at the end of the method listing. These braces tell the application that this is a block of code. When the execution path of the application enters this “block” of code, every line should be executed until the ending brace is met or an instruction is given to exit the code block. This is the same as the click handler blocks of code. In fact, the click handler is just another method.

  return;

The next line declared a variable (int Result) and at the same time initialized the variable and assigned (=) the resulting value by performing the addition of the two supplied parameters (NumberOne + NumberTwo).

Finally, you use the keyword return to fulfill the requirement to return a value of int: return Result;

In the situations where you want to perform an action but don’t want the method to have to return a value, you use a special type called void, so the first line of the method becomes the following:

public void AddTwoNumbers(int NumberOne, int NumberTwo)

Methods get very complex at times, and there are many different ways to parse values into them using parameters.

Add another button called btnCallMethods to your application.

Try adding the code for Listing 10.17, modifying the original button click handler you added for the btnShowResult button. Run the application and click the new button to try and follow the code logic.

        private void btnCallMethods_Click(object sender, RoutedEventArgs e)
        {

            int MyNumber1 = 25;
            int MyNumber2 = 50;

            int AdditionResult = AddTwoNumbers(MyNumber1, MyNumber2);

            this.txtResult.Text = AdditionResult.ToString();
        }

        public int AddTwoNumbers(int NumberOne, int NumberTwo)
        {
            int Result = NumberOne + NumberTwo;
            return Result;
        }

        public int AddTwoNumbers(string NumberOne, string NumberTwo)
        {
            int Result = Convert.ToInt32(NumberOne) + Convert.ToInt32(NumberTwo);
            return Result;
        }

Did you notice that you didn’t have to specify which of the two methods should be used? The compiler is very clever; it works it out based on the types that you are parsing to the method as parameters.

As with most areas of .NET development, there are many ways to achieve the same thing. They all have pros and cons, so the more you understand the different options, the better your chances of making the right decision on which method to implement.

The two methods this book covers are the CLR event and the new RoutedEvent. The simple process of events is described in Figure 10.8.

Figure 10.8. A high-level overview of an event scenario.

The CLR event model works on a concept of “publishers and subscribers.” At any point in an object that you declare an event, that object becomes the event publisher, and any other object that needs to listen for the event becomes a subscriber.

CLR events require an understanding of delegate objects, which in detail is beyond the scope of this chapter, but the concept of the event is the same for both CLR and RoutedEvents.

   public delegate void MyDelegateObject(string Message);

As Figure 10.9 shows, the CLR event travels through to the parent object by way of publicly declared members in each parent object.

Figure 10.9. A CLR event flow.

Think of this as a “bubble” solution.

You now learn how to implement the DoorOpen CLR event, which makes understanding the RoutedEvent much easier.

        public delegate void DoorOpenDelegate(bool IsOpen);
        public event DoorOpenDelegate DoorOpen;

        public void OpenTheDoor()
        {
            this.DoorOpen(true);
        }

The first line in Listing 10.19 shows the delegate object declaration for the event. This declaration says that whichever method() or event uses this object, it returns nothing (void), but a bool value must be provided as a parameter.

The next line declares the actual event:

        public event DoorOpenDelegate DoorOpen;

The scope is set to public so that other objects have access to it and then the keyword event is used to describe what is being declared.

Next you are declaring an instance of the DoorOpenDelegate object and an identifier for it. Think of this being similar to a member variable declaration, such as public string MyString.

Next, is the public method:

        public void OpenTheDoor()
        {
            this.DoorOpen(true);
        }

In the OpenTheDoor() method, you call the identifier of the event DoorOpen. Because it is of type DoorOpenDelegate, you need to parse to it a parameter of type bool. This is called raising the event.

Now that your event is declared and will be raised when the OpenTheDoor() method is called, you need to subscribe to this event in both the object that declared the event (the publisher) and any other objects that want to subscribe to it.

You have not yet added a constructor to your Car class. A constructor is one of the best places to add your subscription declaration.

A constructor is a special method that gets called when a class is first instantiated. The constructor is public in scope and has no return type, but it may have parameters. A constructor with no parameters is called a default constructor.

Add the code for the default Car constructor method, as shown in Listing 10.20.

public Car()
        {
            this.DoorOpen += new DoorOpenDelegate(Car_DoorOpen);
        }

        void Car_DoorOpen(bool IsOpen)
        {
            throw new NotImplementedException();
        }

The first line is the default constructor declaration.

The next line is interesting:

            this.DoorOpen += new DoorOpenDelegate(Car_DoorOpen);

This code shows that the event is handled (+= is a sign for addition) by a method (Car_DoorOpen) that is parsed as a parameter to a new instance of a DoorOpenDelegate.

The method declared below the constructor (known as the EventHandler) has the exact signature of the DoorOpenDelegate object, being that it is void and takes a bool type as a parameter.

Figure 10.10. Press Tab to complete the EventHandler.

Now that you have this event in place, you could add a state handler in the Car class to maintain whether the door is opened or closed, using enums and properties. The event that you added takes a bool, so you could always parse in a false for when the door is not opened. Alternatively, you could really go to town and add an enum for the door states and then use a switch statement to determine which message box to show based on the state of the door in the Car class instance.

RoutedEvents were introduced back in Chapter 8, “An Example Control Using Just the Tools Palette,” when working with the event trigger system in Blend for a button that you had created. The RoutedEvent you create now allows you to subscribe to event notifications in Blend and, therefore, trigger an animation or some other action you desire.

As mentioned in Chapter 8, a RoutedEvent has three different routing strategies that can be employed:

You are going to be adding a Bubbling event in the following code, but as you will see, to employ any of the other two strategies, it is a simple matter of changing a parameter value.

RoutedEvents are generally used in visual elements, such as user controls, because they require the owning object to be derived from the type UIElement to enable a call to the RaiseEvent() method. When working with custom classes that contain no design surface, continue to use CLR events as previously shown.

Compare Figure 10.9 with Figure 10.12 to see the high-level differences between CLR events and RoutedEvents.

Figure 10.12. A RoutedEvent can raise notifications to which any object can subscribe.

public static readonly RoutedEvent TestButtonClickedEvent = EventManager.RegisterRoutedEvent(
            "TestButtonClicked",
            RoutingStrategy.Bubble,
            typeof(RoutedEventHandler),
            typeof(GrandChildControl));

        // Provide CLR accessors for the event
        public event RoutedEventHandler TestButtonClicked
        {
            add { AddHandler(TestButtonClickedEvent, value); }
            remove { RemoveHandler(TestButtonClickedEvent, value); }
        }

Move through the RoutedEvent declaration one line at time, starting at the declaration:

        public static readonly RoutedEvent TestButtonClickedEvent =

This instance is created as a static read-only RoutedEvent. Being static enables you to add handlers for this event when an instance of the Engine class has not been made, which is covered shortly. You can also see that the type is RoutedEvent.

Now onto the next line:

EventManager.RegisterRoutedEvent(

This is a call to a method (of a static object called EventManager) that registers your event with the WPF event system and then returns your RoutedEvent object.

Next is the name of the Event, which is of type string:

            "TestButtonClicked",

Next is the Routing strategy that you wish to employ:

            RoutingStrategy.Bubble,

The required value is an enum type of RoutingStrategy.

Next is the event handler type:

            typeof(RoutedEventHandler),

As a default you should use a RoutedEventHandler. In more advanced scenarios, however, you can create your own types of event handlers.

Next is the owner of the event:

            typeof(GrandChildControl));

This parameter is important, as you will see when adding a handler. Generally, the owner type should be the class in which the event is created.

Below this you see the CLR accessors that are provided for the event:

        public event RoutedEventHandler TestButtonClicked
        {
            add { AddHandler(TestButtonClickedEvent, value); }
            remove { RemoveHandler(TestButtonClickedEvent, value); }
        }

You could think of this as being the same as the public CLR assessors that you added for the Dependency Property example at the start of the chapter. This “wrapper” is what lets you add Handlers for the event in code.

    public partial class Window1
    {
        public Window1()
        {
            this.InitializeComponent();

            // Insert code required on object creation below this point.
            this.AddHandler(GrandChildControl.TestButtonClickedEvent, new
RoutedEventHandler(OnTestButtonClickedEvent));
        }

        void OnTestButtonClickedEvent(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Event Worked!");
        }

The line that you are first interested in is as follows:

this.AddHandler(GrandChildControl.TestButtonClickedEvent, new
RoutedEventHandler(OnTestButtonClickedEvent));

The method AddHandler is built in to the Window type. As you see, this parses in a reference to the static event in the GrandChildControl, which you created previously. The new parameter allows you to declare a method() that will be called when the event is raised.

Because the event handler type you declared in the RoutedEvent declaration is a RoutedEventHandler, you now create a new instance of this type of handler and specify a method name in its constructor, which you do by using the name OnTestButtonClickedEvent. You can name this whatever you like as long as the method signature is the same as what is shown in Listing 10.23 for the method handler void OnTestButtonClickedEvent.

Next is the event handler method:

        void OnTestButtonClickedEvent(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Event Worked!");
        }

As previously mentioned about the WPF event model, the event raised is expecting to parse two parameters: object representing the object that raised the event and the parameters that can be parsed through with the event.

Test the application now by clicking F5 in Visual Studio. With any luck, you should see a message box when you click the Event Test button.

So far, so good. But what you really have here is the same scenario as shown in the CLR example, in which you have a child control referenced in the main Window. The following pushes this further by deepening the levels of children.

Now you have the same scenario shown in Figure 10.12, where you have a control (button) embedded in a control (GrandChildControl) with a RoutedEvent raised from the Click handler. You also now have the GrandChildControl embedded inside another UserControl (ChildControl), which has no event handlers declared. The ChildControl is now embedded as a UserControl of the main Window1.xaml.

You should be able to just run the application by clicking F5 in Blend. Upon clicking the element, you should again get the message box that tells you it worked!

How easy was that? The really big benefit to that also is that now you could create a storyboard in your Window (or ChildControl and GrandChildControl controls) that listens for the TestClickedEvent to be raised. You can’t this do with a CLR event.

For further information on the RoutedEvent object or any of the supporting objects, please see the MSDN library at http://msdn2.microsoft.com/en-us/library/ms742806.aspx.

What is so special about generics is that you specify the type values that are contained within them, so the collection becomes “strongly typed.” That is why you are reading the term List<T>, where the T represents the type. Strongly typed generic collections speed up code performance dramatically when compared with trying to cast or convert objects from arrays.

You declare a List<T> generic using the following syntax:

scope List<T> Identifier;

A valid List of int values would be declared and look something like the following:

private List<int> myIntCollection = new List<int>();

Several methods included with the List type help you to manage the List. In this section you see the most commonly used methods.

The code in Listing 10.24 shows how to add a new int value to a List collection.

private List<int> myIntCollection = new List<int>();

        private void btnListMaker_Click(object sender, RoutedEventArgs e)
        {
            this.myIntCollection.Add(1);
            this.myIntCollection.Add(4);
            this.myIntCollection.Add(5);
            this.myIntCollection.Add(Convert.ToInt32("19"));
        }

In Listing 10.24 a global member List is declared (myIntCollection) as a collection of Ints. That is the only type of object that can be added to the list, as you can see in the method calls:

            this.myIntCollection.Add(5);

The List, or indeed any other Generic collection, does not need to just hold primitive data types, such as int or string. You can create your own objects (such as your Car class) and create a collection of those types of objects as well.

In .NET, when you are thinking about collections or arrays, you need to remember that all collections or arrays are termed as zero-based. This means that the first item in a collection or an array will hold the position 0 in the collection. This is called the item index, or just index, which is important when you start dealing with the collection in terms of finding a specific object.

The following line retrieves the number of items in the collection:

int CollectionCount = this.myIntCollection.Count;

Even though the value returned by the property Count will be 4, in the case of the List created and filled in Listing 10.24, the int object with the value of 1, will be located at position 0 in the collection.

Several methods used by Generic collections require you to know the index of the object that you wish to work with.

This is confusing at first, if you have never counted this way, and it will throw you out at some stage. But hopefully you will see the error of your ways soon enough!

In the situation where you want to specify the position of an object when you are adding to a generic collection, call the insert() method of the collection, specifying the required index position and the object:

    int myInt = 8;
        this.myIntCollection.Insert(1, myInt);

You can also remove objects from the collection by calling the RemoveAt() method and specifying the index of the object to remove:

this.myIntCollection.RemoveAt(0);

In this method call, the object at index or position 0 is being removed, not the object with a value of 0 (if one exists).

Sometimes you may want to remove all the items from the collection, so instead of calling the RemoveAt() method for each item, a call to the Clear() method is all that is required:

this.myIntCollection.Clear();

Using the objects stored in the collection is not terribly difficult, but you need to know the index position of the object. The following line of code shows how an object at index position 2 is assigned to a variable of the same type—int:

int IntAtPosition2 = this.myIntCollection[2];

Notice that square brackets, [ ], are used at the end of the collection to retrieve the object. This assigns the object to the variable IntAtPosition2. This is not a reference, however, so changing the value of the IntAtPosition2 member has no effect on the object stored in the collection.

Generally, working with a List<T> is very simple and very fast, and the methods for adding and removing items are always the same.

Not terribly distant from the List<T> in terms of functionality and methods that are available, the Dictionary is a key pair collection. This means you specify a type to be used as a key and a type to be used as the corresponding value for the item.

Listing 10.25 shows you how to create a simple Dictionary<T,T>, in much the same way as you previously created a List<T>.

private Dictionary<int, string> myDictionary = new Dictionary<int, string>();

        private void btnListMaker_Click(object sender, RoutedEventArgs e)
        {
            this.myDictionary.Add(4, "The number 4");
            this.myDictionary.Add(14, "The number 14");
            this.myDictionary.Add(24, "The number 24");
            this.myDictionary.Add(34, "The number 34");
        }

What is important to understand from Listing 10.25 is that the key of the Dictionary<T,T> should not be confused with the concept of the item index.

Can you add the same objects to a list and a dictionary?

You can always add the same instance of an object at anytime—and as many times as you want to both a List<T> and a Dictionary<T,T>. What you can’t do in the case of a dictionary is create and add the same Key value.

Before you add a new item to your collection (List or Dictionary), you can call a method to check whether it already exists:

            if (!this.myIntCollection.Contains(62))
                this.myIntCollection.Add(62);

For the Dictionary you can check whether the key exists:

if (!this.myDictionary.ContainsKey(15))
                this.myDictionary.Add(15, "The number is 15");

You can also check the value:

            if(!this.myDictionary.ContainsValue("The number 34"))
                this.myDictionary.Add(34, "The number 34");

As previously mentioned, the types used in the collection do not have to be primitive types, such as int and string., You may decide to use your own custom object such as the Car class you worked on in this chapter.

public Dictionary<int, Car> CarsInStock = new Dictionary<int, Car>();

In the preceding code, you can see that the key is specified as an int type and the value is specified as a Car type.

“What is the purpose of this?” you may ask.

Pretend that you have a collection of 100,000 cars, and you need to find the one that Mr. Jones ordered, custom designed to his specifications. You could iterate through the entire list, but this would be time consuming (even more so with complex objects), because you would need to check the properties of each car until you matched the specs.

If you know the key of the object, for example “5552125” (which might be Mr. Jones’s phone number), you could ask the Dictionary to return this value directly, without having to go through every object until you find it, as shown in Figure 10.16.

            Car ClientCar = CarsInStock[5552125];

Figure 10.16. The IntelliSense asking for the key of the collection, which is specifically an int in the CarsInStock collection.

The foreach statement allows you to loop through a type-specific collection at high speed. For example, if you have several objects stored in your Generic collection, you can traverse the collection, changing the value of every object each time the loop works through the collection.

Because the foreach statement allows you to retrieve type-specific references within a collection, you get the entire object back from a collection every time the loop cycles in the statement.

            foreach (Car CarObject in this.CarsInStock.Values )
            {
            }

Note that you need to specify the Values property of the collection if you are iterating a Dictionary<T,T>. The Car object is the class that you previously created; the concept is that a Car object contains details about an instance of the Car—how many wheels, how many doors, engine size, and so on—and it also contains an enum variable type for Manufacturer.

Continuing with the car yard example, this car yard has all the same vehicles from the same manufacturer, safety checked at the same time. Broncos are done on a Tuesday, and Mustang’s are done on a Wednesday.

The code in Listing 10.26 shows a new method being called. This method creates a new instance of the Car class from a set of provided parameters. The method returns the Car instance, which is then added to the Car’s global collection for use in Listing 10.27.

        //Global Dictionary created for the car yard
        public Dictionary<int, Car> CarsInStock = new Dictionary<int, Car>();

        private void btnMakeCars_Click(object sender, RoutedEventArgs e)
        {
            //Simple list of Client references that will be used as a Key in the
collection
            int ClientRef_1 = 5552129;
            int ClientRef_2 = 5553241;
            int ClientRef_3 = 5555481;
            int ClientRef_4 = 5553197;
            int ClientRef_5 = 5558724;

            //Building the collection of clients in the collection
            this.CarsInStock.Add(ClientRef_1, this.MakeNewCar(4, 4, 3,
Car.CarModel.Bronco));
            this.CarsInStock.Add(ClientRef_2, this.MakeNewCar(2, 4, 2,
Car.CarModel.Mustang));
            this.CarsInStock.Add(ClientRef_3, this.MakeNewCar(2, 4, 4,
Car.CarModel.Mustang));
            this.CarsInStock.Add(ClientRef_4, this.MakeNewCar(4, 4, 4,
Car.CarModel.Escort));
            this.CarsInStock.Add(ClientRef_5, this.MakeNewCar(4, 4, 3,
Car.CarModel.Bronco));

            //Allow the cars to be serviced now
            this.btnUpdateServiceStatus.IsEnabled = true;

        }

        /// <summary>
        /// Makes the new car.
        /// </summary>
        /// <param name="NumberOfDoors">The number of doors.</param>
        /// <param name="NumberOfWheels">The number of wheels.</param>
        /// <param name="NumberOfSeats">The number of seats.</param>
        /// <param name="CarModel">The car model.</param>
        /// <returns></returns>
        private Car MakeNewCar(int NumberOfDoors,
            int NumberOfWheels,
            int NumberOfSeats,
            Car.CarModel CarModel)
        {
            Car NewCar = new Car();

            NewCar.NumberOfDoors = NumberOfDoors ;
            NewCar.NumberOfWheels = NumberOfWheels  ;
            NewCar.NumberOfSeats = NumberOfSeats ;

            NewCar.Model = CarModel ;

            return NewCar;

        }

/// <summary>
        /// Handles the Click event of the btnUpdateServiceStatus control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/>
instance containing the event data.</param>
        private void btnUpdateServiceStatus_Click(object sender, RoutedEventArgs e)
        {
            //Determine which car should be serviced
            Car.CarModel ServiceType;

            if (this.radBronco.IsChecked == true)
                ServiceType = Car.CarModel.Bronco;
            else
                ServiceType = Car.CarModel.Mustang ;


            foreach (Car item in this.CarsInStock.Values)
            {
                if (item.Model == ServiceType)
                    item.IsServiced = true;
            }

            MessageBox.Show("All " + ServiceType.ToString() + "'s are now
serviced.");
        }

The code in Listing 10.27 enables the iteration of the collection using a foreach loop, setting the IsServiced status of the Car type as selected by the user with the RadioButtons.

This is a simple enough example, but using foreach is invaluable in data binding management and various other areas of an application. You can use a foreach loop for many other types of collections, not just Generic Lists and Dictionaries. This example showed you how suited the foreach is to a scenario that occurs often in applications.