C# DataRow Examples

DataRow represents a row in a DataTable. It is introduced by the System.Data namespace. It is added or removed from DataTables. It provides a useful container for structured referential data.

This C# tutorial shows the DataRow type from the System.Data namespace. It covers getting, adding and removing rows.

Add DataRow

When using a DataTable you are building in memory, you will almost certainly need to add DataRows. This example method shows how to first add DataColumns. It then shows how to add five DataRows with the fields indicated in those columns. The DataTable is populated with five rows, each a separate dog.

Program that uses DataRow [C#]

static DataTable GetTable()
{
    // Here we create a DataTable with four columns.
    DataTable table = new DataTable();
    table.Columns.Add("Weight", typeof(int));
    table.Columns.Add("Name", typeof(string));
    table.Columns.Add("Breed", typeof(string));
    table.Columns.Add("Date", typeof(DateTime));

    // Here we add five DataRows.
    table.Rows.Add(57, "Koko", "Shar Pei", DateTime.Now);
    table.Rows.Add(130, "Fido", "Bullmastiff", DateTime.Now);
    table.Rows.Add(92, "Alex", "Anatolian Shepherd Dog", DateTime.Now);
    table.Rows.Add(25, "Charles", "Cavalier King Charles Spaniel", DateTime.Now);
    table.Rows.Add(7, "Candy", "Yorkshire Terrier", DateTime.Now);
    return table;
}

Result
    (The DataTable contains five rows.)

Add method signature. The Rows collection, which is a DataRowCollection instance, declares an Add method that receives an object[] array. The object array must have an equal number of elements to the DataColumn fields. You can see the next example for object array.

Object array for DataRow

To continue, we see how you can create an explicit object array before adding it to your DataRowCollection on your DataTable. This is useful for when you need to construct the values programmatically, or pass the arrays around in methods. Please note that the object array here has an array Length equal to the number of columns. Object arrays can store varying element types in their contents.

Program that uses object array with DataTable [C#]

using System;
using System.Data;

class Program
{
    static void Main()
    {
	DataTable table = GetTable();
	//
	// We can instantiate a new object array and add it as a row.
	//
	object[] array = new object[4];
	array[0] = 7;
	array[1] = "Candy";
	array[2] = "Yorkshire Terrier";
	array[3] = DateTime.Now;
	table.Rows.Add(array);
    }
}

Result
    (The DataTable has one row.)

Get DataRow

Sometimes you will need to obtain a reference to a DataRow in your DataTable. This reference can be used for calling the Delete method or other methods, or for passing it as a parameter to methods. Here we see how you can use the Rows indexer, Rows[0], to get the first row. Next we get the last row in the Rows collection by subtracting 1 from the Count.

Program that gets DataRows [C#]

using System;
using System.Data;

class Program
{
    static void Main()
    {
	//
	// Get the first row from the DataTable.
	//
	DataTable table = GetTable();
	DataRow row = table.Rows[0];
	Console.WriteLine(row["Breed"]);
	//
	// Get the last row in the DataTable.
	//
	DataRow last = table.Rows[table.Rows.Count - 1];
	Console.WriteLine(last["Breed"]);

    }
}

Output

Shar Pei
Yorkshire Terrier

Loop through cells

Every DataRow will contain cells or fields, and quite often you will need to examine these values while using DataTables in memory. Here we see an example of how you can access the ItemArray on a DataRow, and then test each field in that row. Note that you can get strongly-typed fields using the Field method.

Program that uses foreach on DataRow [C#]

using System;
using System.Data;

class Program
{
    static void Main()
    {
	//
	// Get the first row and loop over its ItemArray.
	//
	DataTable table = GetTable();
	DataRow row = table.Rows[0];
	foreach (object item in row.ItemArray)
	{
	    if (item is int)
	    {
		Console.WriteLine("Int: {0}", item);
	    }
	    else if (item is string)
	    {
		Console.WriteLine("String: {0}", item);
	    }
	    else if (item is DateTime)
	    {
		Console.WriteLine("DateTime: {0}", item);
	    }
	}
    }
}

Output

Int: 57
String: Koko
String: Shar Pei
DateTime: 4/6/2009 4:10:31 PM

Is keyword. In this loop, we do not know what the exact type of each field in the ItemArray is. We can loop over the ItemArray with the foreach loop and then test each field. This is useful when developing methods that have to deal with flawed or invalid data. You can find more detailed information on foreach-loops on DataRows on this site.

Remove rows

You will find that there are Remove and RemoveAt methods on the DataRow collection. These function differently, but in both cases you must be certain after Remove that you are accessing valid data. In the next example, we remove the first row using Remove. If you try to access the DataRow, the runtime will throw an exception.

Program that removes DataRow [C#]

using System;
using System.Data;

class Program
{
    static void Main()
    {
	//
	// Get the first row for the DataTable
	//
	DataTable table = GetTable();
	//
	// Get the row and remove it.
	//
	DataRow row = table.Rows[0];
	table.Rows.Remove(row);
	//
	// You cannot access row[0] now.
	//
    }
}

Note. Just as a reminder, the exceptions are there to help you debug your program quicker. Don't let your blood pressure rise too much when you see them. Here is the exception raised by the above example.

Unhandled Exception: System.Data.RowNotInTableException: This row has been removed from a table and does not have any data. BeginEdit() will allow creation of new data in this row.

Delete DataRows

In addition to Remove, the DataRow collection has a Delete instance method. This will cleanly delete that DataRow. When you try to access that row's index, you will get the next row. In other words, the DataRow erases the row and you cannot access it all after you call Delete.

Program that deletes DataRow [C#]

using System;
using System.Data;

class Program
{
    static void Main()
    {
	//
	// Get the first row for the DataTable
	//
	DataTable table = GetTable();
	DataRow row = table.Rows[0];
	//
	// Delete the first row. This means the second row is the first row.
	//
	row.Delete();
	//
	// Display the new first row.
	//
	row = table.Rows[0];
	Console.WriteLine(row["Name"]);
    }
}

Output

Fido

Field extension

There is a Field generic method on DataRow that you can use to get strongly typed fields without any casting. This provides clearer code and exploits the power of generic collections that were introduced in .NET. You can, for example, access int, string, and DateTime fields using the Field method.

The type parameter, in sharp brackets, accepts the field type, while the function parameter accepts the field index. You can read more about the Field extension method on this site.

Summary

We saw lots of ways you can use DataRow in your C# program. This is a powerful collection in System.Data that will greatly help your program and keep its code understandable. The DataRow is used in almost every program that also uses the DataTable type.