Beginning C# 7 Hands-On - Advanced Language Features

3 (2 reviews total)
By Tom O.
    Advance your knowledge in tech with a Packt subscription

  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Creating a Simple Generics Class

About this book

Beginning C# 7 Hands-On - Advanced Language Features assumes that you've mastered the basic elements of the C# language and that you're now ready to learn the more advanced C# language and syntax, line by line, in a working Visual Studio environment. You'll learn how to code advanced C# language topics including generics, lambda expressions, and anonymous methods.

You'll learn to use query syntax to construct queries and deploy queries that perform aggregation functions. Work with C# and SQL Server 2017 to perform complex joins and stored procedures. Explore advanced file access methods, and see how to serialize and deserialize objects - all by writing working lines of code that you can run within Visual Studio.

This book is designed for beginner C# developers who have mastered the basics now, and anyone who needs a fast reference to using advanced C# language features in practical coding examples. You'll also take a look at C# through web programming with web forms.

By the time you’ve finished this book, you’ll know all the critical advanced elements of the C# language and how to program everything from C# generics to XML, LINQ, and your first full MVC web applications. These are the advanced building blocks that you can then combine to exploit the full power of the C# programming language, line by line.

Publication date:
October 2017
Publisher
Packt
Pages
310
ISBN
9781788294263

 

Chapter 1. Creating a Simple Generics Class

In this chapter, you will look at the basics of making a simple generic class so that one class can operate on many different data types. A great benefit of generics is flexibility.

 

Creating a generics class


Bring up a project, and go to Solution Explorer; right-click, select Add, and click on Class. Name the class GenericsClass; a simple generics class. Then, click on OK. When the Visual Studio message comes up, click on Yes.

For our purposes, you don't need any of the using System lines at the top, nor any of the comments underneath, so delete them. Your initial screen should look like Figure 1.1.1:

Figure 1.1.1: The initial GenericsClass.cs screen

Working with different data types

Now, let's put a <T> symbol after where it says public class GenericsClass, as follows:

public class GenericsClass<T>

This means that this single class can work equally well with several different data types. Next, enter the following beneath the open curly brace under the preceding line:

private T[] vals;

Enter the following comment directly above this line:

//generic array instance variable

In other words, this will operate equally well on doubles, decimals, integers, and so on.

Making parameters that are generic

Now, in the following line, enter the following:

public GenericsClass(T[] input)

As you can see, you can also make parameters that are generic like this one. This is a parameter, input is the name of it, and the type is T. So, it's a generic array.

Next, enter the following between a set of curly braces beneath the preceding line:

vals = input;

Displaying the values

Of course, you should be able to display these values. so, enter the following line beneath the closed curly brace under the vals = input; line:

public string DisplayValues()

To display these values, you'll enter the following between a set of curly braces beneath the preceding line.

First, put in a string, as follows:

string str = null;

Next, declare the string and initialize the value to null.

Then, enter the following directly below this line:

foreach ( T t in vals)

As you can see, the foreach loop here is going to operate. The T object will be a different data type, depending on how we choose to make the object. The t variable, of course, is each specific value inside the vals array.

Next, you will enter the following between a set of curly braces beneath the preceding line:

str += $"<br>Value={t}";

Remember, we use the += operator to accumulate and <br> to push down to the next line. To get the value, of course, we will put in the t variable.

At the end, you want to return this, so you will type the following beneath the closed curly brace under the preceding line:

return str;

That's it. The final version of the GenericsClass.cs file for this chapter, including comments, is shown in the following code block:

//<T> means this class can operate on many different data types
public class GenericsClass<T>
{
    //generic array instance variable
    private T[] vals;//array of T inputs
    public GenericsClass(T[] input)
    {
        //set value of instance variable
        vals = input;
    }
    public string DisplayValues()
    {
        string str = null;//create string to build up display
        foreach(T t in vals)
        {
            //actually accumulate stuff to be displayed
            str += $"<br>Value={t}";
        }
    //return string of outputs to calling code
    return str;
    }
}

Notice that we have a single block of code; this will now operate on integers, doubles, and so on.

 

Adding a button to Default.aspx


Now, let's take a look at Default.aspx. The only thing we really need to do at this time is to add a Button control. For this, go to Toolbox and grab a Button control from there. Drag and drop it below the line beginning with <form id=... (you can delete the <div> lines, as we won't be needing them). Change the text on the Button control to, for example, Display Values. Your complete Default.aspx file should look like the one shown in Figure 1.1.2:

Figure 1.1.2: The complete HTML for this project

Now, go to the Design view. Our very simple interface is shown in Figure 1.1.3:

Figure 1.1.3: Our very simple interface in the Design view

 

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();

Note

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 theDisplay 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.

Note

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.

 

Chapter review


For review, the complete version of the Default.aspx.cs file for this chapter, including comments, is shown in the following code block:

//using is a directive
//System is a name space
//name space is a collection of features that our needs to run
using System;
//public means accessible anywhere
//partial means this class is split over multiple files
//class is a keyword and think of it as the outermost level of grouping
//:System.Web.UI.Page means our page inherits the features of a Page
public partial class _Default : System.Web.UI.Page
{
    protected void Button1_Click(object sender, EventArgs e)
    {
        //in each case below, GenericsClass<...> works equally well with
        //integers, doubles and decimals, among others
        GenericsClass<int> ints = new GenericsClass<int>(new int[] { 1, 2, 3, 4, 5 });
        sampLabel.Text = ints.DisplayValues();
        GenericsClass<double> dubs = new GenericsClass&lt;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 += decs.DisplayValues();
    }
} 
 

Summary


In this chapter, you learned about the basics of making a simple generic class, so that one class can operate on many different data types. A great benefit of generics is flexibility. You created a simple generics class that worked with different data types, made generic parameters, initialized a collection of integers to their array and displayed the results, and then changed the data types in the generics class to doubles and decimals.

In the next chapter, you will learn about generic methods, or methods that can operate on different data types. You will also learn about constraining a method in terms of the data types that it can operate on, so we'll add a concept called constraints.

About the Author

  • Tom O.

    Tom O. has nine years experience as a teacher of mathematics, physics, statistics, and programming. He worked for five years as a database programmer using various technologies such as .NET, Clipper, SQL, SQL Server, SAS, Excel, and others. He is the publisher of one of the most successful programming courses, called "Learn C# With Visual Studio 2013". Currently, he is working as a mathematics and computer science teacher at a college in NY. Related Education: Master of Science in Applied Statistical Computing, Kennesaw State University; Bachelor of Arts, Pure Mathematics, Queens College; Associates of Science in Computer ProgrammingMicroeconomics Certificate, MIT;

    Browse publications by this author

Latest Reviews

(2 reviews total)
Download funktioniert einwandfrei, Bezahlung ebenfalls, Buchinhalt ist interessant und von hoher Qualität. Gerne wieder!
This book was terribly edited. The knowledge was not presented in a very logical way and the writing in the book needed to be checked more thoroughly. Most of the chapters did not provide good reasons for using the features outlined, they were merely presented to the reader. I expect explanations of why choosing a certain language feature is beneficial. For an example of the poor writing, look at this excerpt: "Now remember, delegates serve essentially as function wrappers. Correct? You use them to point to multiple functions, so you can cascade function calls, for example. The same principle holds here. So, for example, to make use of this, enter the following between a set of curly braces under the line beginning with protected void Button1_Click... : Summarize s =" No, I didn't forget to include the rest of the example code, it was missing in the book. And why is the author asking us to agree with him on whether a delegate is a function wrapper? Passive language such as that is the worst type of writing. I would not recommend this book to a colleague.

Recommended For You

Book Title
Unlock this book and the full library for FREE
Start free trial