DataTable Classe

Définition

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
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.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

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitialize
    interface ISupportInitializeNotification
    interface ISerializable
    interface 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

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

DynamicallyAccessedMembersAttribute SerializableAttribute

Implémente

IListSource ISupportInitialize ISupportInitializeNotification ISerializable IXmlSerializable

Exemples

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 tableaux.
• Créez les colonnes d’expression et affichez les tables.

using System;
using System.Data;

class Program
{
    static void Main()
    {
        // Create two tables and add them into the DataSet.
        DataTable orderTable = CreateOrderTable();
        DataTable orderDetailTable = CreateOrderDetailTable();
        DataSet salesSet = new();
        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 constraint, " +
            "you'll see the following error if you insert " +
            "an order detail with the wrong OrderId:\n");
        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("SubTotal", typeof(decimal), "Sum(Child.LineTotal)");
        orderTable.Columns.Add(colSub);

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

        // If the OrderId is 'Total', compute the amount due on all orders; otherwise, compute the amount due on this order.
        DataColumn colTotal = new(
            "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("Order");

        // Define the columns one at a time.
        DataColumn colId = new("OrderId", typeof(string));
        orderTable.Columns.Add(colId);

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

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

        return orderTable;
    }

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

        // Define all the columns at once.
        DataColumn[] cols =
        [
            new DataColumn("OrderDetailId", typeof(int)),
            new DataColumn("OrderId", typeof(string)),
            new DataColumn("Product", typeof(string)),
            new DataColumn("UnitPrice", typeof(decimal)),
            new DataColumn("OrderQty", typeof(int)),
            new DataColumn("LineTotal", typeof(decimal), "UnitPrice*OrderQty")
        ];

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

    private static void InsertOrders(DataTable orderTable)
    {
        // Add one row at a time.
        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 =
        [
            [1, "O0001", "Mountain Bike", 1419.5, 36],
            [2, "O0001", "Road Bike", 1233.6, 16],
            [3, "O0001", "Touring Bike", 1653.3, 32],
            [4, "O0002", "Mountain Bike", 1419.5, 24],
            [5, "O0002", "Road Bike", 1233.6, 12],
            [6, "O0003", "Mountain Bike", 1419.5, 48],
            [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();
    }
}

' 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

Remarques

La DataTable classe est un objet central dans la bibliothèque ADO.NET. Les autres objets qui utilisent DataTable incluent l’objet DataSet et le DataView.

Les noms d’objets DataTable sont sensibles à la casse sous certaines conditions. Par exemple, si un DataTable est nommé « mydatatable » et un autre « Mydatable », une chaîne utilisée pour rechercher l'une des tables est considérée comme sensible à la casse. Toutefois, si « mydatatable » existe et que « Mydatatable » n'existe 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 DataTable d’objets, 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 à la DataColumnCollection propriété (accessible via la Columns propriété). Pour plus d’informations sur l’ajout DataColumn d’objets, consultez Ajout 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 méthode NewRow retourne une ligne avec le schéma du DataTable, tel qu’il est défini par le DataColumnCollection de la table. Le nombre maximal de lignes qu'un DataTable 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 de DataTable est 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 le DataTable constructeur.

Considérations relatives à la sécurité

Pour plus d’informations sur la sécurité dataSet et DataTable, consultez les instructions de sécurité.

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