[.Net码农].NET Framework 4.5 DataTable 类

最新推荐文章于 2023-05-23 15:49:26 发布

妹子把我们叫二货

最新推荐文章于 2023-05-23 15:49:26 发布

阅读量1.7k

点赞数

分类专栏： .Net码农

.Net码农专栏收录该内容

263 篇文章 0 订阅

订阅专栏

http://msdn.microsoft.com/zh-cn/library/system.data.datatable.aspx

DataTable 类

.NET Framework 4.5

其他版本

5（共 7）对本文的评价是有帮助 - 评价此主题

表示一个内存中数据表。

继承层次结构

System.Object
   System.ComponentModel.MarshalByValueComponent
     System.Data.DataTable
       System.Data.TypedTableBase<T>

命名空间： System.Data
程序集： System.Data（在 System.Data.dll 中）

	名称	说明
	DataTable()	不带参数初始化 DataTable 类的新实例。
	DataTable(String)	用指定的表名初始化 DataTable 类的新实例。
	DataTable(SerializationInfo, StreamingContext)	使用 SerializationInfo 和 StreamingContext 初始化 DataTable 类的新实例。
	DataTable(String, String)	用指定的表名和命名空间初始化 DataTable 类的新实例。

	名称	说明
	CaseSensitive	指示表中的字符串比较是否区分大小写。
	ChildRelations	获取此 DataTable 的子关系的集合。
	Columns	获取属于该表的列的集合。
	Constraints	获取由该表维护的约束的集合。
	Container	获取组件的容器。（继承自 MarshalByValueComponent。）
	DataSet	获取此表所属的 DataSet。
	DefaultView	获取可能包括筛选视图或游标位置的表的自定义视图。
	DesignMode	获取指示组件当前是否处于设计模式的值。（继承自 MarshalByValueComponent。）
	DisplayExpression	获取或设置一个表达式，该表达式返回的值用于表示用户界面中的此表。 DisplayExpression 属性用于在用户界面中显示此表的名称。
	Events	获取附加到该组件的事件处理程序的列表。（继承自 MarshalByValueComponent。）
	ExtendedProperties	获取自定义用户信息的集合。
	HasErrors	获取一个值，该值指示该表所属的 DataSet 的任何表的任何行中是否有错误。
	IsInitialized	获取一个值，该值指示是否已初始化 DataTable。
	Locale	获取或设置用于比较表中字符串的区域设置信息。
	MinimumCapacity	获取或设置该表最初的起始大小。
	Namespace	获取或设置 DataTable 中所存储数据的 XML 表示形式的命名空间。
	ParentRelations	获取该 DataTable 的父关系的集合。
	Prefix	获取或设置 DataTable 中所存储数据的 XML 表示形式的命名空间。
	PrimaryKey	获取或设置充当数据表主键的列的数组。
	RemotingFormat	获取或设置序列化格式。
	Rows	获取属于该表的行的集合。
	Site	获取或设置 DataTable 的 System.ComponentModel.ISite。（重写 MarshalByValueComponent.Site。）
	TableName	获取或设置 DataTable 的名称。

	名称	说明
	AcceptChanges	提交自上次调用 AcceptChanges 以来对该表进行的所有更改。
	BeginInit	开始初始化在窗体上使用或由另一个组件使用的 DataTable。初始化发生在运行时。
	BeginLoadData	在加载数据时关闭通知、索引维护和约束。
	Clear	清除所有数据的 DataTable。
	Clone	克隆 DataTable 的结构，包括所有 DataTable 架构和约束。
	Compute	计算用来传递筛选条件的当前行上的给定表达式。
	Copy	复制该 DataTable 的结构和数据。
	CreateDataReader	返回与此 DataTable 中的数据相对应的 DataTableReader。
	CreateInstance	基础结构。创建 DataTable 的一个新实例。
	Dispose()	释放由 MarshalByValueComponent 使用的所有资源。（继承自 MarshalByValueComponent。）
	Dispose(Boolean)	释放由 MarshalByValueComponent 占用的非托管资源，还可以另外再释放托管资源。（继承自 MarshalByValueComponent。）
	EndInit	结束在窗体上使用或由另一个组件使用的 DataTable 的初始化。初始化发生在运行时。
	EndLoadData	在加载数据后打开通知、索引维护和约束。
	Equals(Object)	确定指定的对象是否等于当前对象。（继承自 Object。）
	Finalize	允许对象在“垃圾回收”回收之前尝试释放资源并执行其他清理操作。（继承自 MarshalByValueComponent。）
	GetChanges()	获取 DataTable 的副本，该副本包含自加载以来或自上次调用 AcceptChanges 以来对该数据集进行的所有更改。
	GetChanges(DataRowState)	获取由 DataRowState 筛选的 DataTable 的副本，该副本包含上次加载以来或调用 AcceptChanges 以来对该数据集进行的所有更改。
	GetDataTableSchema	该方法返回一个包含 Web 服务描述语言 (WSDL) 的 XmlSchemaSet 实例，该语言描述了用作 Web 服务的 DataTable。
	GetErrors	获取包含错误的 DataRow 对象的数组。
	GetHashCode	作为默认哈希函数。（继承自 Object。）
	GetObjectData	用序列化 DataTable 所需的数据填充序列化信息对象。
	GetRowType	基础结构。获取行类型。
	GetSchema	基础结构。有关此成员的说明，请参见 IXmlSerializable.GetSchema。
	GetService	获取 IServiceProvider 的实施者。（继承自 MarshalByValueComponent。）
	GetType	获取当前实例的 Type。（继承自 Object。）
	ImportRow	将 DataRow 复制到 DataTable 中，保留任何属性设置以及初始值和当前值。
	Load(IDataReader)	通过所提供的 IDataReader，用某个数据源的值填充 DataTable。如果 DataTable 已经包含行，则从数据源传入的数据将与现有的行合并。
	Load(IDataReader, LoadOption)	通过所提供的 IDataReader，用某个数据源的值填充 DataTable。如果 DataTable 已包含行，则从数据源传入的数据将根据loadOption 参数的值与现有的行合并。
	Load(IDataReader, LoadOption, FillErrorEventHandler)	通过所提供的使用错误处理委托的 IDataReader 用某个数据源中的值填充 DataTable。
	LoadDataRow(Object[], Boolean)	查找和更新特定行。如果找不到任何匹配行，则使用给定值创建新行。
	LoadDataRow(Object[], LoadOption)	查找和更新特定行。如果找不到任何匹配行，则使用给定值创建新行。
	MemberwiseClone	创建当前 Object 的浅表副本。（继承自 Object。）
	Merge(DataTable)	将指定的 DataTable 与当前的 DataTable 合并。
	Merge(DataTable, Boolean)	将指定的 DataTable 与当前的 DataTable 合并，指示是否在当前的 DataTable 中保留更改。
	Merge(DataTable, Boolean, MissingSchemaAction)	将指定的 DataTable 与当前的 DataTable 合并，指示是否在当前的 DataTable 中保留更改以及如何处理缺失的架构。
	NewRow	创建与该表具有相同架构的新 DataRow。
	NewRowArray	基础结构。返回 DataRow 的数组。
	NewRowFromBuilder	从现有的行创建新行。
	OnColumnChanged	引发 ColumnChanged 事件。
	OnColumnChanging	引发 ColumnChanging 事件。
	OnPropertyChanging	引发 PropertyChanged 事件。
	OnRemoveColumn	通知 DataTable：DataColumn 正在被移除。
	OnRowChanged	引发 RowChanged 事件。
	OnRowChanging	引发 RowChanging 事件。
	OnRowDeleted	引发 RowDeleted 事件。
	OnRowDeleting	引发 RowDeleting 事件。
	OnTableCleared	引发 TableCleared 事件。
	OnTableClearing	引发 TableClearing 事件。
	OnTableNewRow	引发 TableNewRow 事件。
	ReadXml(Stream)	使用指定的 Stream 将 XML 架构和数据读入 DataTable。
	ReadXml(String)	将指定文件中的 XML 架构和数据读入 DataTable 中。
	ReadXml(TextReader)	使用指定的 TextReader 将 XML 架构和数据读入 DataTable。
	ReadXml(XmlReader)	使用指定的 XmlReader 将 XML 架构和数据读入 DataTable。
	ReadXmlSchema(Stream)	使用指定流将 XML 架构读入 DataTable 中。
	ReadXmlSchema(String)	将指定文件中的 XML 架构读入 DataTable 中。
	ReadXmlSchema(TextReader)	使用指定的 TextReader 将 XML 架构读入 DataTable 中。
	ReadXmlSchema(XmlReader)	使用指定的 XmlReader 将 XML 架构读入 DataTable 中。
	ReadXmlSerializable	基础结构。从 XML 流中读取。
	RejectChanges	回滚自该表加载以来或上次调用 AcceptChanges 以来对该表进行的所有更改。
	Reset	将 DataTable 重置为其初始状态。重置将移除表的所有数据、索引、关系和列。如果数据集包含一个数据表，则在重置该表之后，它将仍是数据集的一部分。
	Select()	获取所有 DataRow 对象的数组。
	Select(String)	获取按与筛选条件相匹配的所有 DataRow 对象的数组。
	Select(String, String)	获取按照指定的排序顺序且与筛选条件相匹配的所有 DataRow 对象的数组。
	Select(String, String, DataViewRowState)	获取与排序顺序中的筛选器以及指定的状态相匹配的所有 DataRow 对象的数组。
	ToString	获取 TableName 和 DisplayExpression（如果有一个用作连接字符串）。（重写 MarshalByValueComponent.ToString()。）
	WriteXml(Stream)	使用指定的 Stream 以 XML 格式写入 DataTable 的当前内容。
	WriteXml(String)	使用指定的文件以 XML 格式写入 DataTable 的当前内容。
	WriteXml(TextWriter)	使用指定的 TextWriter 以 XML 格式写入 DataTable 的当前内容。
	WriteXml(XmlWriter)	使用指定的 XmlWriter 以 XML 格式写入 DataTable 的当前内容。
	WriteXml(Stream, Boolean)	使用指定的 Stream 以 XML 格式写入 DataTable 的当前内容。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为true。
	WriteXml(Stream, XmlWriteMode)	使用指定的 XmlWriteMode 将 DataTable 的当前数据写入指定的文件，还可以选择将架构写入指定的文件。若要写架构，请将 mode参数的值设置为 WriteSchema。
	WriteXml(String, Boolean)	使用指定的文件以 XML 格式写入 DataTable 的当前内容。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为true。
	WriteXml(String, XmlWriteMode)	使用指定的文件和 XmlWriteMode，写入 DataTable 的当前数据（还可以选择写入架构）。若要写架构，请将 mode 参数的值设置为WriteSchema。
	WriteXml(TextWriter, Boolean)	使用指定的 TextWriter 以 XML 格式写入 DataTable 的当前内容。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为 true。
	WriteXml(TextWriter, XmlWriteMode)	使用指定的 TextWriter 和 XmlWriteMode 写入 DataTable 的当前数据，还可以选择写入架构。若要写架构，请将 mode 参数的值设置为 WriteSchema。
	WriteXml(XmlWriter, Boolean)	使用指定的 XmlWriter 以 XML 格式写入 DataTable 的当前内容。
	WriteXml(XmlWriter, XmlWriteMode)	使用指定的 XmlWriter 和 XmlWriteMode 写入 DataTable 的当前数据，还可以选择写入架构。若要写架构，请将 mode 参数的值设置为 WriteSchema。
	WriteXml(Stream, XmlWriteMode, Boolean)	使用指定的 XmlWriteMode 将 DataTable 的当前数据写入指定的文件，还可以选择将架构写入指定的文件。若要写架构，请将 mode参数的值设置为 WriteSchema。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为 true。
	WriteXml(String, XmlWriteMode, Boolean)	使用指定的文件和 XmlWriteMode，写入 DataTable 的当前数据（还可以选择写入架构）。若要写架构，请将 mode 参数的值设置为WriteSchema。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为 true。
	WriteXml(TextWriter, XmlWriteMode, Boolean)	使用指定的 TextWriter 和 XmlWriteMode 写入 DataTable 的当前数据，还可以选择写入架构。若要写架构，请将 mode 参数的值设置为 WriteSchema。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为 true。
	WriteXml(XmlWriter, XmlWriteMode, Boolean)	使用指定的 XmlWriter 和 XmlWriteMode 写入 DataTable 的当前数据，还可以选择写入架构。若要写架构，请将 mode 参数的值设置为 WriteSchema。若要保存该表及其所有子代的数据，请将 writeHierarchy 参数设置为 true。
	WriteXmlSchema(Stream)	将 DataTable 的当前数据结构以 XML 架构形式写入指定的流。
	WriteXmlSchema(String)	将 DataTable 的当前数据结构以 XML 架构形式写入指定的文件。
	WriteXmlSchema(TextWriter)	使用指定的 TextWriter 将 DataTable 的当前数据结构编写为 XML 架构。
	WriteXmlSchema(XmlWriter)	使用指定的 XmlWriter 将 DataTable 的当前数据结构以 XML 架构形式写入。
	WriteXmlSchema(Stream, Boolean)	将 DataTable 的当前数据结构以 XML 架构形式写入指定的流。若要保存该表及其所有子代的架构，请将 writeHierarchy 参数设置为true。
	WriteXmlSchema(String, Boolean)	将 DataTable 的当前数据结构以 XML 架构形式写入指定的文件。若要保存该表及其所有子代的架构，请将 writeHierarchy 参数设置为true。
	WriteXmlSchema(TextWriter, Boolean)	使用指定的 TextWriter 将 DataTable 的当前数据结构编写为 XML 架构。若要保存该表及其所有子代的架构，请将 writeHierarchy 参数设置为 true。
	WriteXmlSchema(XmlWriter, Boolean)	使用指定的 XmlWriter 将 DataTable 的当前数据结构以 XML 架构形式写入。若要保存该表及其所有子代的架构，请将 writeHierarchy参数设置为 true。

	名称	说明
	ColumnChanged	在 DataRow 中指定的 DataColumn 的值被更改后发生。
	ColumnChanging	在 DataRow 中指定的 DataColumn 的值发生更改时发生。
	Disposed	添加事件处理程序以侦听组件上的 Disposed 事件。（继承自 MarshalByValueComponent。）
	Initialized	初始化 DataTable 后发生。
	RowChanged	在成功更改 DataRow 之后发生。
	RowChanging	在 DataRow 正在更改时发生。
	RowDeleted	在表中的行已被删除后发生。
	RowDeleting	在表中的行要被删除之前发生。
	TableCleared	清除 DataTable 后发生。
	TableClearing	清除 DataTable 后发生。
	TableNewRow	插入新 DataRow 时发生。

	名称	说明
	AsDataView	创建并返回支持 LINQ 的 DataView 对象。（由 DataTableExtensions 定义。）
	AsEnumerable	返回一个 IEnumerable<T> 对象，其泛型参数 T 为 DataRow。此对象可用在 LINQ 表达式或方法查询中。（由 DataTableExtensions 定义。）

	名称	说明
	fInitInProgress	基础结构。检查是否正在进行初始化。初始化发生在运行时。

	名称	说明
	IListSource.ContainsListCollection	有关此成员的说明，请参见 IListSource.ContainsListCollection。
	IListSource.GetList	有关此成员的说明，请参见 IListSource.GetList。
	IXmlSerializable.GetSchema	有关此成员的说明，请参见 IXmlSerializable.GetSchema。
	IXmlSerializable.ReadXml	有关此成员的说明，请参见 IXmlSerializable.ReadXml。
	IXmlSerializable.WriteXml	有关此成员的说明，请参见 IXmlSerializable.WriteXml。

备注

DataTable 是 ADO.NET 库中的核心对象。其他使用 DataTable 的对象包括 DataSet 和 DataView。

当访问 DataTable 对象时，请注意它们是按条件区分大小写的。例如，如果一个 DataTable 被命名为“mydatatable”，另一个被命名为“Mydatatable”，则用于搜索其中一个表的字符串被认为是区分大小写的。但是，如果“mydatatable”存在而“Mydatatable”不存在，则认为该搜索字符串不区分大小写。一个 DataSet 可以包含两个 DataTable 对象，它们具有相同的 TableName 属性值和不同的 Namespace 属性值。有关使用 DataTable 对象的更多信息，请参见创建 DataTable。

如果正在以编程方式创建 DataTable，则必须先通过将 DataColumn 对象添加到 DataColumnCollection（通过 Columns 属性访问）中来定义其架构。有关添加 DataColumn 对象的更多信息，请参见向数据表中添加列。

若要向 DataTable 中添加行，必须先使用 NewRow 方法返回新的 DataRow 对象。 NewRow 方法返回具有 DataTable 的架构的行，就像由该表的 DataColumnCollection 定义的那样。DataTable 可存储的最大行数是 16,777,216。有关详细信息，请参阅向数据表中添加数据。

DataTable 也包含可用于确保数据完整性的 Constraint 对象的集合。有关详细信息，请参阅数据表约束。

有许多 DataTable 事件可用于确定对表进行更改的时间。这些方法包括 RowChanged、RowChanging、RowDeleting 和 RowDeleted。有关可与 DataTable 一起使用的事件的更多信息，请参见处理 DataTable 事件。

当创建 DataTable 的实例时，某些读/写属性将被设置为初始值。有关这些值的列表，请参见 DataTable.DataTable 构造函数主题。

说明
DataSet 和 DataTable 对象从 MarshalByValueComponent 继承，并支持用于 .NET Framework 远程处理的 ISerializable 接口。它们是唯一可用于 .NET Framework 远程处理的 ADO.NET 对象。

Topic	Location
如何：创建数据表	Visual Studio 中的数据访问
如何：创建数据表	Visual Studio 中的数据访问

示例

下面的示例创建两个 DataTable 对象和一个 DataRelation 对象，并将这些新对象添加到 DataSet 中。这些表随后会显示在 DataGridView 控件中。

// Put the next line into the Declarations section.
private System.Data.DataSet dataSet;

private void MakeDataTables()
{
    // Run all of the functions. 
    MakeParentTable();
    MakeChildTable();
    MakeDataRelation();
    BindToDataGrid();
}

private void MakeParentTable()
{
    // Create a new DataTable.
    System.Data.DataTable table = new DataTable("ParentTable");
    // Declare variables for DataColumn and DataRow objects.
    DataColumn column;
    DataRow row;

    // Create new DataColumn, set DataType, 
    // ColumnName and add to DataTable.    
    column = new DataColumn();
    column.DataType = System.Type.GetType("System.Int32");
    column.ColumnName = "id";
    column.ReadOnly = true;
    column.Unique = true;
    // Add the Column to the DataColumnCollection.
    table.Columns.Add(column);

    // Create second column.
    column = new DataColumn();
    column.DataType = System.Type.GetType("System.String");
    column.ColumnName = "ParentItem";
    column.AutoIncrement = false;
    column.Caption = "ParentItem";
    column.ReadOnly = false;
    column.Unique = false;
    // Add the column to the table.
    table.Columns.Add(column);

    // Make the ID column the primary key column.
    DataColumn[] PrimaryKeyColumns = new DataColumn[1];
    PrimaryKeyColumns[0] = table.Columns["id"];
    table.PrimaryKey = PrimaryKeyColumns;

    // Instantiate the DataSet variable.
    dataSet = new DataSet();
    // Add the new DataTable to the DataSet.
    dataSet.Tables.Add(table);

    // Create three new DataRow objects and add 
    // them to the DataTable
    for (int i = 0; i<= 2; i++)
    {
        row = table.NewRow();
        row["id"] = i;
        row["ParentItem"] = "ParentItem " + i;
        table.Rows.Add(row);
    }
}

private void MakeChildTable()
{
    // Create a new DataTable.
    DataTable table = new DataTable("childTable");
    DataColumn column;
    DataRow row;

    // Create first column and add to the DataTable.
    column = new DataColumn();
    column.DataType= System.Type.GetType("System.Int32");
    column.ColumnName = "ChildID";
    column.AutoIncrement = true;
    column.Caption = "ID";
    column.ReadOnly = true;
    column.Unique = true;

    // Add the column to the DataColumnCollection.
    table.Columns.Add(column);

    // Create second column.
    column = new DataColumn();
    column.DataType= System.Type.GetType("System.String");
    column.ColumnName = "ChildItem";
    column.AutoIncrement = false;
    column.Caption = "ChildItem";
    column.ReadOnly = false;
    column.Unique = false;
    table.Columns.Add(column);

    // Create third column.
    column = new DataColumn();
    column.DataType= System.Type.GetType("System.Int32");
    column.ColumnName = "ParentID";
    column.AutoIncrement = false;
    column.Caption = "ParentID";
    column.ReadOnly = false;
    column.Unique = false;
    table.Columns.Add(column);

    dataSet.Tables.Add(table);

    // Create three sets of DataRow objects, 
    // five rows each, and add to DataTable.
    for(int i = 0; i <= 4; i ++)
    {
        row = table.NewRow();
        row["childID"] = i;
        row["ChildItem"] = "Item " + i;
        row["ParentID"] = 0 ;
        table.Rows.Add(row);
    }
    for(int i = 0; i <= 4; i ++)
    {
        row = table.NewRow();
        row["childID"] = i + 5;
        row["ChildItem"] = "Item " + i;
        row["ParentID"] = 1 ;
        table.Rows.Add(row);
    }
    for(int i = 0; i <= 4; i ++)
    {
        row = table.NewRow();
        row["childID"] = i + 10;
        row["ChildItem"] = "Item " + i;
        row["ParentID"] = 2 ;
        table.Rows.Add(row);
    }
}

private void MakeDataRelation()
{
    // DataRelation requires two DataColumn 
    // (parent and child) and a name.
    DataColumn parentColumn = 
        dataSet.Tables["ParentTable"].Columns["id"];
    DataColumn childColumn = 
        dataSet.Tables["ChildTable"].Columns["ParentID"];
    DataRelation relation = new 
        DataRelation("parent2Child", parentColumn, childColumn);
    dataSet.Tables["ChildTable"].ParentRelations.Add(relation);
}

private void BindToDataGrid()
{
    // Instruct the DataGrid to bind to the DataSet, with the 
    // ParentTable as the topmost DataTable.
    dataGrid1.SetDataBinding(dataSet,"ParentTable");
}

此示例演示如何手动创建 DataTable 具有特定架构定义：

创建多个表并定义初始的列。
创建约束表。
插入值并显示表。
创建列表达式并显示表。

用此代码示例的 C# 和 Visual Basic 项目都可以在开发人员。了中找到。

using System;
using System.Data;

class Program {
   static void Main(string[] args) {
      // Create two tables and add them into the DataSet
      DataTable orderTable = CreateOrderTable();
      DataTable orderDetailTable = CreateOrderDetailTable();
      DataSet salesSet = new DataSet();
      salesSet.Tables.Add(orderTable);
      salesSet.Tables.Add(orderDetailTable);

      // Set the relations between the tables and create the related constraint.
      salesSet.Relations.Add("OrderOrderDetail", orderTable.Columns["OrderId"], orderDetailTable.Columns["OrderId"], true);

      Console.WriteLine("After creating the foreign key constriant, you will see the following error if inserting order detail with the wrong OrderId: ");
      try {
         DataRow errorRow = orderDetailTable.NewRow();
         errorRow[0] = 1;
         errorRow[1] = "O0007";
         orderDetailTable.Rows.Add(errorRow);
      } catch (Exception e) {
         Console.WriteLine(e.Message);
      }
      Console.WriteLine();

      // Insert the rows into the table
      InsertOrders(orderTable);
      InsertOrderDetails(orderDetailTable);

      Console.WriteLine("The initial Order table.");
      ShowTable(orderTable);

      Console.WriteLine("The OrderDetail table.");
      ShowTable(orderDetailTable);

      // Use the Aggregate-Sum on the child table column to get the result.
      DataColumn colSub = new DataColumn("SubTotal", typeof(Decimal), "Sum(Child.LineTotal)");
      orderTable.Columns.Add(colSub);

      // Compute the tax by referencing the SubTotal expression column.
      DataColumn colTax = new DataColumn("Tax", typeof(Decimal), "SubTotal*0.1");
      orderTable.Columns.Add(colTax);

      // If the OrderId is 'Total', compute the due on all orders; or compute the due on this order.
      DataColumn colTotal = new DataColumn("TotalDue", typeof(Decimal), "IIF(OrderId='Total',Sum(SubTotal)+Sum(Tax),SubTotal+Tax)");
      orderTable.Columns.Add(colTotal);

      DataRow row = orderTable.NewRow();
      row["OrderId"] = "Total";
      orderTable.Rows.Add(row);

      Console.WriteLine("The Order table with the expression columns.");
      ShowTable(orderTable);

      Console.WriteLine("Press any key to exit.....");
      Console.ReadKey();
   }

   private static DataTable CreateOrderTable() {
      DataTable orderTable = new DataTable("Order");

      // Define one column.
      DataColumn colId = new DataColumn("OrderId", typeof(String));
      orderTable.Columns.Add(colId);

      DataColumn colDate = new DataColumn("OrderDate", typeof(DateTime));
      orderTable.Columns.Add(colDate);

      // Set the OrderId column as the primary key.
      orderTable.PrimaryKey = new DataColumn[] { colId };

      return orderTable;
   }

   private static DataTable CreateOrderDetailTable() {
      DataTable orderDetailTable = new DataTable("OrderDetail");

      // Define all the columns once.
      DataColumn[] cols ={
                                  new DataColumn("OrderDetailId",typeof(Int32)),
                                  new DataColumn("OrderId",typeof(String)),
                                  new DataColumn("Product",typeof(String)),
                                  new DataColumn("UnitPrice",typeof(Decimal)),
                                  new DataColumn("OrderQty",typeof(Int32)),
                                  new DataColumn("LineTotal",typeof(Decimal),"UnitPrice*OrderQty")
                              };

      orderDetailTable.Columns.AddRange(cols);
      orderDetailTable.PrimaryKey = new DataColumn[] { orderDetailTable.Columns["OrderDetailId"] };
     return orderDetailTable;
   }

   private static void InsertOrders(DataTable orderTable) {
      // Add one row once.
      DataRow row1 = orderTable.NewRow();
      row1["OrderId"] = "O0001";
      row1["OrderDate"] = new DateTime(2013, 3, 1);
      orderTable.Rows.Add(row1);

      DataRow row2 = orderTable.NewRow();
      row2["OrderId"] = "O0002";
      row2["OrderDate"] = new DateTime(2013, 3, 12);
      orderTable.Rows.Add(row2);

      DataRow row3 = orderTable.NewRow();
      row3["OrderId"] = "O0003";
      row3["OrderDate"] = new DateTime(2013, 3, 20);
      orderTable.Rows.Add(row3);
   }

   private static void InsertOrderDetails(DataTable orderDetailTable) {
      // Use an Object array to insert all the rows .
      // Values in the array are matched sequentially to the columns, based on the order in which they appear in the table.
      Object[] rows = {
                                 new Object[]{1,"O0001","Mountain Bike",1419.5,36},
                                 new Object[]{2,"O0001","Road Bike",1233.6,16},
                                 new Object[]{3,"O0001","Touring Bike",1653.3,32},
                                 new Object[]{4,"O0002","Mountain Bike",1419.5,24},
                                 new Object[]{5,"O0002","Road Bike",1233.6,12},
                                 new Object[]{6,"O0003","Mountain Bike",1419.5,48},
                                 new Object[]{7,"O0003","Touring Bike",1653.3,8},
                             };

      foreach (Object[] row in rows) {
         orderDetailTable.Rows.Add(row);
      }
   }

   private static void ShowTable(DataTable table) {
      foreach (DataColumn col in table.Columns) {
         Console.Write("{0,-14}", col.ColumnName);
      }
      Console.WriteLine();

      foreach (DataRow row in table.Rows) {
         foreach (DataColumn col in table.Columns) {
            if (col.DataType.Equals(typeof(DateTime)))
               Console.Write("{0,-14:d}", row[col]);
            else if (col.DataType.Equals(typeof(Decimal)))
               Console.Write("{0,-14:C}", row[col]);
            else
               Console.Write("{0,-14}", row[col]);           
         }
         Console.WriteLine();
      }
      Console.WriteLine();
   }
}