DataTable Classe

Référence

Définition

Espace de noms:: System.Data

Assembly:: System.Data.Common.dll

Assembly:: System.Data.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente une table de données en mémoire.

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

Héritage: Object

MarshalByValueComponent
DataTable

Héritage: Object
DataTable

Dérivé: System.Data.TypedTableBase<T>

Attributs: SerializableAttribute

Implémente: IListSource ISupportInitialize ISupportInitializeNotification ISerializable IXmlSerializable

Exemples

L’exemple suivant crée deux DataTable objets et un DataRelation objet et ajoute les nouveaux objets à un DataSet. Les tables sont ensuite affichées dans un DataGridView contrôle.

// 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

Cet exemple montre comment créer un DataTable manuellement avec des définitions de schéma spécifiques :

Créez plusieurs DataTables et définissez les colonnes initiales.
Créez les contraintes de table.
Insérez les valeurs et affichez les tables.
Créez les colonnes d’expression et affichez les tables.

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

Remarques

Il DataTable s’agit d’un objet central dans la bibliothèque ADO.NET. Autres objets qui utilisent l’include DataTable the DataSet and the DataView.

Lors de l’accès aux DataTable objets, notez qu’ils respectent la casse conditionnelle. Par exemple, si l’un DataTable est nommé « mydatatable » et qu’un autre est nommé « Mydatatable », une chaîne utilisée pour rechercher l’une des tables est considérée comme sensible à la casse. Toutefois, si « mydatatable » existe et « Mydatatable » ne le fait pas, la chaîne de recherche est considérée comme insensible à la casse. Un DataSet peut contenir deux DataTable objets qui ont la même TableName valeur de propriété, mais des valeurs de propriété différentes Namespace . Pour plus d’informations sur l’utilisation d’objets DataTable , consultez Création d’un DataTable.

Si vous créez un DataTable schéma par programmation, vous devez d’abord définir son schéma en ajoutant des DataColumn objets au DataColumnCollection (accessible via la Columns propriété). Pour plus d’informations sur l’ajout d’objets, consultez Ajout DataColumn de colonnes à un DataTable.

Pour ajouter des lignes à un DataTable, vous devez d’abord utiliser la NewRow méthode pour renvoyer un nouvel DataRow objet. La NewRow méthode retourne une ligne avec le schéma du DataTable, tel qu’il est défini par les tables DataColumnCollection. Le nombre maximal de lignes qu’un DataTable magasin peut stocker est de 16 777 216. Pour plus d’informations, consultez Ajout de données à un DataTable.

Il DataTable contient également une collection d’objets Constraint qui peuvent être utilisés pour garantir l’intégrité des données. Pour plus d’informations, consultez Contraintes DataTable.

Il existe de nombreux DataTable événements qui peuvent être utilisés pour déterminer quand des modifications sont apportées à une table. Il s'agit notamment de RowChanged, RowChanging, RowDeleting et RowDeleted. Pour plus d’informations sur les événements qui peuvent être utilisés avec un DataTable, consultez Gestion des événements DataTable.

Lorsqu’une instance d’une instance est DataTable créée, certaines des propriétés en lecture/écriture sont définies sur les valeurs initiales. Pour obtenir la liste de ces valeurs, consultez la DataTable.DataTable rubrique du constructeur.

Notes

Les DataSet objets et héritent DataTable de MarshalByValueComponent l’interface ISerializable pour .NET Framework communication à distance. Il s’agit des seuls objets ADO.NET que vous pouvez utiliser pour .NET Framework communication à distance.

Considérations relatives à la sécurité

Pour plus d’informations sur la sécurité DataSet et DataTable, consultez conseils sur la sécurité.

Constructeurs

DataTable()	Initialise une nouvelle instance de la classe DataTable sans argument.
DataTable(SerializationInfo, StreamingContext)	Initialise une nouvelle instance de la classe DataTable avec des données sérialisées.
DataTable(String)	Initialise une nouvelle instance de la classe DataTable avec le nom de table spécifié.
DataTable(String, String)	Initialise une nouvelle instance de la classe DataTable avec le nom de table et l'espace de noms spécifiés.

Champs

fInitInProgress

Vérifie si l'initialisation est en cours. L'initialisation se produit au moment de l'exécution.

Propriétés

CaseSensitive	Indique si les comparaisons de chaînes au sein de la table respectent la casse.
ChildRelations	Obtient la collection des relations enfants de ce DataTable.
Columns	Obtient la collection des colonnes qui appartiennent à cette table.
Constraints	Obtient la collection de contraintes gérée par cette table.
Container	Obtient le conteneur du composant. (Hérité de MarshalByValueComponent)
DataSet	Obtient le DataSet auquel cette table appartient.
DefaultView	Obtient une vue personnalisée de la table qui peut comprendre une vue filtrée ou une position de curseur.
DesignMode	Obtient une valeur indiquant si le composant est actuellement en mode design. (Hérité de MarshalByValueComponent)
DisplayExpression	Obtient ou définit l'expression qui retourne une valeur utilisée pour représenter cette table dans l'interface utilisateur. La propriété `DisplayExpression` vous permet d'afficher le nom de cette table dans une interface utilisateur.
Events	Obtient la liste des gestionnaires d'événements attachés à ce composant. (Hérité de MarshalByValueComponent)
ExtendedProperties	Obtient la collection d'informations utilisateur personnalisées.
HasErrors	Obtient une valeur indiquant s'il existe des erreurs dans une des lignes d'une table du DataSet auquel appartient la table.
IsInitialized	Obtient une valeur qui indique si DataTable est initialisé.
Locale	Obtient ou définit les paramètres régionaux utilisés pour comparer des chaînes dans la table.
MinimumCapacity	Obtient ou définit la taille de départ initiale pour cette table.
Namespace	Obtient ou définit l'espace de noms de la représentation XML des données stockées dans le DataTable.
ParentRelations	Obtient la collection des relations parentes de ce DataTable.
Prefix	Obtient ou définit l'espace de noms de la représentation XML des données stockées dans le DataTable.
PrimaryKey	Obtient ou définit un tableau de colonnes qui fonctionnent comme des clés primaires pour la table de données.
RemotingFormat	Obtient ou définit le format de sérialisation.
Rows	Obtient la collection des lignes qui appartiennent à cette table.
Site	Obtient ou définit un élément ISite pour l'élément DataTable.
TableName	Obtient ou définit le nom de l'objet DataTable.

Méthodes

AcceptChanges()	Valide toutes les modifications apportées à cette table depuis le dernier appel à AcceptChanges().
BeginInit()	Commence l'initialisation d'un DataTable qui est utilisé dans un formulaire ou par un autre composant. L'initialisation se produit au moment de l'exécution.
BeginLoadData()	Désactive les notifications, la gestion d'index et les contraintes lors du chargement de données.
Clear()	Efface toutes les données de DataTable.
Clone()	Clone la structure de DataTable, y compris tous les schémas et contraintes DataTable.
Compute(String, String)	Calcule l'expression donnée sur les lignes en cours qui passent les critères du filtre.
Copy()	Copie à la fois la structure et les données de ce DataTable.
CreateDataReader()	Retourne un DataTableReader correspondant aux données dans ce DataTable.
CreateInstance()	Crée une instance de DataTable.
Dispose()	Libère toutes les ressources utilisées par MarshalByValueComponent. (Hérité de MarshalByValueComponent)
Dispose(Boolean)	Libère les ressources non managées utilisées par MarshalByValueComponent et libère éventuellement les ressources managées. (Hérité de MarshalByValueComponent)
EndInit()	Termine l'initialisation d'un DataTable qui est utilisé dans un formulaire ou par un autre composant. L'initialisation se produit au moment de l'exécution.
EndLoadData()	Active les notifications, la gestion d'index et les contraintes après le chargement de données.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetChanges()	Obtient une copie du DataTable qui contient l'ensemble des modifications qui lui ont été apportées depuis son chargement ou depuis le dernier appel à AcceptChanges().
GetChanges(DataRowState)	Obtient une copie du DataTable contenant l'ensemble des modifications qui lui ont été apportées depuis son dernier chargement ou depuis l'appel à AcceptChanges(), filtrée par DataRowState.
GetDataTableSchema(XmlSchemaSet)	Cette méthode retourne une instance de XmlSchemaSet contenant WSDL (Web Services Description Language), lequel décrit DataTable pour les services Web.
GetErrors()	Obtient un tableau d'objets DataRow qui contiennent des erreurs.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)	Remplit un objet d’informations de sérialisation avec les données nécessaires pour sérialiser DataTable.
GetRowType()	Obtient le type de ligne.
GetSchema()	Pour obtenir une description de ce membre, consultez GetSchema().
GetService(Type)	Obtient l'implémenteur du IServiceProvider. (Hérité de MarshalByValueComponent)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
ImportRow(DataRow)	Copie DataRow dans un DataTable en préservant tous les paramètres de propriété, ainsi que les valeurs d'origine et actuelles.
Load(IDataReader)	Remplit un DataTable avec des valeurs issues d'une source de données à l'aide du IDataReader fourni. Si DataTable contient déjà des lignes, les données entrantes à partir de la source de données sont fusionnées avec les lignes existantes.
Load(IDataReader, LoadOption)	Remplit un DataTable avec des valeurs issues d'une source de données à l'aide du IDataReader fourni. Si `DataTable` contient déjà des lignes, les données entrantes à partir de la source de données sont fusionnées avec les lignes existantes en fonction de la valeur du paramètre `loadOption`.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Remplit un DataTable avec des valeurs issues d'une source de données à l'aide du IDataReader fourni et d'un délégué de gestion d'erreur.
LoadDataRow(Object[], Boolean)	Recherche et met à jour une ligne spécifique. Si aucune ligne correspondante n'est détectée, une nouvelle ligne est créée à l'aide des valeurs données.
LoadDataRow(Object[], LoadOption)	Recherche et met à jour une ligne spécifique. Si aucune ligne correspondante n'est détectée, une nouvelle ligne est créée à l'aide des valeurs données.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Merge(DataTable)	Fusionnez le DataTable spécifié avec le DataTable actuel.
Merge(DataTable, Boolean)	Fusionnez le DataTable spécifié avec le `DataTable` actuel, en indiquant s'il faut conserver les modifications dans le `DataTable` actuel.
Merge(DataTable, Boolean, MissingSchemaAction)	Fusionnez le DataTable spécifié avec le `DataTable` actuel, en indiquant s'il faut conserver les modifications et comment gérer le schéma manquant dans le `DataTable` actuel.
NewRow()	Crée un nouveau DataRow possédant le même schéma que la table.
NewRowArray(Int32)	Retourne un tableau de DataRow.
NewRowFromBuilder(DataRowBuilder)	Crée une nouvelle ligne à partir d'une ligne existante.
OnColumnChanged(DataColumnChangeEventArgs)	Déclenche l’événement ColumnChanged.
OnColumnChanging(DataColumnChangeEventArgs)	Déclenche l’événement ColumnChanging.
OnPropertyChanging(PropertyChangedEventArgs)	Déclenche l’événement PropertyChanged.
OnRemoveColumn(DataColumn)	Avertit DataTable que DataColumn est en cours de suppression.
OnRowChanged(DataRowChangeEventArgs)	Déclenche l’événement RowChanged.
OnRowChanging(DataRowChangeEventArgs)	Déclenche l’événement RowChanging.
OnRowDeleted(DataRowChangeEventArgs)	Déclenche l’événement RowDeleted.
OnRowDeleting(DataRowChangeEventArgs)	Déclenche l’événement RowDeleting.
OnTableCleared(DataTableClearEventArgs)	Déclenche l’événement TableCleared.
OnTableClearing(DataTableClearEventArgs)	Déclenche l’événement TableClearing.
OnTableNewRow(DataTableNewRowEventArgs)	Déclenche l’événement TableNewRow.
ReadXml(Stream)	Lit le schéma et les données XML dans le DataTable à l'aide du Stream spécifié.
ReadXml(String)	Lit le schéma et les données XML dans le DataTable à partir du fichier spécifié.
ReadXml(TextReader)	Lit le schéma et les données XML dans le DataTable à l'aide du TextReader spécifié.
ReadXml(XmlReader)	Lit le schéma et les données XML dans le DataTable à l'aide du XmlReader spécifié.
ReadXmlSchema(Stream)	Lit un schéma XML dans le DataTable à l'aide du flux de données spécifié.
ReadXmlSchema(String)	Lit un schéma XML dans le DataTable à partir du fichier spécifié.
ReadXmlSchema(TextReader)	Lit un schéma XML dans le DataTable à l'aide du TextReader spécifié.
ReadXmlSchema(XmlReader)	Lit un schéma XML dans le DataTable à l'aide du XmlReader spécifié.
ReadXmlSerializable(XmlReader)	Lectures d'un flux de données XML.
RejectChanges()	Restaure toutes les modifications apportées à la table depuis son chargement ou le dernier appel à AcceptChanges().
Reset()	Rétablit l'état d'origine de DataTable. La réinitialisation supprime toutes les données, relations et colonnes de la table. Si un DataSet inclut un DataTable, la table fera partie du DataSet après sa réinitialisation.
Select()	Obtient un tableau de tous les objets DataRow.
Select(String)	Obtient un tableau de tous les objets DataRow qui correspondent aux critères de filtre.
Select(String, String)	Obtient un tableau de tous les objets DataRow qui correspondent aux critères de filtre, dans l'ordre de tri spécifié.
Select(String, String, DataViewRowState)	Obtient un tableau de tous les objets DataRow qui correspondent au filtre et à l'état spécifié, dans l'ordre de tri.
ToString()	Obtient le TableName et le DisplayExpression éventuels sous la forme d'une chaîne concaténée.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
WriteXml(Stream)	Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de Stream spécifié.
WriteXml(Stream, Boolean)	Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de Stream spécifié. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXml(Stream, XmlWriteMode)	Écrit les données en cours, et éventuellement le schéma, de DataTable dans le fichier spécifié à l'aide du XmlWriteMode spécifié. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`.
WriteXml(Stream, XmlWriteMode, Boolean)	Écrit les données en cours, et éventuellement le schéma, de DataTable dans le fichier spécifié à l'aide du XmlWriteMode spécifié. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXml(String)	Écrit le contenu actuel du DataTable au format XML à l'aide du fichier spécifié.
WriteXml(String, Boolean)	Écrit le contenu actuel du DataTable au format XML à l'aide du fichier spécifié. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXml(String, XmlWriteMode)	Écrit les données en cours, et éventuellement le schéma, de DataTable à l'aide du fichier et XmlWriteMode spécifiés. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`.
WriteXml(String, XmlWriteMode, Boolean)	Écrit les données en cours, et éventuellement le schéma, de DataTable à l'aide du fichier et XmlWriteMode spécifiés. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXml(TextWriter)	Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de TextWriter spécifié.
WriteXml(TextWriter, Boolean)	Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de TextWriter spécifié. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXml(TextWriter, XmlWriteMode)	Écrit les données en cours, et éventuellement le schéma, de DataTable à l'aide des TextWriter et XmlWriteMode spécifiés. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`.
WriteXml(TextWriter, XmlWriteMode, Boolean)	Écrit les données en cours, et éventuellement le schéma, de DataTable à l'aide des TextWriter et XmlWriteMode spécifiés. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXml(XmlWriter)	Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de XmlWriter spécifié.
WriteXml(XmlWriter, Boolean)	Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de XmlWriter spécifié.
WriteXml(XmlWriter, XmlWriteMode)	Écrit les données en cours, et éventuellement le schéma, de DataTable à l'aide des XmlWriter et XmlWriteMode spécifiés. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`.
WriteXml(XmlWriter, XmlWriteMode, Boolean)	Écrit les données en cours, et éventuellement le schéma, de DataTable à l'aide des XmlWriter et XmlWriteMode spécifiés. Pour écrire le schéma, affectez `WriteSchema` comme valeur du paramètre `mode`. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXmlSchema(Stream)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML dans le flux de données spécifié.
WriteXmlSchema(Stream, Boolean)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML dans le flux de données spécifié. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXmlSchema(String)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML dans le fichier spécifié.
WriteXmlSchema(String, Boolean)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML dans le fichier spécifié. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXmlSchema(TextWriter)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML à l'aide du TextWriter spécifié.
WriteXmlSchema(TextWriter, Boolean)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML à l'aide du TextWriter spécifié. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.
WriteXmlSchema(XmlWriter)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML à l'aide du XmlWriter spécifié.
WriteXmlSchema(XmlWriter, Boolean)	Écrit la structure de données actuelle du DataTable sous la forme d'un schéma XML à l'aide du XmlWriter spécifié. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre `writeHierarchy` la valeur `true`.

Événements

ColumnChanged	Se produit après la modification d'une valeur du DataColumn spécifié dans un DataRow.
ColumnChanging	Se produit lors de la modification d'une valeur du DataColumn spécifié dans un DataRow.
Disposed	Ajoute un gestionnaire d'événements pour écouter l'événement Disposed sur le composant. (Hérité de MarshalByValueComponent)
Initialized	Se produit une fois que le DataTable est initialisé.
RowChanged	Se produit après la modification réussie de DataRow.
RowChanging	Se produit lorsque DataRow est en cours de modification.
RowDeleted	Se produit lorsqu'une ligne de la table a été supprimée.
RowDeleting	Se produit avant qu'une ligne de la table soit sur le point d'être supprimée.
TableCleared	Se produit une fois DataTable effacé.
TableClearing	Se produit lorsque DataTable est effacé.
TableNewRow	Se produit lorsqu'un nouveau DataRow est inséré.

Implémentations d’interfaces explicites

IListSource.ContainsListCollection	Pour obtenir une description de ce membre, consultez ContainsListCollection.
IListSource.GetList()	Pour obtenir une description de ce membre, consultez GetList().
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Remplit un objet d’informations de sérialisation avec les données nécessaires pour sérialiser DataTable.
IXmlSerializable.GetSchema()	Pour obtenir une description de ce membre, consultez GetSchema().
IXmlSerializable.ReadXml(XmlReader)	Pour obtenir une description de ce membre, consultez ReadXml(XmlReader).
IXmlSerializable.WriteXml(XmlWriter)	Pour obtenir une description de ce membre, consultez WriteXml(XmlWriter).

Méthodes d’extension

AsDataView(DataTable)	Crée et retourne un objet DataView prenant en charge LINQ.
AsEnumerable(DataTable)	Retourne un objet IEnumerable<T> où le paramètre générique `T` est DataRow. Cet objet peut être utilisé dans une expression LINQ ou une requête de méthode.

S’applique à

Cohérence de thread

Ce type est sécurisé pour les opérations de lecture multithread. Vous devez synchroniser toutes les opérations d’écriture.

Voir aussi

DataTables