DataTable Classe

Définition

Représente une table de données en mémoire.Represents one table of in-memory data.

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitializeNotification, System::Runtime::Serialization::ISerializable, System::Xml::Serialization::IXmlSerializable
[System.Serializable]
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 ISupportInitializeNotification
    interface ISerializable
    interface IXmlSerializable
    interface ISupportInitialize
Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitializeNotification, IXmlSerializable
Héritage
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant crée deux DataTable objets et un DataRelation objet, et ajoute les nouveaux objets à un DataSet.The following example creates two DataTable objects and one DataRelation object, and adds the new objects to a DataSet. Les tables sont ensuite affichées dans un DataGridView contrôle.The tables are then displayed in a DataGridView control.

   // 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 manuellement un DataTable avec des définitions de schéma spécifiques :This sample demonstrates how to create a DataTable manually with specific schema definitions:

  • Créez plusieurs DataTables et définissez les colonnes initiales.Create multiple DataTables and define the initial columns.

  • Créez les contraintes de table.Create the table constraints.

  • Insérez les valeurs et affichez les tables.Insert the values and display the tables.

  • Créez les colonnes d’expression et affichez les tables.Create the expression columns and display the tables.

C#vous trouverez des projets Visual Basic avec cet exemple de code dans les exemples de code pour développeurs.C# and Visual Basic projects with this code sample can be found on Developer Code Samples.

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

Le DataTable est un objet central dans la bibliothèque ADO.net.The DataTable is a central object in the ADO.NET library. Les autres objets qui utilisent DataTable le incluent DataSet le et DataViewle.Other objects that use the DataTable include the DataSet and the DataView.

Lors de l' DataTable accès aux objets, Notez qu’ils respectent la casse de manière conditionnelle.When accessing DataTable objects, note that they are conditionally case sensitive. Par exemple, s’il DataTable s’agit d’un nom nommé « Mydatatable » et un autre nommé « Mydatatable », une chaîne utilisée pour Rechercher l’une des tables est considérée comme sensible à la casse.For example, if one DataTable is named "mydatatable" and another is named "Mydatatable", a string used to search for one of the tables is regarded as case sensitive. Toutefois, si « Mydatatable » existe et que « Mydatatable » ne le fait pas, la chaîne recherchée est considérée comme ne respectant pas la casse.However, if "mydatatable" exists and "Mydatatable" does not, the search string is regarded as case insensitive. Un DataSet peut contenir deux DataTable objets qui ont la même TableName valeur de propriété mais Namespace des valeurs de propriété différentes.A DataSet can contain two DataTable objects that have the same TableName property value but different Namespace property values. Pour plus d’informations sur l' DataTable utilisation des objets, consultez création d’un DataTable.For more information about working with DataTable objects, see Creating a DataTable.

DataTable Si vous créez un par programme, vous devez d’abord définir son schéma en ajoutant DataColumn des objets à l DataColumnCollection ' (accessible via Columns la propriété).If you are creating a DataTable programmatically, you must first define its schema by adding DataColumn objects to the DataColumnCollection (accessed through the Columns property). Pour plus d’informations sur DataColumn l’ajout d’objets, consultez Ajout de colonnes à un DataTable.For more information about adding DataColumn objects, see Adding Columns to a DataTable.

Pour ajouter des lignes à DataTableun, vous devez d’abord NewRow utiliser la méthode pour retourner DataRow un nouvel objet.To add rows to a DataTable, you must first use the NewRow method to return a new DataRow object. La NewRow méthode retourne une ligne avec le schéma DataTablede, tel qu’il est défini par le de DataColumnCollectionla table.The NewRow method returns a row with the schema of the DataTable, as it is defined by the table's DataColumnCollection. Le nombre maximal de lignes qu’un DataTable peut stocker est 16 777 216.The maximum number of rows that a DataTable can store is 16,777,216. Pour plus d’informations, consultez Ajout de données à un DataTable.For more information, see Adding Data to a DataTable.

Contient également une collection d' Constraint objets qui peuvent être utilisés pour garantir l’intégrité des données. DataTableThe DataTable also contains a collection of Constraint objects that can be used to ensure the integrity of the data. Pour plus d’informations, consultez contraintes de DataTable.For more information, see DataTable Constraints.

De nombreux DataTable événements peuvent être utilisés pour déterminer quand des modifications sont apportées à une table.There are many DataTable events that can be used to determine when changes are made to a table. Il s'agit notamment de RowChanged, RowChanging, RowDeleting et RowDeleted.These include RowChanged, RowChanging, RowDeleting, and RowDeleted. Pour plus d’informations sur les événements qui peuvent être utilisés avec DataTableun, consultez gestion des événements DataTable.For more information about the events that can be used with a DataTable, see Handling DataTable Events.

Lorsqu’une instance de DataTable est créée, certaines des propriétés de lecture/écriture sont définies sur des valeurs initiales.When an instance of DataTable is created, some of the read/write properties are set to initial values. Pour obtenir la liste de ces valeurs, consultez DataTable.DataTable la rubrique relative au constructeur.For a list of these values, see the DataTable.DataTable constructor topic.

Notes

Les DataSet objets DataTable et héritent MarshalByValueComponentde et prennent en ISerializable charge l’interface pour .NET Framework la communication à distance.The DataSet and DataTable objects inherit from MarshalByValueComponent, and support the ISerializable interface for .NET Framework remoting. Il s’agit des seuls objets ADO.NET que vous pouvez utiliser pour .NET Framework la communication à distance.These are the only ADO.NET objects that you can use for .NET Framework remoting.

Constructeurs

DataTable()

Initialise une nouvelle instance de la classe DataTable sans argument.Initializes a new instance of the DataTable class with no arguments.

DataTable(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe DataTable avec SerializationInfo et StreamingContext.Initializes a new instance of the DataTable class with the SerializationInfo and the StreamingContext.

DataTable(String)

Initialise une nouvelle instance de la classe DataTable avec le nom de table spécifié.Initializes a new instance of the DataTable class with the specified table name.

DataTable(String, String)

Initialise une nouvelle instance de la classe DataTable avec le nom de table et l'espace de noms spécifiés.Initializes a new instance of the DataTable class using the specified table name and namespace.

Champs

fInitInProgress

Vérifie si l'initialisation est en cours.Checks whether initialization is in progress. L'initialisation se produit au moment de l'exécution.The initialization occurs at run time.

Propriétés

CaseSensitive

Indique si les comparaisons de chaînes au sein de la table respectent la casse.Indicates whether string comparisons within the table are case-sensitive.

ChildRelations

Obtient la collection des relations enfants de ce DataTable.Gets the collection of child relations for this DataTable.

Columns

Obtient la collection des colonnes qui appartiennent à cette table.Gets the collection of columns that belong to this table.

Constraints

Obtient la collection de contraintes gérée par cette table.Gets the collection of constraints maintained by this table.

Container

Obtient le conteneur du composant.Gets the container for the component.

(Hérité de MarshalByValueComponent)
DataSet

Obtient le DataSet auquel cette table appartient.Gets the DataSet to which this table belongs.

DefaultView

Obtient une vue personnalisée de la table qui peut comprendre une vue filtrée ou une position de curseur.Gets a customized view of the table that may include a filtered view, or a cursor position.

DesignMode

Obtient une valeur indiquant si le composant est actuellement en mode design.Gets a value indicating whether the component is currently in design mode.

(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.Gets or sets the expression that returns a value used to represent this table in the user interface. La propriété DisplayExpression vous permet d'afficher le nom de cette table dans une interface utilisateur.The DisplayExpression property lets you display the name of this table in a user interface.

Events

Obtient la liste des gestionnaires d'événements attachés à ce composant.Gets the list of event handlers that are attached to this component.

(Hérité de MarshalByValueComponent)
ExtendedProperties

Obtient la collection d'informations utilisateur personnalisées.Gets the collection of customized user information.

HasErrors

Obtient une valeur indiquant s'il existe des erreurs dans une des lignes d'une table du DataSet auquel appartient la table.Gets a value indicating whether there are errors in any of the rows in any of the tables of the DataSet to which the table belongs.

IsInitialized

Obtient une valeur qui indique si DataTable est initialisé.Gets a value that indicates whether the DataTable is initialized.

Locale

Obtient ou définit les paramètres régionaux utilisés pour comparer des chaînes dans la table.Gets or sets the locale information used to compare strings within the table.

MinimumCapacity

Obtient ou définit la taille de départ initiale pour cette table.Gets or sets the initial starting size for this table.

Namespace

Obtient ou définit l'espace de noms de la représentation XML des données stockées dans le DataTable.Gets or sets the namespace for the XML representation of the data stored in the DataTable.

ParentRelations

Obtient la collection des relations parentes de ce DataTable.Gets the collection of parent relations for this DataTable.

Prefix

Obtient ou définit l'espace de noms de la représentation XML des données stockées dans le DataTable.Gets or sets the namespace for the XML representation of the data stored in the DataTable.

PrimaryKey

Obtient ou définit un tableau de colonnes qui fonctionnent comme des clés primaires pour la table de données.Gets or sets an array of columns that function as primary keys for the data table.

RemotingFormat

Obtient ou définit le format de sérialisation.Gets or sets the serialization format.

Rows

Obtient la collection des lignes qui appartiennent à cette table.Gets the collection of rows that belong to this table.

Site

Obtient ou définit un élément ISite pour l'élément DataTable.Gets or sets an ISite for the DataTable.

TableName

Obtient ou définit le nom de l'objet DataTable.Gets or sets the name of the DataTable.

Méthodes

AcceptChanges()

Valide toutes les modifications apportées à cette table depuis le dernier appel à AcceptChanges().Commits all the changes made to this table since the last time AcceptChanges() was called.

BeginInit()

Commence l'initialisation d'un DataTable qui est utilisé dans un formulaire ou par un autre composant.Begins the initialization of a DataTable that is used on a form or used by another component. L'initialisation se produit au moment de l'exécution.The initialization occurs at run time.

BeginLoadData()

Désactive les notifications, la gestion d'index et les contraintes lors du chargement de données.Turns off notifications, index maintenance, and constraints while loading data.

Clear()

Efface toutes les données de DataTable.Clears the DataTable of all data.

Clone()

Clone la structure de DataTable, y compris tous les schémas et contraintes DataTable.Clones the structure of the DataTable, including all DataTable schemas and constraints.

Compute(String, String)

Calcule l'expression donnée sur les lignes en cours qui passent les critères du filtre.Computes the given expression on the current rows that pass the filter criteria.

Copy()

Copie à la fois la structure et les données de ce DataTable.Copies both the structure and data for this DataTable.

CreateDataReader()

Retourne un DataTableReader correspondant aux données dans ce DataTable.Returns a DataTableReader corresponding to the data within this DataTable.

CreateInstance()

Crée une instance de DataTable.Creates a new instance of DataTable.

Dispose()

Libère toutes les ressources utilisées par MarshalByValueComponent.Releases all resources used by the 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.Releases the unmanaged resources used by the MarshalByValueComponent and optionally releases the managed resources.

(Hérité de MarshalByValueComponent)
EndInit()

Termine l'initialisation d'un DataTable qui est utilisé dans un formulaire ou par un autre composant.Ends the initialization of a DataTable that is used on a form or used by another component. L'initialisation se produit au moment de l'exécution.The initialization occurs at run time.

EndLoadData()

Active les notifications, la gestion d'index et les contraintes après le chargement de données.Turns on notifications, index maintenance, and constraints after loading data.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(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().Gets a copy of the DataTable that contains all changes made to it since it was loaded or AcceptChanges() was last called.

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.Gets a copy of the DataTable containing all changes made to it since it was last loaded, or since AcceptChanges() was called, filtered by 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.This method returns an XmlSchemaSet instance containing the Web Services Description Language (WSDL) that describes the DataTable for Web Services.

GetErrors()

Obtient un tableau d'objets DataRow qui contiennent des erreurs.Gets an array of DataRow objects that contain errors.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(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.Populates a serialization information object with the data needed to serialize the DataTable.

GetRowType()

Obtient le type de ligne.Gets the row type.

GetSchema()

Pour obtenir une description de ce membre, consultez GetSchema().For a description of this member, see GetSchema().

GetService(Type)

Obtient l'implémenteur du IServiceProvider.Gets the implementer of the IServiceProvider.

(Hérité de MarshalByValueComponent)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(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.Copies a DataRow into a DataTable, preserving any property settings, as well as original and current values.

Load(IDataReader)

Remplit un DataTable avec des valeurs issues d'une source de données à l'aide du IDataReader fourni.Fills a DataTable with values from a data source using the supplied IDataReader. 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.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

Load(IDataReader, LoadOption)

Remplit un DataTable avec des valeurs issues d'une source de données à l'aide du IDataReader fourni.Fills a DataTable with values from a data source using the supplied IDataReader. 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.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows according to the value of the loadOption parameter.

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.Fills a DataTable with values from a data source using the supplied IDataReader using an error-handling delegate.

LoadDataRow(Object[], Boolean)

Recherche et met à jour une ligne spécifique.Finds and updates a specific row. Si aucune ligne correspondante n'est détectée, une nouvelle ligne est créée à l'aide des valeurs données.If no matching row is found, a new row is created using the given values.

LoadDataRow(Object[], LoadOption)

Recherche et met à jour une ligne spécifique.Finds and updates a specific row. Si aucune ligne correspondante n'est détectée, une nouvelle ligne est créée à l'aide des valeurs données.If no matching row is found, a new row is created using the given values.

MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Merge(DataTable)

Fusionnez le DataTable spécifié avec le DataTable actuel.Merge the specified DataTable with the current DataTable.

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 the specified DataTable with the current DataTable, indicating whether to preserve changes in the current DataTable.

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.Merge the specified DataTable with the current DataTable, indicating whether to preserve changes and how to handle missing schema in the current DataTable.

NewRow()

Crée un nouveau DataRow possédant le même schéma que la table.Creates a new DataRow with the same schema as the table.

NewRowArray(Int32)

Retourne un tableau de DataRow.Returns an array of DataRow.

NewRowFromBuilder(DataRowBuilder)

Crée une nouvelle ligne à partir d'une ligne existante.Creates a new row from an existing row.

OnColumnChanged(DataColumnChangeEventArgs)

Déclenche l'événement ColumnChanged.Raises the ColumnChanged event.

OnColumnChanging(DataColumnChangeEventArgs)

Déclenche l'événement ColumnChanging.Raises the ColumnChanging event.

OnPropertyChanging(PropertyChangedEventArgs)

Déclenche l'événement PropertyChanged.Raises the PropertyChanged event.

OnRemoveColumn(DataColumn)

Avertit DataTable que DataColumn est en cours de suppression.Notifies the DataTable that a DataColumn is being removed.

OnRowChanged(DataRowChangeEventArgs)

Déclenche l'événement RowChanged.Raises the RowChanged event.

OnRowChanging(DataRowChangeEventArgs)

Déclenche l'événement RowChanging.Raises the RowChanging event.

OnRowDeleted(DataRowChangeEventArgs)

Déclenche l'événement RowDeleted.Raises the RowDeleted event.

OnRowDeleting(DataRowChangeEventArgs)

Déclenche l'événement RowDeleting.Raises the RowDeleting event.

OnTableCleared(DataTableClearEventArgs)

Déclenche l'événement TableCleared.Raises the TableCleared event.

OnTableClearing(DataTableClearEventArgs)

Déclenche l'événement TableClearing.Raises the TableClearing event.

OnTableNewRow(DataTableNewRowEventArgs)

Déclenche l'événement TableNewRow.Raises the TableNewRow event.

ReadXml(Stream)

Lit le schéma et les données XML dans le DataTable à l'aide du Stream spécifié.Reads XML schema and data into the DataTable using the specified Stream.

ReadXml(String)

Lit le schéma et les données XML dans le DataTable à partir du fichier spécifié.Reads XML schema and data into the DataTable from the specified file.

ReadXml(TextReader)

Lit le schéma et les données XML dans le DataTable à l'aide du TextReader spécifié.Reads XML schema and data into the DataTable using the specified TextReader.

ReadXml(XmlReader)

Lit le schéma et les données XML dans le DataTable à l'aide du XmlReader spécifié.Reads XML Schema and Data into the DataTable using the specified XmlReader.

ReadXmlSchema(Stream)

Lit un schéma XML dans le DataTable à l'aide du flux de données spécifié.Reads an XML schema into the DataTable using the specified stream.

ReadXmlSchema(String)

Lit un schéma XML dans le DataTable à partir du fichier spécifié.Reads an XML schema into the DataTable from the specified file.

ReadXmlSchema(TextReader)

Lit un schéma XML dans le DataTable à l'aide du TextReader spécifié.Reads an XML schema into the DataTable using the specified TextReader.

ReadXmlSchema(XmlReader)

Lit un schéma XML dans le DataTable à l'aide du XmlReader spécifié.Reads an XML schema into the DataTable using the specified XmlReader.

ReadXmlSerializable(XmlReader)

Lectures d'un flux de données XML.Reads from an XML stream.

RejectChanges()

Restaure toutes les modifications apportées à la table depuis son chargement ou le dernier appel à AcceptChanges().Rolls back all changes that have been made to the table since it was loaded, or the last time AcceptChanges() was called.

Reset()

Rétablit l'état d'origine de DataTable.Resets the DataTable to its original state. La réinitialisation supprime toutes les données, relations et colonnes de la table.Reset removes all data, indexes, relations, and columns of the table. Si un DataSet inclut un DataTable, la table fera partie du DataSet après sa réinitialisation.If a DataSet includes a DataTable, the table will still be part of the DataSet after the table is reset.

Select()

Obtient un tableau de tous les objets DataRow.Gets an array of all DataRow objects.

Select(String)

Obtient un tableau de tous les objets DataRow qui correspondent aux critères de filtre.Gets an array of all DataRow objects that match the filter criteria.

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é.Gets an array of all DataRow objects that match the filter criteria, in the specified sort order.

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.Gets an array of all DataRow objects that match the filter in the order of the sort that match the specified state.

ToString()

Obtient le TableName et le DisplayExpression éventuels sous la forme d'une chaîne concaténée.Gets the TableName and DisplayExpression, if there is one as a concatenated string.

WriteXml(Stream)

Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de Stream spécifié.Writes the current contents of the DataTable as XML using the specified Stream.

WriteXml(Stream, Boolean)

Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de Stream spécifié.Writes the current contents of the DataTable as XML using the specified Stream. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to 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é.Writes the current data, and optionally the schema, for the DataTable to the specified file using the specified XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema.

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é.Writes the current data, and optionally the schema, for the DataTable to the specified file using the specified XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to true.

WriteXml(String)

Écrit le contenu actuel du DataTable au format XML à l'aide du fichier spécifié.Writes the current contents of the DataTable as XML using the specified file.

WriteXml(String, Boolean)

Écrit le contenu actuel du DataTable au format XML à l'aide du fichier spécifié.Writes the current contents of the DataTable as XML using the specified file. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to 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.Writes the current data, and optionally the schema, for the DataTable using the specified file and XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema.

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.Writes the current data, and optionally the schema, for the DataTable using the specified file and XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to true.

WriteXml(TextWriter)

Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de TextWriter spécifié.Writes the current contents of the DataTable as XML using the specified TextWriter.

WriteXml(TextWriter, Boolean)

Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de TextWriter spécifié.Writes the current contents of the DataTable as XML using the specified TextWriter. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to 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.Writes the current data, and optionally the schema, for the DataTable using the specified TextWriter and XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema.

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.Writes the current data, and optionally the schema, for the DataTable using the specified TextWriter and XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to true.

WriteXml(XmlWriter)

Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de XmlWriter spécifié.Writes the current contents of the DataTable as XML using the specified XmlWriter.

WriteXml(XmlWriter, Boolean)

Écrit le contenu actuel de l’objet DataTable sous forme XML à l’aide de XmlWriter spécifié.Writes the current contents of the DataTable as XML using the specified XmlWriter.

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.Writes the current data, and optionally the schema, for the DataTable using the specified XmlWriter and XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema.

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.Writes the current data, and optionally the schema, for the DataTable using the specified XmlWriter and XmlWriteMode. Pour écrire le schéma, affectez WriteSchema comme valeur du paramètre mode.To write the schema, set the value for the mode parameter to WriteSchema. Pour enregistrer les données pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the data for the table and all its descendants, set the writeHierarchy parameter to 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é.Writes the current data structure of the DataTable as an XML schema to the specified stream.

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é.Writes the current data structure of the DataTable as an XML schema to the specified stream. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the schema for the table and all its descendants, set the writeHierarchy parameter to 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é.Writes the current data structure of the DataTable as an XML schema to the specified file.

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é.Writes the current data structure of the DataTable as an XML schema to the specified file. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the schema for the table and all its descendants, set the writeHierarchy parameter to 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é.Writes the current data structure of the DataTable as an XML schema using the specified TextWriter.

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é.Writes the current data structure of the DataTable as an XML schema using the specified TextWriter. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the schema for the table and all its descendants, set the writeHierarchy parameter to 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é.Writes the current data structure of the DataTable as an XML schema using the specified XmlWriter.

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é.Writes the current data structure of the DataTable as an XML schema using the specified XmlWriter. Pour enregistrer le schéma pour la table et tous ses descendants, affectez au paramètre writeHierarchy la valeur true.To save the schema for the table and all its descendants, set the writeHierarchy parameter to true.

Événements

ColumnChanged

Se produit après la modification d'une valeur du DataColumn spécifié dans un DataRow.Occurs after a value has been changed for the specified DataColumn in a DataRow.

ColumnChanging

Se produit lors de la modification d'une valeur du DataColumn spécifié dans un DataRow.Occurs when a value is being changed for the specified DataColumn in a DataRow.

Disposed

Ajoute un gestionnaire d'événements qui doit écouter l'événement Disposed pour le composant.Adds an event handler to listen to the Disposed event on the component.

(Hérité de MarshalByValueComponent)
Initialized

Se produit une fois que le DataTable est initialisé.Occurs after the DataTable is initialized.

RowChanged

Se produit après la modification réussie de DataRow.Occurs after a DataRow has been changed successfully.

RowChanging

Se produit lorsque DataRow est en cours de modification.Occurs when a DataRow is changing.

RowDeleted

Se produit lorsqu'une ligne de la table a été supprimée.Occurs after a row in the table has been deleted.

RowDeleting

Se produit avant qu'une ligne de la table soit sur le point d'être supprimée.Occurs before a row in the table is about to be deleted.

TableCleared

Se produit une fois DataTable effacé.Occurs after a DataTable is cleared.

TableClearing

Se produit lorsque DataTable est effacé.Occurs when a DataTable is cleared.

TableNewRow

Se produit lorsqu'un nouveau DataRow est inséré.Occurs when a new DataRow is inserted.

Implémentations d’interfaces explicites

IListSource.ContainsListCollection

Pour obtenir une description de ce membre, consultez ContainsListCollection.For a description of this member, see ContainsListCollection.

IListSource.GetList()

Pour obtenir une description de ce membre, consultez GetList().For a description of this member, see GetList().

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Remplit un objet d’informations de sérialisation avec les données nécessaires pour sérialiser DataTable.Populates a serialization information object with the data needed to serialize the DataTable.

IXmlSerializable.GetSchema()

Pour obtenir une description de ce membre, consultez GetSchema().For a description of this member, see GetSchema().

IXmlSerializable.ReadXml(XmlReader)

Pour obtenir une description de ce membre, consultez ReadXml(XmlReader).For a description of this member, see ReadXml(XmlReader).

IXmlSerializable.WriteXml(XmlWriter)

Pour obtenir une description de ce membre, consultez WriteXml(XmlWriter).For a description of this member, see WriteXml(XmlWriter).

Méthodes d’extension

AsDataView(DataTable)

Crée et retourne un objet DataView prenant en charge LINQ.Creates and returns a LINQ-enabled DataView object.

AsEnumerable(DataTable)

Retourne un objet IEnumerable<T> où le paramètre générique T est DataRow.Returns an IEnumerable<T> object, where the generic parameter T is DataRow. Cet objet peut être utilisé dans une expression LINQLINQ ou une requête de méthode.This object can be used in a LINQLINQ expression or method query.

S’applique à

Cohérence de thread

Ce type est sécurisé pour les opérations de lecture multithread.This type is safe for multithreaded read operations. Vous devez synchroniser toutes les opérations d’écriture.You must synchronize any write operations.

Voir aussi