Initializing a collection of integers to their array and displaying the results

Now, double-click on the Display Values button and go into Default.aspx.cs. Delete the Page_Load block. Next, between the set of curly braces beneath the line beginning with protected void Button1_Click..., enter the following:

GenericsClass<int> ints = new GenericsClass<int>(new int[] { 1, 2, 3, 4, 5 });

You can see in this line that we are basically initializing a collection of integers to their array.

Now, you can display this. So, for example, you can enter the following below this line:

sampLabel.Text += ints.DisplayValues();

Notice that the GenericsClass which we have constructed is operating in integers, but it can operate equally well on any other data type.

Changing the data types in our generics class

Now, to make the code efficiency more obvious, take both of the preceding lines, copy them (Ctrl + C) and paste them (Ctrl + V) beneath these and just change it to double, as follows:

GenericsClass<double> dubs = new GenericsClass<double>(new double[] {1, 2, 3, 4, 5});
sampLabel.Text = ints.DisplayValues();

We'll call this one dubs and change the name here to double: it's the same code, the same class, and the same generic class that you can operate on the doubles. Again, to emphasize this one more time, and to see that flexibility and code reuse is really the purpose here; that is, the ability to reuse code, we'll now take both of these new lines, copy and paste them below once more, and just change double to decimal, as follows:

GenericsClass<decimal> decs = new GenericsClass<decimal>(new decimal[] { 1, 2, 3, 4, 5 });
sampLabel.Text = ints.DisplayValues();

Let's call this one decs. Now, of course, if you want to make things a little more interesting, you can throw in some decimals:

GenericsClass<double> dubs = new GenericsClass<double>(new double[] { 1.0, -2.3, 3, 4, 5 });
sampLabel.Text = ints.DisplayValues();
GenericsClass<decimal> decs = new GenericsClass<decimal>(new decimal[] { 1, 2.0M, 3, 4, 5.79M });
sampLabel.Text = ints.DisplayValues();

With decimals, just make sure that you put the M suffix in there, because you need the M suffix at the end to indicate that it's a decimal.

Running the program

Now, let's take a look. When you run this code and click on the Display Values button, your screen will look like the one shown in Figure 1.1.4:

Figure 1.1.4: The initial run of our code

Accumulating the input

Now, we will accumulate the input. So, in the following sampLabel.Text lines, we change the = sign to +=, as shown here:

GenericsClass<double> dubs = new GenericsClass<double>(new double[] { 1.0, -2.3, 3, 4, 5 });
sampLabel.Text += ints.DisplayValues();
GenericsClass<decimal> decs = new GenericsClass<decimal>(new decimal[] { 1, 2.0M, 3, 4, 5.79M });
sampLabel.Text += ints.DisplayValues();

Let's run it one more time. Click on the Display Values button and your screen will now look like the one shown in Figure 1.1.5:

Figure 1.1.5: The input is now being accumulated, and the values are showing as expected

The program is now working as expected.

So, the big idea of generics at this point is that you can define a generic class. This class can operate equally well on many different data types. For example, you can make a generic class that operates on integers as well as on doubles and decimals.

This step isn't strictly required, but here's a little bit of additional insight. If you want to, you can set a breakpoint as follows. Select the line with the open curly brace under the line beginning with protected void Button1_Click.... Now, go to Debug | Step Into (F11) and click on Display Values.

Now, we will go through it. So, to first step into it, hover your mouse over the T object in the following line in Generics Class.cs:

public GenericsClass(T[] input)

Here, T is essentially like a parameter, so it does have a certain value, which is expressed in the vals = input; line. The first time, T is used for integers. This is how you can step through this code. At the bottom of the screen, the values inside the array are displayed, as shown in Figure 1.1.6:

Figure 1.1.6: The values inside the array

The t variable, as you can see in Figure 1.1.7, is an integer, and this is how it operates:

Figure 1.1.7: The t is an integer

Notice also in the screenshot that it's a generics class with an <int> datatype.

The T object in the foreach(T t in vals) line right now represents an integer, and so on for the other data types. So, flexibility of code and reuse of code means that you will write less code. If not for generics, you would have to create individual classes to handle each different data type.