DataTable Classe

Referência

Definição

Namespace:: System.Data

Assembly:: System.Data.Common.dll

Assembly:: System.Data.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa uma tabela de dados na memória.

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitialize, System::ComponentModel::ISupportInitializeNotification, System::Runtime::Serialization::ISerializable, System::Xml::Serialization::IXmlSerializable

public ref class DataTable

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitialize, System::Runtime::Serialization::ISerializable

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitializeNotification, System::Runtime::Serialization::ISerializable, System::Xml::Serialization::IXmlSerializable

public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitialize, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

public class DataTable

[System.Serializable]
public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitialize, System.Runtime.Serialization.ISerializable

[System.Serializable]
public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitialize
    interface ISupportInitializeNotification
    interface ISerializable
    interface IXmlSerializable

type DataTable = class

[<System.Serializable>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitialize
    interface ISerializable

[<System.Serializable>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitializeNotification
    interface ISupportInitialize
    interface ISerializable
    interface IXmlSerializable

[<System.Serializable>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitializeNotification
    interface ISerializable
    interface IXmlSerializable
    interface ISupportInitialize

Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitialize, ISupportInitializeNotification, IXmlSerializable

Public Class DataTable

Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitialize

Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitializeNotification, IXmlSerializable

Herança: Object

MarshalByValueComponent
DataTable

Herança: Object
DataTable

Derivado: System.Data.TypedTableBase<T>

Atributos: SerializableAttribute

Implementações: IListSource ISupportInitialize ISupportInitializeNotification ISerializable IXmlSerializable

Exemplos

O exemplo a seguir cria dois DataTable objetos e um DataRelation objeto e adiciona os novos objetos a um DataSet. Em seguida, as tabelas são exibidas em um DataGridView controle.

// 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");
}

' Put the next line into the Declarations section.
private dataSet As DataSet 
 
Private Sub MakeDataTables()
    ' Run all of the functions. 
    MakeParentTable()
    MakeChildTable()
    MakeDataRelation()
    BindToDataGrid()
End Sub
 
Private Sub MakeParentTable()
    ' Create a new DataTable.
    Dim table As New DataTable("ParentTable")

    ' Declare variables for DataColumn and DataRow objects.
    Dim column As DataColumn 
    Dim row As DataRow 
 
    ' 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.
    Dim PrimaryKeyColumns(0) As DataColumn
    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
    Dim i As Integer
    For i = 0 to 2
       row = table.NewRow()
       row("id") = i
       row("ParentItem") = "ParentItem " + i.ToString()
       table.Rows.Add(row)
    Next i
End Sub
 
Private Sub MakeChildTable()
    ' Create a new DataTable.
    Dim table As New DataTable("childTable")
    Dim column As DataColumn 
    Dim row As DataRow 
 
    ' 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.
    Dim i As Integer
    For i = 0 to 4
       row = table.NewRow()
       row("childID") = i
       row("ChildItem") = "Item " + i.ToString()
       row("ParentID") = 0 
       table.Rows.Add(row)
    Next i
    For i = 0 to 4
       row = table.NewRow()
       row("childID") = i + 5
       row("ChildItem") = "Item " + i.ToString()
       row("ParentID") = 1 
       table.Rows.Add(row)
    Next i
    For i = 0 to 4
       row = table.NewRow()
       row("childID") = i + 10
       row("ChildItem") = "Item " + i.ToString()
       row("ParentID") = 2 
       table.Rows.Add(row)
    Next i
End Sub
 
Private Sub MakeDataRelation()
    ' DataRelation requires two DataColumn 
    ' (parent and child) and a name.
    Dim parentColumn As DataColumn = _
        dataSet.Tables("ParentTable").Columns("id")
    Dim childColumn As DataColumn = _
        dataSet.Tables("ChildTable").Columns("ParentID")
    Dim relation As DataRelation = new _
        DataRelation("parent2Child", parentColumn, childColumn)
    dataSet.Tables("ChildTable").ParentRelations.Add(relation)
End Sub
 
Private Sub BindToDataGrid()
    ' Instruct the DataGrid to bind to the DataSet, with the 
    ' ParentTable as the topmost DataTable.
    DataGrid1.SetDataBinding(dataSet,"ParentTable")
End Sub

Este exemplo demonstra como criar uma DataTable manualmente com definições de esquema específicas:

Crie várias DataTables e defina as colunas iniciais.
Crie as restrições de tabela.
Insira os valores e exiba as tabelas.
Crie as colunas de expressão e exiba as tabelas.

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

Imports System.Data

Class Program
   Public Shared Sub Main(args As String())
      ' Create two tables and add them into the DataSet
      Dim orderTable As DataTable = CreateOrderTable()
      Dim orderDetailTable As DataTable = CreateOrderDetailTable()
      Dim salesSet As 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
         Dim errorRow As DataRow = orderDetailTable.NewRow()
         errorRow(0) = 1
         errorRow(1) = "O0007"
         orderDetailTable.Rows.Add(errorRow)
      Catch e As Exception
         Console.WriteLine(e.Message)
      End Try
      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.
      Dim colSub As New DataColumn("SubTotal", GetType([Decimal]), "Sum(Child.LineTotal)")
      orderTable.Columns.Add(colSub)

      ' Compute the tax by referencing the SubTotal expression column.
      Dim colTax As New DataColumn("Tax", GetType([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.
      Dim colTotal As New DataColumn("TotalDue", GetType([Decimal]), "IIF(OrderId='Total',Sum(SubTotal)+Sum(Tax),SubTotal+Tax)")
      orderTable.Columns.Add(colTotal)

      Dim row As DataRow = 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()
   End Sub

   Private Shared Function CreateOrderTable() As DataTable
      Dim orderTable As New DataTable("Order")

      ' Define one column.
      Dim colId As New DataColumn("OrderId", GetType([String]))
      orderTable.Columns.Add(colId)

      Dim colDate As New DataColumn("OrderDate", GetType(DateTime))
      orderTable.Columns.Add(colDate)

      ' Set the OrderId column as the primary key.
      orderTable.PrimaryKey = New DataColumn() {colId}

      Return orderTable
   End Function

   Private Shared Function CreateOrderDetailTable() As DataTable
      Dim orderDetailTable As New DataTable("OrderDetail")

      ' Define all the columns once.
      Dim cols As DataColumn() = {New DataColumn("OrderDetailId", GetType(Int32)), New DataColumn("OrderId", GetType([String])), New DataColumn("Product", GetType([String])), New DataColumn("UnitPrice", GetType([Decimal])), New DataColumn("OrderQty", GetType(Int32)), New DataColumn("LineTotal", GetType([Decimal]), "UnitPrice*OrderQty")}

      orderDetailTable.Columns.AddRange(cols)
      orderDetailTable.PrimaryKey = New DataColumn() {orderDetailTable.Columns("OrderDetailId")}
      Return orderDetailTable
   End Function

   Private Shared Sub InsertOrders(orderTable As DataTable)
      ' Add one row once.
      Dim row1 As DataRow = orderTable.NewRow()
      row1("OrderId") = "O0001"
      row1("OrderDate") = New DateTime(2013, 3, 1)
      orderTable.Rows.Add(row1)

      Dim row2 As DataRow = orderTable.NewRow()
      row2("OrderId") = "O0002"
      row2("OrderDate") = New DateTime(2013, 3, 12)
      orderTable.Rows.Add(row2)

      Dim row3 As DataRow = orderTable.NewRow()
      row3("OrderId") = "O0003"
      row3("OrderDate") = New DateTime(2013, 3, 20)
      orderTable.Rows.Add(row3)
   End Sub

   Private Shared Sub InsertOrderDetails(orderDetailTable As DataTable)
      ' 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.
      Dim rows As [Object]() = {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}}

      For Each row As [Object]() In rows
         orderDetailTable.Rows.Add(row)
      Next
   End Sub

   Private Shared Sub ShowTable(table As DataTable)
      For Each col As DataColumn In table.Columns
         Console.Write("{0,-14}", col.ColumnName)
      Next
      Console.WriteLine()

      For Each row As DataRow In table.Rows
         For Each col As DataColumn In table.Columns
            If col.DataType.Equals(GetType(DateTime)) Then
               Console.Write("{0,-14:d}", row(col))
            ElseIf col.DataType.Equals(GetType([Decimal])) Then
               Console.Write("{0,-14:C}", row(col))
            Else
               Console.Write("{0,-14}", row(col))
            End If
         Next
         Console.WriteLine()
      Next
      Console.WriteLine()
   End Sub
End Class

Comentários

É DataTable um objeto central na biblioteca ADO.NET. Outros objetos que usam o DataTable incluem o DataSet e o DataView.

Ao acessar DataTable objetos, observe que eles diferenciam maiúsculas de minúsculas condicionalmente. Por exemplo, se um DataTable for chamado de "mydatatable" e outro for chamado "Mydatatable", uma cadeia de caracteres usada para pesquisar uma das tabelas será considerada sensível a maiúsculas de minúsculas. No entanto, se "mydatatable" existir e "Mydatatable" não existir, a cadeia de caracteres de pesquisa será considerada sem diferenciação de maiúsculas de minúsculas. Uma DataSet pode conter dois DataTable objetos que têm o mesmo TableName valor de propriedade, mas valores de propriedade diferentes Namespace . Para obter mais informações sobre como trabalhar com DataTable objetos, consulte Criando uma DataTable.

Se você estiver criando um DataTable programaticamente, primeiro deve definir seu esquema adicionando DataColumn objetos ao DataColumnCollection (acessado por meio da Columns propriedade). Para obter mais informações sobre como adicionar DataColumn objetos, consulte Adicionando colunas a uma DataTable.

Para adicionar linhas a um DataTable, primeiro você deve usar o NewRow método para retornar um novo DataRow objeto. O NewRow método retorna uma linha com o esquema do DataTable, como é definido pela tabela DataColumnCollection. O número máximo de linhas que um DataTable pode armazenar é 16.777.216. Para obter mais informações, consulte Adicionando dados a uma DataTable.

Também DataTable contém uma coleção de Constraint objetos que podem ser usados para garantir a integridade dos dados. Para obter mais informações, consulte Restrições de DataTable.

Há muitos DataTable eventos que podem ser usados para determinar quando as alterações são feitas em uma tabela. Elas incluem RowChanged, RowChanginge RowDeleted RowDeleting. Para obter mais informações sobre os eventos que podem ser usados com um DataTable, consulte Como lidar com eventos datatable.

Quando uma instância é DataTable criada, algumas das propriedades de leitura/gravação são definidas como valores iniciais. Para obter uma lista desses valores, consulte o tópico do DataTable.DataTable construtor.

Observação

O DataSet objeto e DataTable os objetos herdam MarshalByValueComponent e dão suporte à ISerializable interface para .NET Framework comunicação remota. Esses são os únicos objetos ADO.NET que você pode usar para .NET Framework comunicação remota.

Considerações sobre segurança

Para obter informações sobre o DataSet e a segurança do DataTable, consulte as diretrizes de segurança.

Construtores

DataTable()	Inicializa uma nova instância da classe DataTable sem argumentos.
DataTable(SerializationInfo, StreamingContext)	Inicializa uma nova instância da classe DataTable com dados serializados.
DataTable(String)	Inicializa uma nova instância da classe DataTable com o nome da tabela especificada.
DataTable(String, String)	Inicializa uma nova instância da classe DataTable usando o nome de tabela e o namespace especificados.

Campos

fInitInProgress

Verifica se a inicialização está em andamento. A inicialização ocorre no tempo de execução.

Propriedades

CaseSensitive	Indica se a comparação de cadeias de caracteres dentro da tabela diferencia maiúsculas de minúsculas.
ChildRelations	Obtém a coleção das relações filho desta DataTable.
Columns	Obtém a coleção de colunas que pertencem a essa tabela.
Constraints	Obtém a coleção de restrições mantidas por essa tabela.
Container	Obtém o contêiner para o componente. (Herdado de MarshalByValueComponent)
DataSet	Obtém o DataSet ao qual essa tabela pertence.
DefaultView	Obtém uma exibição personalizada da tabela que pode incluir uma exibição filtrada ou uma posição do cursor.
DesignMode	Obtém um valor que indica se o componente está atualmente no modo de design. (Herdado de MarshalByValueComponent)
DisplayExpression	Obtém ou define a expressão que retorna um valor usado para representar essa tabela na interface do usuário. A propriedade `DisplayExpression` permite exibir o nome da tabela em uma interface do usuário.
Events	Obtém a lista de manipuladores de eventos que estão anexados a este componente. (Herdado de MarshalByValueComponent)
ExtendedProperties	Obtém a coleção de informações de usuário personalizadas.
HasErrors	Obtém um valor que indica se há erros em alguma das linhas em uma das tabelas de DataSet a que a tabela pertence.
IsInitialized	Obtém um valor que indica se o DataTable é inicializado.
Locale	Obtém ou define as informações de localidade usadas para comparar cadeias de caracteres na tabela.
MinimumCapacity	Obtém ou define o tamanho inicial para essa tabela.
Namespace	Obtém ou define o namespace da representação XML dos dados armazenados no DataTable.
ParentRelations	Obtém a coleção de relações de pai desta DataTable.
Prefix	Obtém ou define o namespace da representação XML dos dados armazenados no DataTable.
PrimaryKey	Obtém ou define uma matriz de colunas que funcionam como chaves primárias da tabela de dados.
RemotingFormat	Obtém ou define o formato de serialização.
Rows	Obtém a coleção de linhas que pertencem a essa tabela.
Site	Obtém ou define um ISite para o DataTable.
TableName	Obtém ou define o nome de DataTable.

Métodos

AcceptChanges()	Confirma todas as alterações feitas à tabela desde a última vez em que AcceptChanges() foi chamado.
BeginInit()	Começa a inicialização de um DataTable usado em um formulário ou por outro componente. A inicialização ocorre no tempo de execução.
BeginLoadData()	Desativa as notificações, a manutenção de índice e as restrições durante o carregamento de dados.
Clear()	Limpa o DataTable de todos os dados.
Clone()	Clona a estrutura do DataTable, incluindo todos os esquemas e restrições de DataTable.
Compute(String, String)	Calcula a expressão especificada nas linhas atuais que passam os critérios de filtro.
Copy()	Copia a estrutura e os dados para este DataTable.
CreateDataReader()	Retorna um DataTableReader correspondente aos dados nessa DataTable.
CreateInstance()	Cria uma nova instância de DataTable.
Dispose()	Libera todos os recursos usados pelo MarshalByValueComponent. (Herdado de MarshalByValueComponent)
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo MarshalByValueComponent e opcionalmente libera os recursos gerenciados. (Herdado de MarshalByValueComponent)
EndInit()	Encerra a inicialização de um DataTable que é usado em um formulário ou por outro componente. A inicialização ocorre no tempo de execução.
EndLoadData()	Desativa as notificações, a manutenção de índice e as restrições após o carregamento de dados.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetChanges()	Obtém uma cópia do DataTable que contém todas as alterações feitas nele desde que ele foi carregado ou que o AcceptChanges() foi chamado pela última vez.
GetChanges(DataRowState)	Obtém uma cópia do DataTable que contém todas as alterações feitas desde o último carregamento ou desde que AcceptChanges() foi chamado, filtrado por DataRowState.
GetDataTableSchema(XmlSchemaSet)	Esse método retorna uma instância XmlSchemaSet que contém a linguagem WSDL que descreve o DataTable para os Serviços Web.
GetErrors()	Obtém uma matriz de objetos DataRow que contêm erros.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Popula um objeto de informações de serialização com os dados necessários para serializar o DataTable.
GetRowType()	Obtém o tipo de linha.
GetSchema()	Para obter uma descrição desse membro, confira GetSchema().
GetService(Type)	Obtém o implementador do IServiceProvider. (Herdado de MarshalByValueComponent)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
ImportRow(DataRow)	Copia um DataRow em um DataTable, preservando quaisquer configurações de propriedade, bem como os valores originais e atuais.
Load(IDataReader)	Preenche um DataTable com valores de uma fonte de dados usando o IDataReaderfornecido. Se o DataTable já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes.
Load(IDataReader, LoadOption)	Preenche um DataTable com valores de uma fonte de dados usando o IDataReaderfornecido. Se o `DataTable` já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes de acordo com o valor do parâmetro `loadOption`.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Preenche um DataTable com valores de uma fonte de dados usando o IDataReader fornecido comum delegado de tratamento de erro.
LoadDataRow(Object[], Boolean)	Localiza e atualiza uma linha específica. Se nenhuma linha correspondente for encontrada, uma nova linha será criada usando os valores fornecidos.
LoadDataRow(Object[], LoadOption)	Localiza e atualiza uma linha específica. Se nenhuma linha correspondente for encontrada, uma nova linha será criada usando os valores fornecidos.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Merge(DataTable)	Mesclar o DataTable especificado ao DataTable atual.
Merge(DataTable, Boolean)	Mescla o DataTable especificado com o `DataTable` atual, indicando se as alterações no `DataTable` atual devem ser preservadas.
Merge(DataTable, Boolean, MissingSchemaAction)	Mescla o DataTable especificado com o `DataTable` atual, indicando se as alterações e a maneira como manipular o esquema ausente no `DataTable` atual devem ser preservadas.
NewRow()	Cria um novo DataRow com o mesmo esquema que a tabela.
NewRowArray(Int32)	Retorna uma matriz de DataRow.
NewRowFromBuilder(DataRowBuilder)	Cria uma nova linha de uma linha existente.
OnColumnChanged(DataColumnChangeEventArgs)	Aciona o evento ColumnChanged.
OnColumnChanging(DataColumnChangeEventArgs)	Aciona o evento ColumnChanging.
OnPropertyChanging(PropertyChangedEventArgs)	Aciona o evento PropertyChanged.
OnRemoveColumn(DataColumn)	Notifica o DataTable que um DataColumn está sendo removido.
OnRowChanged(DataRowChangeEventArgs)	Aciona o evento RowChanged.
OnRowChanging(DataRowChangeEventArgs)	Aciona o evento RowChanging.
OnRowDeleted(DataRowChangeEventArgs)	Aciona o evento RowDeleted.
OnRowDeleting(DataRowChangeEventArgs)	Aciona o evento RowDeleting.
OnTableCleared(DataTableClearEventArgs)	Aciona o evento TableCleared.
OnTableClearing(DataTableClearEventArgs)	Aciona o evento TableClearing.
OnTableNewRow(DataTableNewRowEventArgs)	Aciona o evento TableNewRow.
ReadXml(Stream)	Lê o esquema XML e dados para o DataTable usando o Stream especificado.
ReadXml(String)	Lê o esquema XML e dados para o DataTable do arquivo especificado.
ReadXml(TextReader)	Lê o esquema XML e dados para o DataTable usando o TextReader especificado.
ReadXml(XmlReader)	Lê o esquema XML e dados no DataTable usando o XmlReader especificado.
ReadXmlSchema(Stream)	Lê um esquema XML para a DataTable usando o fluxo especificado.
ReadXmlSchema(String)	Lê um esquema XML para a DataTable do arquivo especificado.
ReadXmlSchema(TextReader)	Lê um esquema XML para a DataTable usando o TextReader especificado.
ReadXmlSchema(XmlReader)	Lê um esquema XML para a DataTable usando o XmlReader especificado.
ReadXmlSerializable(XmlReader)	Lê de um fluxo XML.
RejectChanges()	Reverte todas as alterações feitas na tabela desde que foi carregado ou desde a última vez em que AcceptChanges() foi chamado.
Reset()	Redefine o DataTable com o estado original. A redefinição remove todos os dados, índices, relações e colunas da tabela. Se um DataSet incluir uma DataTable, a tabela ainda fará parte do DataSet depois que a tabela for redefinida.
Select()	Obtém uma matriz de todos os objetos DataRow.
Select(String)	Obtém uma matriz de todos os objetos DataRow que correspondem aos critérios de filtro.
Select(String, String)	Obtém uma matriz de todos os objetos DataRow que correspondem aos critérios de filtro, na ordem de classificação especificada.
Select(String, String, DataViewRowState)	Obtém uma matriz de todos os objetos DataRow que correspondem ao filtro, na ordem de classificação correspondente ao estado especificado.
ToString()	Obterá o TableName e a DisplayExpression, se houver algum como uma cadeia de caracteres concatenada.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
WriteXml(Stream)	Grava o conteúdo atual do DataTable como XML usando o Stream especificado.
WriteXml(Stream, Boolean)	Grava o conteúdo atual do DataTable como XML usando o Stream especificado. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXml(Stream, XmlWriteMode)	Grava os dados atuais e, opcionalmente, o esquema do DataTable no arquivo especificado usando o XmlWriteMode especificado. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`.
WriteXml(Stream, XmlWriteMode, Boolean)	Grava os dados atuais e, opcionalmente, o esquema do DataTable no arquivo especificado usando o XmlWriteMode especificado. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXml(String)	Grava o conteúdo atual do DataTable como XML usando o arquivo especificado.
WriteXml(String, Boolean)	Grava o conteúdo atual do DataTable como XML usando o arquivo especificado. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXml(String, XmlWriteMode)	Grava os dados atuais e, opcionalmente, o esquema da DataTable usando o arquivo especificado e o XmlWriteMode. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`.
WriteXml(String, XmlWriteMode, Boolean)	Grava os dados atuais e, opcionalmente, o esquema da DataTable usando o arquivo especificado e o XmlWriteMode. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXml(TextWriter)	Grava o conteúdo atual do DataTable como XML usando o TextWriter especificado.
WriteXml(TextWriter, Boolean)	Grava o conteúdo atual do DataTable como XML usando o TextWriter especificado. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXml(TextWriter, XmlWriteMode)	Grava os dados atuais e, opcionalmente, o esquema do DataTable usando o TextWriter e o XmlWriteMode especificados. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`.
WriteXml(TextWriter, XmlWriteMode, Boolean)	Grava os dados atuais e, opcionalmente, o esquema do DataTable usando o TextWriter e o XmlWriteMode especificados. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXml(XmlWriter)	Grava o conteúdo atual do DataTable como XML usando o XmlWriter especificado.
WriteXml(XmlWriter, Boolean)	Grava o conteúdo atual do DataTable como XML usando o XmlWriter especificado.
WriteXml(XmlWriter, XmlWriteMode)	Grava os dados atuais e, opcionalmente, o esquema do DataTable usando o XmlWriter e o XmlWriteMode especificados. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`.
WriteXml(XmlWriter, XmlWriteMode, Boolean)	Grava os dados atuais e, opcionalmente, o esquema do DataTable usando o XmlWriter e o XmlWriteMode especificados. Para gravar o esquema, defina o valor do parâmetro `mode` como `WriteSchema`. Para salvar os dados para a tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXmlSchema(Stream)	Grava a estrutura de dados atual do DataTable como um esquema XML para o fluxo especificado.
WriteXmlSchema(Stream, Boolean)	Grava a estrutura de dados atual do DataTable como um esquema XML para o fluxo especificado. Para salvar o esquema da tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXmlSchema(String)	Grava a estrutura de dados atual do DataTable como um esquema XML para o arquivo especificado.
WriteXmlSchema(String, Boolean)	Grava a estrutura de dados atual do DataTable como um esquema XML para o arquivo especificado. Para salvar o esquema da tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXmlSchema(TextWriter)	Grava a estrutura de dados atual do DataTable como um esquema XML usando o TextWriter especificado.
WriteXmlSchema(TextWriter, Boolean)	Grava a estrutura de dados atual do DataTable como um esquema XML usando o TextWriter especificado. Para salvar o esquema da tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.
WriteXmlSchema(XmlWriter)	Grava a estrutura de dados atual do DataTable como um esquema XML usando o XmlWriter especificado.
WriteXmlSchema(XmlWriter, Boolean)	Grava a estrutura de dados atual do DataTable como um esquema XML usando o XmlWriter especificado. Para salvar o esquema da tabela e todos os descendentes, defina o parâmetro `writeHierarchy` como `true`.

Eventos

ColumnChanged	Ocorre depois que um valor foi alterado para o DataColumn especificado em um DataRow.
ColumnChanging	Ocorre quando um valor está sendo alterado para o DataColumn especificado em um DataRow.
Disposed	Adiciona um manipulador de eventos para escutar o evento Disposed no componente. (Herdado de MarshalByValueComponent)
Initialized	Ocorre após o DataTable ser inicializado.
RowChanged	Ocorre após um DataRow ter sido alterado com êxito.
RowChanging	Ocorre quando uma DataRow está sendo alterada.
RowDeleted	Ocorre depois que uma linha na tabela é excluída.
RowDeleting	Ocorre antes de uma linha na tabela estar prestes a ser excluída.
TableCleared	Ocorre depois que uma DataTable é limpa.
TableClearing	Ocorre quando uma DataTable é limpa.
TableNewRow	Ocorre quando um novo DataRow é inserido.

Implantações explícitas de interface

IListSource.ContainsListCollection	Para obter uma descrição desse membro, confira ContainsListCollection.
IListSource.GetList()	Para obter uma descrição desse membro, confira GetList().
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Popula um objeto de informações de serialização com os dados necessários para serializar o DataTable.
IXmlSerializable.GetSchema()	Para obter uma descrição desse membro, confira GetSchema().
IXmlSerializable.ReadXml(XmlReader)	Para obter uma descrição desse membro, confira ReadXml(XmlReader).
IXmlSerializable.WriteXml(XmlWriter)	Para obter uma descrição desse membro, confira WriteXml(XmlWriter).

Métodos de Extensão

AsDataView(DataTable)	Cria e retorna um objeto DataView habilitado para LINQ.
AsEnumerable(DataTable)	Retorna um objeto IEnumerable<T> em que o parâmetro genérico `T` é DataRow. Esse objeto pode ser usado em uma expressão LINQ ou consulta de método.

Aplica-se a

Acesso thread-safe

Este tipo é seguro para operações de leitura e multithread. Você deve sincronizar todas as operações de gravação.

Confira também

DataTables