A column is a technique of categorizing some
values that belong to a table. Based on this, one category from a list of a
video application can be made of video titles. Another category can contain the
years the videos were released. Yet another category can contain a number used
to identify the format of the video. Here is an example of a table:

To create a column, you can first declare a variable of type DataColumn.
The DataColumn class is equipped with five constructors. The default
constructor allows you to create a column without giving details. Here is an
example:

To distinguish them, each column must have a specific and
unique name. The name of a column allows you and the compiler to identify a
particular column. The name must follow the rules of variables in C#. To
specify the object name of a column, when creating it, you can use the second
constructor whose syntax is:

public DataColumn(string name);

This constructor expects as argument the name of the column.
Here is an example:

Based on these descriptions, the minimum information needed to create
a column is a name. If you don't specify a name, a default name is assigned to
the new column.

Operations on the Columns of a Table

Introduction

The
columns of a table are stored in a property called Columns of the DataTable
class. The Columns property is an object of type DataColumnCollection.
The DataColumnCollection class provides everything that is necessary to
create and manage any column. The DataColumnCollection class is in fact a
collection of objects.

Adding a Column to a Table

To make a column part of a table, you must add it to the
table's collection of columns. The DataColumnCollection
class is equipped with a method called Add() that allows you to add
a column to the table.

The DataColumnCollection.Add() method is overloaded
with 3 versions. One of the versions uses the following syntax:

public virtual DataColumn Add();

When called, this create creates a new column and return it.
The compiler would assign a default name to the column. If this is the first
column, it would be named Column1. If it is the second column, it would be named
Column2, and so on. You can still specify or change the name of a column
created with the above version of the Add() method. To do this, assign the desired string to the DataColumn.ColumnName.
Here is an example:

Instead of adding one column (at a time) to a table, you can
first create an array of columns and add that array to the collection of
columns. To do this, you can call the DataColumnCollection.AddRange()
method. Its syntax is:

public void AddRange(DataColumn[] columns);

This method takes as argument an array of predefined
columns. Here is an example:

If you create an application that allows the
user to enter some values for the above list of videos, you would wish the user
enter the right type of data under each column. To assist you with, the DataColumn class allows you to specify
an appropriate or desired data type for each column. Just as done in other regular
applications, the data types of a table allow its columns to accept or reject
inappropriate values. Although we saw that the name was the most important
aspect of a column, in reality, a data type is also required.

To supports data types for a column, the DataColumn
class relies on the following .NET Framework structures we have used in previous
lessons: Boolean, Byte , Char, DateTime, Decimal,
Double, Int16, Int32, Int64, SByte, Single,
String, TimeSpan, UInt16, UInt32, and UInt64.
The DataColumn class can also support an array of Byte values, as
in Byte[], for a column.

When creating a new column, if
you don't specify its data type, it is assumed to be a string and
the string data type is automatically applied to it. To specify the data type of a column, you have two main
alternatives. When declaring a column, to specify its data type, you can
initialize the DataColumn variable using the third constructor of the
class. Its syntax is:

public DataColumn(string columnName, Type dataType);

To specify a column's data type, select one from the Type
class of the System namespace by calling the Type.GetType() method. The GetType()
method is overloaded with three versions. The first version has the following
syntax:

public static Type GetType(string typeName);

This method expects as argument a valid data type defined in
the .NET Framework. The data type must be retrieved from the Type class of the
System namespace. The name of the data type must be qualified with a period
operator. Here is an example:

Column maintenance consists of adding one or more columns to
a table, identifying an existing column in a table, looking for a column in a
table, deleting one column or deleting all columns of a table. All these
operations are easily supported by the various classes of the System.Data
namespace.

The Parent Table of a Column

You are probably now familiar with the relationships among
the data set, the table and the columns. Just in case:

A table belongs to a data set and not the contrary. Also, you can create
and use a data set without creating a table

A column must belong to a table. A table without at least one column is no
table at all. It is useless

When using the information stored in a table we will learn
when studying records, sometimes you will need to identify the table that owns a
particular column you are accessing. This information can be provided by the Table
property of the DataColumn class.

Identifying a Column

Once again, remember that the group of columns of a table is
an object of type DataColumnCollection. The DataColumnCollection
class implements the GetEnumerator() method of the IEnumerable
interface. This allows you to enumerate the columns of a table using foreach.

Application: Listing the Columns of a table

To be able to list the columns of a table, change the videos.cs file as
follows:

If you happen to have an undesired column in a table, you
can delete it. To perform this operation, the DataColumnCollection class
provides the Remove() method. This method is overloaded in two versions.
One of them uses the following syntax:

public void Remove(string name);

This method expects the name of a column as argument. If the
table has that column, the column would be deleted. Here is an example:

If there is no column with the name passed as argument to
the DataColumnCollection.Remove() method, the compiler would throw an ArgumentException
exception. As this can only be undesirable, the DataColumnCollection
class allows you to check the existence of the column on the table. This is done
by calling the Contains() method whose syntax is:

Even if the table contains that column, it may not allow the
column to be be deleted. For this reason, you should first check that the table
allows that the column be deleted. To assist you with checking this, the DataColumnCollection
class is equipped with the CanRemove() method. Its syntax is:

public bool CanRemove(DataColumn column);

Deleting a Column by Index

The columns of a table are arranged in an indexed list with
the first (the most left) column at index 0, the second (from left) at index 1,
and so on. To delete a column based on its index, you can call the DataColumnCollection.RemoveAt()
method. Its syntax is:

public void RemoveAt(int index);

The index of the column is passed to this method. When
calling this method, make sure you pass a valid index that is an integer greater
than or equal to 0 but less than the DataColumnCollection.Count - 1. Here
is an example:

If you pass a negative index of a number >= DataColumnCollection.Count,
the compiler would throw an IndexOutOfRangeException exception. If you
know the object name of the column, you can first get its index by calling the DataColumnCollection.IndexOf()
method and then pass its returned value to the RemoveAt() method.

Clearing the Table of Columns

To delete all columns from a table, you can call the DataColumnCollection.Clear()
method. Its syntax is:

public void Clear();

After this method has been called, all columns from the
table are deleted.