Lesson 10: Introduction to Built-In Collections Classes

A Name/Value Collection

Introduction

To provide a special type of a dictionary collection, the System.Collections.Specialized namespace defines a class named NameValueCollection:

[SerializableAttribute]
public class NameValueCollection : NameObjectCollectionBase

NameValueCollection is a collection class that uses combinations of strings for each item. As is the case for all dictionary-based collections, this uses combinations of key/value pairs, or rather name/value pairs.

Adding an Item to a Name/Value Collection

As is the case for most collection classes, the method to add an item to a NameValueCollection list is named Add. It comes in two versions. One version is to add an existing NameValueCollection list to the collection. The other classic version uses the following syntax:

public virtual void Add(string name, string value);

When calling this method, pass two strings as arguments. The first argument will become the key and the second argument as value. Here is an example of calling this method:

using System.Web.Mvc;
using System.Collections.Specialized;

namespace Exercises.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            NameValueCollection collegeMajors = new NameValueCollection();

            collegeMajors.Add("CMSC", "Computer Science");
            collegeMajors.Add("IFSM", "Information Systems Management");
            collegeMajors.Add("PSAD", "Public Safety Administration");
            collegeMajors.Add("GRCO", "Graphic Communication");

            return View();
        }
    }
}

Accessing an Item from a Name/Value Collection by Name

To give you access to its items, the NameValueCollection class is equipped with a read-only indexed property that is overloaded with two versions. One of the versions uses the following syntax:

public string this[string name] { get; set; }

When using this version, you should pass an existing name. Here is an example:

using System.Web.Mvc;
using System.Collections.Specialized;

namespace ModelingExercise1.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            NameValueCollection collegeMajors = new NameValueCollection();

            collegeMajors.Add("CMSC", "Computer Science");
            collegeMajors.Add("IFSM", "Information Systems Management");
            collegeMajors.Add("PSAD", "Public Safety Administration");
            collegeMajors.Add("GRCO", "Graphic Communication");

            string major = collegeMajors["PSAD"];

            return View();
        }
    }
}

If you pass a valid name, this property produces the equivalent value. If pass a name that the compiler cannot find in the list, the property produces an empty value.

Accessing an Item from a Name/Value Collection by its Index

The items of a NameValueCollection list are stored in a 0-based indexed collection where from the first value occupies the 0 position, the second value occupies the 1 position, and so on. To support this, the NameValueCollection class is equipped with the following version of its index property:

public string this[int index] { get; }

The integer-based based version allows you to pass a number as parameter. Here is an example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Specialized;
using System.Web.Mvc;

namespace ModelingExercise1.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            NameValueCollection collegeMajors = new NameValueCollection();

            collegeMajors.Add("CMSC", "Computer Science");
            collegeMajors.Add("IFSM", "Information Systems Management");
            collegeMajors.Add("PSAD", "Public Safety Administration");
            collegeMajors.Add("GRCO", "Graphic Communication");

            string college = collegeMajors[2];

            return View();
        }
    }
}

If you pass a positive index that is lower than the total number of items - 1, the compiler produces the equivalent value. If you pass a negative index or one that is higher than the total number of items, the compiler would an System.ArgumentOutOfRangeException exception.

Practical Learning: Introducing Built-In Collection Classes

Start Microsoft Visual Studio
On the main menu, click File -> New -> Project...
In the New Project dialog box, click ASP.NET Web Application (.NET Framework). Change the Name to PayrollPreparation1
Click OK
In the New ASP.NET Web Application dialog box, click the MVC icon and click OK
In the Solution Explorer, right-click Content -> Add -> Style Sheet
Type Payroll
Click OK

Create a few styles as follows:

body {
}

.content       { width:         450px;
                 margin:        auto;  }
.summary       { width:         300px;
                 margin:        auto;  }
.btnFormatting { height:        32px;
                 width:         400px; }
.tbxFormatting { width:         80px;  }
.main-title    { margin:        auto;
                 width:         450px;
                 border-bottom: 2px solid gray; }

In the Solution Explorer, under Views, expand Shared and double-click _Layout.cshtml

Change the document as follows:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Payroll Evaluation :: @ViewBag.Title</title>
    @Styles.Render("~/Content/css")
    @Scripts.Render("~/bundles/modernizr")
<link rel="stylesheet" type="text/css" href="~/Content/Payroll.css" />
</head>
<body>
    <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="container">
            <div class="navbar-header">
                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                </button>
                @Html.ActionLink("Payroll Evaluation", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
            </div>
            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li>@Html.ActionLink("Home", "Index", "Home")</li>
                    <li>@Html.ActionLink("About", "About", "Home")</li>
                    <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                </ul>
            </div>
        </div>
    </div>
    <div class="container body-content">
        @RenderBody()
        <hr />
        <footer>
            <p class="text-center">&copy; @DateTime.Now.Year - Payroll Evaluation</p>
        </footer>
    </div>

    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/bootstrap")
    @RenderSection("scripts", required: false)
</body>
</html>

In the Solution Explorer, right-click Controllers -> Add -> New Scaffolded Item...
In the Add Scaffold dialog box, click MVC 5 Controller - Empty
Click Add
Type PayrollProcessing to get PayrollProcessingController
Click Add

Change the document as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace PayrollPreparation1.Controllers
{
    public class PayrollProcessingController : Controller
    {
        // GET: PayrollProcessing
        public ActionResult Index()
        {
            return View();
        }

        // GET: PayrollStartUp
        public ActionResult PayrollStartUp()
        {
            return View();
        }

        // GET: PayrollProcessing/PayrollPreparation
        public ActionResult PayrollPreparation()
        {
            return View();
        }
    }
}

A Form Collection

Introduction

So far, to get the values from a view to a controller, we passed the names of webcontrols to the necessary action/method. Here is an example:

using System.Web.Mvc;

namespace Exercises.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            return View();
        }

        public ActionResult CreateEmployeeRecord(string EmployeeNumber,
                                                 string FirstName,
                                                 string LastName,
                                                 string HourlySalary)
        {
            return View();
        }
    }
}

The .NET Frameework provides a better solution. ASP.NET MVC makes it possible to consider all of the controls of a webpage as a group. To support the webcontrols of a view, ASP.NET MVC provides a class named FormCollection. It is defined in the System.Web.Mvc namespace. The FormCollection class is derived from the NameValueCollection class that we saw already:

public sealed class FormCollection : NameValueCollection, 
									 IValueProvider

Practical Learning: Introducing Built-In Collection Classes

Change the PayrollPreparation() method as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace PayrollPreparation1.Controllers
{
    public class PayrollProcessingController : Controller
    {
        // GET: PayrollProcessing
        public ActionResult Index()
        {
            return View();
        }

        // GET: PayrollStartUp
        public ActionResult PayrollStartUp()
        {
            return View();
        }

        // GET: PayrollProcessing/PayrollPreparation
        public ActionResult PayrollPreparation(string HourlySalary, string Monday, string Tuesday,
                                               string Wednesday, string Thursday, string Friday)
        {
            return View();
        }
    }
}

In the document, right-click somewhere inside the PayrollStartUp() method and click Add View...
In the dialog box, make sure the text box displays PayrollStartUp and click Add

Create a form as follows:

@{
    ViewBag.Title = "Payroll Start-Up";
}

<h2 class="text-center">Payroll Start-Up</h2>

<hr />

@using (Html.BeginForm("PayrollPreparation", "Home", FormMethod.Post, new { name = "frmPayrollPreparation" }))
{
    <div class="content">
        <table>
            <tr>
                <td>Hourly Salary:</td>
                <td>&nbsp;</td>
            </tr>
        </table>
        <hr />
        <table>
            <tr>
                <td>Monday</td>
                <td>Tusday</td>
                <td>Wednesday</td>
                <td>Thursday</td>
                <td>Friday</td>
            </tr>
            <tr>
                <td>&nbsp;</td>
                <td>&nbsp;</td>
                <td>&nbsp;</td>
                <td>&nbsp;</td>
                <td>&nbsp;</td>
            </tr>
        </table>
    </div>

    <hr />

    <p class="text-center"><input type="submit" name="btnCalculate" class="btnFormatting" value="Calculate" /></p>
}

Creating a Form Collection of Web Controls

When you create a form in a view, the form is automatically equipped with a FormCollection object. Everytime you add a webcontrol to the form and give a name to that control, the control is automatically added to the form's FormCollection list. Here are examples:

@{
    ViewBag.Title = "Create Employee Record";
}

<h2>Create Employee Record</h2>

@using (Html.BeginForm())
{
    <p>Employee #: @Html.TextBox("EmployeeNumber")</p>
    <p>First Name: @Html.TextBox("FirstName")</p>
    <p>Last Name: @Html.TextBox("LastName")</p>
    <p>Hourly Salary: @Html.TextBox("HourlySalary")</p>
}

Practical Learning: Adding an Item to a Name/Value Collection

Change the document as follows:

@{
    ViewBag.Title = "Payroll Start-Up";
}

<h2 class="text-center">Payroll Start-Up</h2>

<hr />

@using (Html.BeginForm("PayrollPreparation", "Home", FormMethod.Post, new { name = "frmPayrollPreparation" }))
{
    <div class="content">
        <table>
            <tr>
                <td>Hourly Salary:</td>
                <td>@Html.TextBox("HourlySalary", null, new { @class = "tbxFormatting" })</td>
            </tr>
        </table>
        <hr />
        <table>
            <tr>
                <td>Monday</td>
                <td>Tusday</td>
                <td>Wednesday</td>
                <td>Thursday</td>
                <td>Friday</td>
            </tr>
            <tr>
                <td>@Html.TextBox("Monday", null, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Tuesday", null, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Wednesday", null, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Thursday", null, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Friday", null, new { @class = "tbxFormatting" })</td>
            </tr>
        </table>
    </div>

    <hr />

    <p class="text-center"><input type="submit" name="btnCalculate" class="btnFormatting" value="Calculate" /></p>
}

Click the PayrollProcessingController.cs tab to access it

Accessing the Objects of a Form Collection

To access the webcontrols of a form in a controller, add a FormCollection parameter to the method action of the view.. Here is an example:

using System.Web.Mvc;

namespace Exercises.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            return View();
        }

        public ActionResult CreateEmployeeRecord(FormCollection collection)
        {
            return View();
        }
    }
}

As it was described for its parent the NameValueCollection class, the items of a FormCollection list can be accessed from one of two indexed properties. If you know the position of an item, you can pass its index to the FormCollection argument. Unlike the NameValueCollection class, if you provide an invalid index, the compiler would throw an exception. Therefore, a better or more precise way is to pass the actual name of a controller.

Practical Learning: Accessing the Form Collection Objects

Change the PayrollPreparation() method as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace PayrollPreparation1.Controllers
{
    public class PayrollProcessingController : Controller
    {
        // GET: PayrollProcessing
        public ActionResult Index()
        {
            return View();
        }

        // GET: PayrollProcessing/PayrollStartUp
        public ActionResult PayrollStartUp()
        {
            return View();
        }

        // GET: PayrollProcessing/PayrollPreparation
        public ActionResult PayrollPreparation(FormCollection collection)
        {
            // Accessing FormCollection items by Name
            double salary = double.Parse(collection["HourlySalary"]);
            double monday = double.Parse(collection["Monday"]);
            double tuesday = double.Parse(collection["Tuesday"]);
            double wednesday = double.Parse(collection["Wednesday"]);
            double thursday = double.Parse(collection["Thursday"]);
            double friday = double.Parse(collection["Friday"]);

            double totalTime = Models.Calculations.Add5(monday, tuesday, wednesday, thursday, friday);

            Models.Payroll preparation = new Models.Payroll(salary, totalTime);

            // Accessing FormCollection items by Index
            ViewBag.Friday = collection[5];
            ViewBag.Monday = collection[1];
            ViewBag.Tuesday = collection[2];
            ViewBag.Thursday = collection[4];
            ViewBag.Wednesday = collection[3];
            ViewBag.HourlySalary = collection[0];

            ViewBag.RegularTime = preparation.RegularTime.ToString("F");
            ViewBag.RegularPay = preparation.RegularPay.ToString("F");
            ViewBag.Overtime = preparation.Overtime.ToString("F");
            ViewBag.OvertimePay = preparation.OvertimePay.ToString("F");
            ViewBag.TotalPay = preparation.NetPay.ToString("F");

            collection.Add("HourlySalary", salary.ToString("F"));

            return View();
        }
    }
}

In the document, right-click inside the PayrollPreparation() method and click Add View...
In the dialog box, make sure the text box displays PayrollPreparation and click Add

Change the PayrollPreparation() method as follows:

@{
    ViewBag.Title = "Payroll Preparation";

    PayrollPreparation1.Controllers.PayrollProcessingController ppc = new PayrollPreparation1.Controllers.PayrollProcessingController();
}

<h2 class="text-center">Payroll Preparation</h2>

<br />

@using (Html.BeginForm())
{
    <div class="content">
        <table>
            <tr>
                <td>Hourly Salary:</td>
                <td>@Html.TextBox("HourlySalary", ViewBag.HourlySalary as string, new { @class = "tbxFormatting" })</td>
            </tr>
        </table>
        <hr />
        <table>
            <tr>
                <td>Monday</td>
                <td>Tuesday</td>
                <td>Wednesday</td>
                <td>Thursday</td>
                <td>Friday</td>
            </tr>
            <tr>
                <td>@Html.TextBox("Monday", ViewBag.Monday as string, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Tuesday", ViewBag.Tuesday as string, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Wednesday", ViewBag.Wednesday as string, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Thursday", ViewBag.Thursday as string, new { @class = "tbxFormatting" })</td>
                <td>@Html.TextBox("Friday", ViewBag.Friday as string, new { @class = "tbxFormatting" })</td>
            </tr>
        </table>
    </div>
    <div class="summary">
        <table>
            <tr>
                <td>&nbsp;</td>
                <td style="text-align: center">Time</td>
                <td style="text-align: center">Pay</td>
            </tr>
            <tr>
                <td>Regular:</td>
                <td style="text-align: center">@Html.TextBox("RegularTime", ViewBag.RegularTime as string, new { @class = "tbxFormatting" })</td>
                <td style="text-align: center">@Html.TextBox("RegularPay", ViewBag.RegularPay as string, new { @class = "tbxFormatting" })</td>
            </tr>
            <tr>
                <td>Overtime:</td>
                <td style="text-align: center">@Html.TextBox("Overtime", ViewBag.PayrollSummary as string, new { @class = "tbxFormatting" })</td>
                <td style="text-align: center">@Html.TextBox("OvertimePay", ViewBag.OvertimePay as string, new { @class = "tbxFormatting" })</td>
            </tr>
            <tr>
                <td>&nbsp;</td>
                <td style="text-align: center">Net Pay:</td>
                <td style="text-align: center">@Html.TextBox("TotalPay", ViewBag.TotalPay as string, new { @class = "tbxFormatting" })</td>
            </tr>
        </table>
    </div>
}

Click the PayrollStartUp.cshtml tab to access it
To execute the project, on the main menu, click Debug -> Start Without Debugging

In the text boxes, enter the values as follows:

Hourly Salary: 24.85
Monday:        8.00
Tuesday:       10.50
Wednesday:     8.00
Thursday:      9.50
Friday:        8.50

Click the Calculate button
Close the browser and return to your programming environment

Introduction to Lists, Again

Overview

To use a list in your web project, you have various options. You can use an array. An array is a list where the number of items is specified in the beginning and cannot change. That is, the list cannot grow nor can it shrink. The second option is to crate a collection class. This can be a waste of time. To assist you with lists, the .NET Framework provides a rich library of collection classes.

Instead of creating your own collection class from scratch, the .NET Framework provides collection classes in the System.Collections and the System.Collections.Generic namespaces. To complement those classes, the framework provides additional classes in a namespaces named System.Collections.Concurrent, System.Collections.ObjectModel, and System.Collections.Specialized. The System.Collections.Concurrent namespace contains classes for an object that is accessed by many threads at the same time. The System.Collections.Specialized namespace contains classes that are primarily used like those in the System.Collections or the System.Collections.Generic namespaces (normal/general lists, dictionaries, strings, etc) but add functionalities for particular needs.

A Collection of Stacked Items

A stack is list of items that follow a certain pattern as follows. Like every list, in the beginning, the collection is empty until an item is added. As the items are added, they behave like plates on a dishwasher: every new item is positioned on top of the previous one. If items are deleted, the item that was added last will also be the first item to be taken out or to be deleted, and the item added last will also be the first to be taken out or deleted. This behavior is referred to as first-in-last-out (or FILO) or last-in-first-out (or LIFO).

To assist you in creating a stacked collection, the System.Collections namespace provides a class named Stack. The System.Collections.Generic namespace provides a class named Stack. In both cases, to add an item to the collection, call a method named Push. Here is an example:

<!DOCTYPE html>
<html>
<head>
<title>Altair Realtors - House Description</title>
</head>
<body>
@{
    Stack<string> singleFamily = new Stack<string>();

    singleFamily.Push("5 Bedrooms and 2 Bthrooms");
    singleFamily.Push("Living Room and Dining Room");
    singleFamily.Push("Finished Basement");
}

</body>
</html>

To get the item that is currently at the top of the stack, call a method named Peek. To remove the item that is currently at the top of the stack, call a method named Pop.

A Series of Queued Items

A queue is a list of aligned items. Think of people arriving at a cashier in a supermarke to to check out. The customer who arrives first at the cashier is the first to be served and therefore the first to leave the supermarket. (Don't overthink it; just consider a perfect world).

To help you create a collection where items are queued, the System.Collections namespace provides a class named Queue. The System.Collections.Generic namespace provides a class named Queue. In both cases, to add an item to the collection, call a method named Enqueue. Here is an example:

<!DOCTYPE html>
<html>
<head>
<title>Human Movements</title>
</head>
<body>
@{
    Queue<string> movements = new Queue<string>();

    movements.Enqueue("Come");
    movements.Enqueue("Stay");
    movements.Enqueue("Leave");
}
</body>
</html>

To know what item is in the front of the list (or line), call a method named Peek. To remove the item that is currently in the front area of the list (or line), call a method named Dequeue.

The Collection Class

Probably the most common or the primary class used to create a collection is the generic List<> class. To complement it with additional functionalities, the System.Collections.ObjectModel namespace provides a generic class named Collection:

public class Collection<T> : IList<T>, ICollection<T>, IEnumerable<T>, 
							 IEnumerable, IList, ICollection,
							 IReadOnlyList<T>, IReadOnlyCollection<T>

Normally, to use this class, you should (or better yet, must) derive a class from it (even if you want/need to leave your new class empty).

Like its counter part the System.Collections.Generic.List<>, the System.Collections.ObjectModel.Collection<T> class implements the System.Collections.Generic.ICollection<> interface. As a result, it has the functionality to add new items, to remove one or all items, to check the existence of an item, or to enumerate the collection. Like the System.Collections.Generic.List<> class, the System.Collections.ObjectModel.Collection<> class provides the ability to insert one item or a range or items in its collection. The System.Collections.ObjectModel.Collection<T> class provides a method named InsertItem. Its syntax is:

protected virtual void InsertItem(int index, T item);

This method allows you to insert a new item in the indicated position.

Probably the most unique functionality that the new class adds to its counterpart is the ability to replace an existing item with another. This is done through a method named SetItem. Its syntax is:

protected virtual void SetItem(int index, T item);

The System.Collections.ObjectModel.Collection<T> class provides an alternative way to remove all items from its list through a method named ClearItems. Its syntax is:

protected virtual void ClearItems();

In order to use this method, you must override it. If you simply want to remove all items from your collection, call the Clear() method from its body. Otherwise, the ClearItems() method is used if there is a particular way you want to clean the collection.

A Name/Value Collection

To provide a special type of a dictionary collection, the System.Collections.Specialized namespace defines a class named NameValueCollection:

[SerializableAttribute]
public class NameValueCollection : NameObjectCollectionBase

public virtual void Add(string name, string value);

When calling this method, pass two strings as arguments. The first argument will become the key and the second argument as value. Here is an example of calling this method:

using System.Web.Mvc;
using System.Collections.Specialized;

namespace Exercises.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            NameValueCollection collegeMajors = new NameValueCollection();

            collegeMajors.Add("CMSC", "Computer Science");
            collegeMajors.Add("IFSM", "Information Systems Management");
            collegeMajors.Add("PSAD", "Public Safety Administration");
            collegeMajors.Add("GRCO", "Graphic Communication");

            return View();
        }
    }
}

To give you access to its items, the NameValueCollection class is equipped with a read-only indexed property that is overloaded with two versions. One of the versions uses the following syntax:

public string this[string name] { get; set; }

When using this version, you should pass an existing name. Here is an example:

using System.Web.Mvc;
using System.Collections.Specialized;

namespace ModelingExercise1.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            NameValueCollection collegeMajors = new NameValueCollection();

            collegeMajors.Add("CMSC", "Computer Science");
            collegeMajors.Add("IFSM", "Information Systems Management");
            collegeMajors.Add("PSAD", "Public Safety Administration");
            collegeMajors.Add("GRCO", "Graphic Communication");

            string major = collegeMajors["PSAD"];

            return View();
        }
    }
}

If you pass a valid name, this property produces the equivalent value. If pass a name that the compiler cannot find in the list, the property produces an empty value.

public string this[int index] { get; }

The integer-based based version allows you to pass a number as parameter. Here is an example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Specialized;
using System.Web.Mvc;

namespace ModelingExercise1.Controllers
{
    public class BusinessController : Controller
    {
        // GET: Business
        public ActionResult Index()
        {
            NameValueCollection collegeMajors = new NameValueCollection();

            collegeMajors.Add("CMSC", "Computer Science");
            collegeMajors.Add("IFSM", "Information Systems Management");
            collegeMajors.Add("PSAD", "Public Safety Administration");
            collegeMajors.Add("GRCO", "Graphic Communication");

            string college = collegeMajors[2];

            return View();
        }
    }
}

Practical Learning: Ending the Lesson

Close your programming environment


Previous	Copyright © 2010-2021, FunctionX	Next