DataTable.Load DataTable.Load DataTable.Load DataTable.Load Method

Définition

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.

Surcharges

Load(IDataReader) Load(IDataReader) Load(IDataReader) 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) Load(IDataReader, LoadOption) 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) Load(IDataReader, LoadOption, FillErrorEventHandler) 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.

Exemples

L’exemple suivant illustre plusieurs des problèmes liés à l’appel de Load la méthode.The following example demonstrates several of the issues involved with calling the Load method. Tout d’abord, l’exemple se concentre sur les problèmes de schéma, notamment la IDataReaderdéduction d’un schéma à partir du chargé, puis la gestion des schémas incompatibles, et les schémas avec des colonnes manquantes ou supplémentaires.First, the example focuses on schema issues, including inferring a schema from the loaded IDataReader, and then handling incompatible schemas, and schemas with missing or additional columns. L’exemple se concentre ensuite sur les problèmes de données, notamment la gestion des différentes options de chargement.The example then focuses on data issues, including handling the various loading options.

Notes

Cet exemple montre comment utiliser l’une des versions surchargées de Load.This example shows how to use one of the overloaded versions of Load. Pour obtenir d’autres exemples qui peuvent être disponibles, consultez les rubriques sur les surcharges individuelles.For other examples that might be available, see the individual overload topics.

static void Main()
{
    // This example examines a number of scenarios involving the 
    // DataTable.Load method.
    Console.WriteLine("Load a DataTable and infer its schema:");

    // The table has no schema. The Load method will infer the 
    // schema from the IDataReader:
    DataTable table = new DataTable();

    // Retrieve a data reader, based on the Customers data. In
    // an application, this data might be coming from a middle-tier
    // business object:
    DataTableReader reader = new DataTableReader(GetCustomers());

    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine("Load a DataTable from an incompatible IDataReader:");

    // Create a table with a single integer column. Attempt
    // to load data from a reader with a schema that is 
    // incompatible. Note the exception, determined
    // by the particular incompatibility:
    table = GetIntegerTable();
    reader = new DataTableReader(GetStringTable());
    try
    {
        table.Load(reader);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.GetType().Name + ":" + ex.Message);
    }

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has extra columns:");

    // Note that loading a reader with extra columns adds
    // the columns to the existing table, if possible:
    table = GetIntegerTable();
    reader = new DataTableReader(GetCustomers());
    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has missing columns:");

    // Note that loading a reader with missing columns causes 
    // the columns to be filled with null data, if possible:
    table = GetCustomers();
    reader = new DataTableReader(GetIntegerTable());
    table.Load(reader);
    PrintColumns(table);

    // Demonstrate the various possibilites when loading data into
    // a DataTable that already contains data.
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Demonstrate data considerations:");
    Console.WriteLine("Current value, Original value, (RowState)");
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Original table:");

    table = SetupModifiedRows();
    DisplayRowState(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine("Data in IDataReader to be loaded:");
    DisplayRowState(GetChangedCustomers());

    PerformDemo(LoadOption.OverwriteChanges);
    PerformDemo(LoadOption.PreserveChanges);
    PerformDemo(LoadOption.Upsert);

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

private static void DisplayRowState(DataTable table)
{
    for (int i = 0; i <= table.Rows.Count - 1; i++)
    {
        object current = "--";
        object original = "--";
        DataRowState rowState = table.Rows[i].RowState;

        // Attempt to retrieve the current value, which doesn't exist
        // for deleted rows:
        if (rowState != DataRowState.Deleted)
        {
            current = table.Rows[i]["Name", DataRowVersion.Current];
        }

        // Attempt to retrieve the original value, which doesn't exist
        // for added rows:
        if (rowState != DataRowState.Added)
        {
            original = table.Rows[i]["Name", DataRowVersion.Original];
        }
        Console.WriteLine("{0}: {1}, {2} ({3})", i, current, 
            original, rowState);
    }
}

private static DataTable GetChangedCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));
    table.Columns.Add("Name", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 0, "XXX" });
    table.Rows.Add(new object[] { 1, "XXX" });
    table.Rows.Add(new object[] { 2, "XXX" });
    table.Rows.Add(new object[] { 3, "XXX" });
    table.Rows.Add(new object[] { 4, "XXX" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetCustomers()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));
    table.Columns.Add("Name", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 0, "Mary" });
    table.Rows.Add(new object[] { 1, "Andy" });
    table.Rows.Add(new object[] { 2, "Peter" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetIntegerTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 4 });
    table.Rows.Add(new object[] { 5 });
    table.AcceptChanges();
    return table;
}

private static DataTable GetStringTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { "Mary" });
    table.Rows.Add(new object[] { "Andy" });
    table.Rows.Add(new object[] { "Peter" });
    table.AcceptChanges();
    return table;
}

private static void PerformDemo(LoadOption optionForLoad)
{

    // Load data into a DataTable, retrieve a DataTableReader containing
    // different data, and call the Load method. Depending on the
    // LoadOption value passed as a parameter, this procedure displays
    // different results in the DataTable.
    Console.WriteLine(" ============================= ");
    Console.WriteLine("table.Load(reader, {0})", optionForLoad);
    Console.WriteLine(" ============================= ");

    DataTable table = SetupModifiedRows();
    DataTableReader reader = new DataTableReader(GetChangedCustomers());
    table.RowChanging +=new DataRowChangeEventHandler(HandleRowChanging);

    table.Load(reader, optionForLoad);
    Console.WriteLine();
    DisplayRowState(table);
}

private static void PrintColumns(DataTable table)
{
    // Loop through all the rows in the DataTableReader
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0; i < table.Columns.Count; i++)
        {
            Console.Write(row[i] + " ");
        }
        Console.WriteLine();
    }
}

private static DataTable SetupModifiedRows()
{
    // Fill a DataTable with customer info, and 
    // then modify, delete, and add rows.

    DataTable table = GetCustomers();
    // Row 0 is unmodified.
    // Row 1 is modified.
    // Row 2 is deleted.
    // Row 3 is added.
    table.Rows[1]["Name"] = "Sydney";
    table.Rows[2].Delete();
    DataRow row = table.NewRow();
    row["ID"] = 3;
    row["Name"] = "Melony";
    table.Rows.Add(row);

    // Note that the code doesn't call
    // table.AcceptChanges()
    return table;
}

static void HandleRowChanging(object sender, DataRowChangeEventArgs e)
{
    Console.WriteLine(
        "RowChanging event: ID = {0}, action = {1}", e.Row["ID"], 
        e.Action);
}
Sub Main()
  Dim table As New DataTable()

  ' This example examines a number of scenarios involving the 
  ' DataTable.Load method.
  Console.WriteLine("Load a DataTable and infer its schema:")

  ' Retrieve a data reader, based on the Customers data. In
  ' an application, this data might be coming from a middle-tier
  ' business object:
  Dim reader As New DataTableReader(GetCustomers())

  ' The table has no schema. The Load method will infer the 
  ' schema from the IDataReader:
  table.Load(reader)
  PrintColumns(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine("Load a DataTable from an incompatible IDataReader:")

  ' Create a table with a single integer column. Attempt
  ' to load data from a reader with a schema that is 
  ' incompatible. Note the exception, determined
  ' by the particular incompatibility:
  table = GetIntegerTable()
  reader = New DataTableReader(GetStringTable())
  Try
    table.Load(reader)
  Catch ex As Exception
    Console.WriteLine(ex.GetType.Name & ":" & ex.Message())
  End Try

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable with an IDataReader that has extra columns:")

  ' Note that loading a reader with extra columns adds
  ' the columns to the existing table, if possible:
  table = GetIntegerTable()
  reader = New DataTableReader(GetCustomers())
  table.Load(reader)
  PrintColumns(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable with an IDataReader that has missing columns:")

  ' Note that loading a reader with missing columns causes 
  ' the columns to be filled with null data, if possible:
  table = GetCustomers()
  reader = New DataTableReader(GetIntegerTable())
  table.Load(reader)
  PrintColumns(table)

  ' Demonstrate the various possibilites when loading data into
  ' a DataTable that already contains data.
  Console.WriteLine(" ============================= ")
  Console.WriteLine("Demonstrate data considerations:")
  Console.WriteLine("Current value, Original value, (RowState)")
  Console.WriteLine(" ============================= ")
  Console.WriteLine("Original table:")

  table = SetupModifiedRows()
  DisplayRowState(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine("Data in IDataReader to be loaded:")
  DisplayRowState(GetChangedCustomers())

  PerformDemo(LoadOption.OverwriteChanges)
  PerformDemo(LoadOption.PreserveChanges)
  PerformDemo(LoadOption.Upsert)

  Console.WriteLine("Press any key to continue.")
  Console.ReadKey()
End Sub

Private Sub DisplayRowState(ByVal table As DataTable)
  For i As Integer = 0 To table.Rows.Count - 1
    Dim current As Object = "--"
    Dim original As Object = "--"
    Dim rowState As DataRowState = table.Rows(i).RowState

    ' Attempt to retrieve the current value, which doesn't exist
    ' for deleted rows:
    If rowState <> DataRowState.Deleted Then
      current = table.Rows(i)("Name", DataRowVersion.Current)
    End If

    ' Attempt to retrieve the original value, which doesn't exist
    ' for added rows:
    If rowState <> DataRowState.Added Then
      original = table.Rows(i)("Name", DataRowVersion.Original)
    End If
    Console.WriteLine("{0}: {1}, {2} ({3})", i, current, original, rowState)
  Next
End Sub

Private Function GetChangedCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable

  ' Create two columns, ID and Name.
  Dim idColumn As DataColumn = table.Columns.Add("ID", GetType(Integer))
  table.Columns.Add("Name", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {0, "XXX"})
  table.Rows.Add(New Object() {1, "XXX"})
  table.Rows.Add(New Object() {2, "XXX"})
  table.Rows.Add(New Object() {3, "XXX"})
  table.Rows.Add(New Object() {4, "XXX"})
  table.AcceptChanges()
  Return table
End Function

Private Function GetCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable

  ' Create two columns, ID and Name.
  Dim idColumn As DataColumn = table.Columns.Add("ID", GetType(Integer))
  table.Columns.Add("Name", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {0, "Mary"})
  table.Rows.Add(New Object() {1, "Andy"})
  table.Rows.Add(New Object() {2, "Peter"})
  table.AcceptChanges()
  Return table
End Function

Private Function GetIntegerTable() As DataTable
  ' Create sample table with a single Int32 column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", GetType(Integer))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {4})
  table.Rows.Add(New Object() {5})
  table.AcceptChanges()
  Return table
End Function

Private Function GetStringTable() As DataTable
  ' Create sample table with a single String column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {"Mary"})
  table.Rows.Add(New Object() {"Andy"})
  table.Rows.Add(New Object() {"Peter"})
  table.AcceptChanges()
  Return table
End Function

Private Sub PerformDemo(ByVal optionForLoad As LoadOption)

  ' Load data into a DataTable, retrieve a DataTableReader containing
  ' different data, and call the Load method. Depending on the
  ' LoadOption value passed as a parameter, this procedure displays
  ' different results in the DataTable.
  Console.WriteLine(" ============================= ")
  Console.WriteLine("table.Load(reader, {0})", optionForLoad)
  Console.WriteLine(" ============================= ")

  Dim table As DataTable = SetupModifiedRows()
  Dim reader As New DataTableReader(GetChangedCustomers())
  AddHandler table.RowChanging, New _
      DataRowChangeEventHandler(AddressOf HandleRowChanging)

  table.Load(reader, optionForLoad)
  Console.WriteLine()
  DisplayRowState(table)
End Sub

Private Sub PrintColumns( _
   ByVal table As DataTable)

  ' Loop through all the rows in the DataTableReader.
  For Each row As DataRow In table.Rows
    For Each col As DataColumn In table.Columns
      Console.Write(row(col).ToString() & " ")
    Next
    Console.WriteLine()
  Next
End Sub

Private Function SetupModifiedRows() As DataTable
  ' Fill a DataTable with customer info, and 
  ' then modify, delete, and add rows.

  Dim table As DataTable = GetCustomers()
  ' Row 0 is unmodified.
  ' Row 1 is modified.
  ' Row 2 is deleted.
  ' Row 3 is added.
  table.Rows(1)("Name") = "Sydney"
  table.Rows(2).Delete()
  Dim row As DataRow = table.NewRow
  row("ID") = 3
  row("Name") = "Melony"
  table.Rows.Add(row)

  ' Note that the code doesn't call
  ' table.AcceptChanges()
  Return table
End Function

Private Sub HandleRowChanging(ByVal sender As Object, _
  ByVal e As System.Data.DataRowChangeEventArgs)
  Console.WriteLine( _
      "RowChanging event: ID = {0}, action = {1}", e.Row("ID"), _
      e.Action)
End Sub

Remarques

La Load méthode peut être utilisée dans plusieurs scénarios courants, tous centrés sur l’obtention de données à partir d’une source de données spécifiée et l’ajout au conteneur de données actuel DataTable(dans ce cas, a).The Load method can be used in several common scenarios, all centered around getting data from a specified data source and adding it to the current data container (in this case, a DataTable). Ces scénarios décrivent l’utilisation standard DataTabled’un, décrivant ses comportements de mise à jour et de fusion.These scenarios describe standard usage for a DataTable, describing its update and merge behavior.

Effectue DataTable une synchronisation ou une mise à jour avec une seule source de données primaire.A DataTable synchronizes or updates with a single primary data source. Le DataTable effectue le suivi des modifications, ce qui permet la synchronisation avec la source de données principale.The DataTable tracks changes, allowing synchronization with the primary data source. En outre, un DataTable peut accepter des données incrémentielles provenant d’une ou de plusieurs sources de données secondaires.In addition, a DataTable can accept incremental data from one or more secondary data sources. Le DataTable n’est pas responsable du suivi des modifications afin d’autoriser la synchronisation avec la source de données secondaire.The DataTable isn't responsible for tracking changes in order to allow synchronization with the secondary data source.

Compte tenu de ces deux sources de données hypothétiques, un utilisateur est susceptible d’exiger l’un des comportements suivants :Given these two hypothetical data sources, a user is likely to require one of the following behaviors:

  • DataTable Initialise à partir d’une source de données primaire.Initialize DataTable from a primary data source. Dans ce scénario, l’utilisateur souhaite initialiser un vide DataTable avec les valeurs de la source de données principale.In this scenario, the user wants to initialize an empty DataTable with values from the primary data source. Plus tard, l’utilisateur a l’intention de propager les modifications vers la source de données principale.Later the user intends to propagate changes back to the primary data source.

  • Conservez les modifications et resynchronisez-les à partir de la source de données principale.Preserve changes and re-synchronize from the primary data source. Dans ce scénario, l’utilisateur souhaite prendre la DataTable valeur remplie dans le scénario précédent et effectuer une synchronisation incrémentielle avec la source de données principale, en préservant les modifications apportées dans le. DataTableIn this scenario, the user wants to take the DataTable filled in the previous scenario and perform an incremental synchronization with the primary data source, preserving modifications made in the DataTable.

  • Flux de données incrémentiel à partir de sources de données secondaires.Incremental data feed from secondary data sources. Dans ce scénario, l’utilisateur souhaite fusionner les modifications à partir d’une ou de plusieurs sources de données secondaires, et propager ces modifications vers la source de données principale.In this scenario, the user wants to merge changes from one or more secondary data sources, and propagate those changes back to the primary data source.

La Load méthode rend possible tous ces scénarios.The Load method makes all these scenarios possible. Toutes les surcharges de cette méthode, sauf une, vous permettent de spécifier un paramètre d’option de chargement, qui indique comment DataTable les lignes déjà présentes dans un combiné avec les lignes sont chargées.All but one of the overloads for this method allows you to specify a load option parameter, indicating how rows already in a DataTable combine with rows being loaded. (La surcharge qui ne vous permet pas de spécifier le comportement utilise l’option de chargement par défaut.) Le tableau suivant décrit les trois options de chargement fournies par LoadOption l’énumération.(The overload that doesn't allow you to specify the behavior uses the default load option.) The following table describes the three load options provided by the LoadOption enumeration. Dans chaque cas, la description indique le comportement lorsque la clé primaire d’une ligne dans les données entrantes correspond à la clé primaire d’une ligne existante.In each case, the description indicates the behavior when the primary key of a row in the incoming data matches the primary key of an existing row.

Option de chargementLoad Option DescriptionDescription
PreserveChanges (valeur par défaut)PreserveChanges (default) Met à jour la version d’origine de la ligne avec la valeur de la ligne entrante.Updates the original version of the row with the value of the incoming row.
OverwriteChanges Met à jour les versions actuelles et d’origine de la ligne avec la valeur de la ligne entrante.Updates the current and original versions of the row with the value of the incoming row.
Upsert Met à jour la version actuelle de la ligne avec la valeur de la ligne entrante.Updates the current version of the row with the value of the incoming row.

En général, les PreserveChanges options OverwriteChanges et sont destinées aux scénarios dans lesquels l’utilisateur doit synchroniser le DataSet et ses modifications avec la source de données principale.In general, the PreserveChanges and OverwriteChanges options are intended for scenarios in which the user needs to synchronize the DataSet and its changes with the primary data source. L' Upsert option facilite l’agrégation des modifications à partir d’une ou de plusieurs sources de données secondaires.The Upsert option facilitates aggregating changes from one or more secondary data sources.

Load(IDataReader) Load(IDataReader) Load(IDataReader) 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.

public:
 void Load(System::Data::IDataReader ^ reader);
public void Load (System.Data.IDataReader reader);
member this.Load : System.Data.IDataReader -> unit
Public Sub Load (reader As IDataReader)

Paramètres

reader
IDataReader IDataReader IDataReader IDataReader

IDataReader qui fournit un jeu de résultats.An IDataReader that provides a result set.

Exemples

L’exemple suivant illustre plusieurs des problèmes liés à l’appel de Load la méthode.The following example demonstrates several of the issues involved with calling the Load method. Tout d’abord, l’exemple se concentre sur les problèmes de schéma, notamment la IDataReaderdéduction d’un schéma à partir du chargé, puis la gestion des schémas incompatibles, et les schémas avec des colonnes manquantes ou supplémentaires.First, the example focuses on schema issues, including inferring a schema from the loaded IDataReader, and then handling incompatible schemas, and schemas with missing or additional columns. L’exemple appelle ensuite la Load méthode, en affichant les données à la fois avant et après l’opération de chargement.The example then calls the Load method, displaying the data both before and after the load operation.

static void Main()
{
    // This example examines a number of scenarios involving the 
    // DataTable.Load method.
    Console.WriteLine("Load a DataTable and infer its schema:");

    // The table has no schema. The Load method will infer the 
    // schema from the IDataReader:
    DataTable table = new DataTable();

    // Retrieve a data reader, based on the Customers data. In
    // an application, this data might be coming from a middle-tier
    // business object:
    DataTableReader reader = new DataTableReader(GetCustomers());

    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable from an incompatible IDataReader:");

    // Create a table with a single integer column. Attempt
    // to load data from a reader with a schema that is 
    // incompatible. Note the exception, determined
    // by the particular incompatibility:
    table = GetIntegerTable();
    reader = new DataTableReader(GetStringTable());
    try 
    {
        table.Load(reader);
    } 
    catch (Exception ex) 
    { 
        Console.WriteLine(ex.GetType().Name + ":" + ex.Message);
    }

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has extra columns:");

    // Note that loading a reader with extra columns adds
    // the columns to the existing table, if possible:
    table = GetIntegerTable();
    reader = new DataTableReader(GetCustomers());
    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has missing columns:");

    // Note that loading a reader with missing columns causes 
    // the columns to be filled with null data, if possible:
    table = GetCustomers();
    reader = new DataTableReader(GetIntegerTable());
    table.Load(reader);
    PrintColumns(table);

    // Demonstrate the various possibilites when loading data 
    // into a DataTable that already contains data.
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Demonstrate data considerations:");
    Console.WriteLine("Current value, Original value, (RowState)");
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Original table:");

    table = SetupModifiedRows();
    DisplayRowState(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine("Data in IDataReader to be loaded:");
    DisplayRowState(GetChangedCustomers());

    // Load data into a DataTable, retrieve a DataTableReader 
    // containing different data, and call the Load method. 
    Console.WriteLine(" ============================= ");
    Console.WriteLine("table.Load(reader)");
    Console.WriteLine(" ============================= ");

    table = SetupModifiedRows();
    reader = new DataTableReader(GetChangedCustomers());
    table.Load(reader);
    DisplayRowState(table);

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

private static void DisplayRowState(DataTable table)
{
    for (int i = 0; i <= table.Rows.Count - 1; i++)
    {
        object current = "--";
        object original = "--";
        DataRowState rowState = table.Rows[i].RowState;

        // Attempt to retrieve the current value, which doesn't exist
        // for deleted rows:
        if (rowState != DataRowState.Deleted)
        {
            current = table.Rows[i]["Name", DataRowVersion.Current];
        }

        // Attempt to retrieve the original value, which doesn't exist
        // for added rows:
        if (rowState != DataRowState.Added)
        {
            original = table.Rows[i]["Name", DataRowVersion.Original];
        }
        Console.WriteLine("{0}: {1}, {2} ({3})", i, 
            current, original, rowState);
    }
}

private static DataTable GetChangedCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(int));
    table.Columns.Add("Name", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 1, "XXX" });
    table.Rows.Add(new object[] { 2, "XXX" });
    table.Rows.Add(new object[] { 3, "XXX" });
    table.Rows.Add(new object[] { 4, "XXX" });
    table.Rows.Add(new object[] { 5, "XXX" });
    table.Rows.Add(new object[] { 6, "XXX" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetCustomers()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(int));
    table.Columns.Add("Name", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 1, "Mary" });
    table.Rows.Add(new object[] { 2, "Andy" });
    table.Rows.Add(new object[] { 3, "Peter" });
    table.Rows.Add(new object[] { 4, "Russ" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetIntegerTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(int));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 5 });
    table.Rows.Add(new object[] { 6 });
    table.Rows.Add(new object[] { 7 });
    table.Rows.Add(new object[] { 8 });
    table.AcceptChanges();
    return table;
}

private static DataTable GetStringTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { "Mary" });
    table.Rows.Add(new object[] { "Andy" });
    table.Rows.Add(new object[] { "Peter" });
    table.Rows.Add(new object[] { "Russ" });
    table.AcceptChanges();
    return table;
}

private static void PrintColumns(DataTable table)
{
    // Loop through all the rows in the DataTableReader
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0; i < table.Columns.Count; i++)
        {
            Console.Write(row[i] + " ");
        }
        Console.WriteLine();
    }
}

private static DataTable SetupModifiedRows()
{
    // Fill a DataTable with customer info, and 
    // then modify, delete, and add rows.

    DataTable table = GetCustomers();
    // Row 0 is unmodified.
    // Row 1 is modified.
    // Row 2 is deleted.
    // Row 5 is added.
    table.Rows[1]["Name"] = "Sydney";
    table.Rows[2].Delete();
    DataRow row = table.NewRow();
    row["ID"] = 5;
    row["Name"] = "Melony";
    table.Rows.Add(row);

    // Note that the code doesn't call
    // table.AcceptChanges()
    return table;
}
Sub Main()
  ' This example examines a number of scenarios involving the 
  ' DataTable.Load method.
  Console.WriteLine("Load a DataTable and infer its schema:")

  ' The table has no schema. The Load method will infer the 
  ' schema from the IDataReader:
  Dim table As New DataTable()

  ' Retrieve a data reader, based on the Customers data. In
  ' an application, this data might be coming from a middle-tier
  ' business object:
  Dim reader As New DataTableReader(GetCustomers())

  table.Load(reader)
  PrintColumns(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable from an incompatible IDataReader:")

  ' Create a table with a single integer column. Attempt
  ' to load data from a reader with a schema that is 
  ' incompatible. Note the exception, determined
  ' by the particular incompatibility:
  table = GetIntegerTable()
  reader = New DataTableReader(GetStringTable())
  Try
    table.Load(reader)
  Catch ex As Exception
    Console.WriteLine(ex.GetType.Name & ":" & ex.Message())
  End Try

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable with an IDataReader that has extra columns:")

  ' Note that loading a reader with extra columns adds
  ' the columns to the existing table, if possible:
  table = GetIntegerTable()
  reader = New DataTableReader(GetCustomers())
  table.Load(reader)
  PrintColumns(table)

  Console.WriteLine(" ============================= ")
      Console.WriteLine( _
          "Load a DataTable with an IDataReader that has missing columns:")

  ' Note that loading a reader with missing columns causes 
  ' the columns to be filled with null data, if possible:
  table = GetCustomers()
  reader = New DataTableReader(GetIntegerTable())
  table.Load(reader)
  PrintColumns(table)

  ' Demonstrate the various possibilites when loading data into
  ' a DataTable that already contains data.
  Console.WriteLine(" ============================= ")
  Console.WriteLine("Demonstrate data considerations:")
  Console.WriteLine("Current value, Original value, (RowState)")
  Console.WriteLine(" ============================= ")
  Console.WriteLine("Original table:")

  table = SetupModifiedRows()
  DisplayRowState(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine("Data in IDataReader to be loaded:")
  DisplayRowState(GetChangedCustomers())

  ' Load data into a DataTable, retrieve a DataTableReader 
  ' containing different data, and call the Load method. 
  Console.WriteLine(" ============================= ")
  Console.WriteLine("table.Load(reader)")
  Console.WriteLine(" ============================= ")

  table = SetupModifiedRows()
  reader = New DataTableReader(GetChangedCustomers())
  table.Load(reader)
  DisplayRowState(table)

  Console.WriteLine("Press any key to continue.")
  Console.ReadKey()
End Sub

Private Sub DisplayRowState(ByVal table As DataTable)
  For i As Integer = 0 To table.Rows.Count - 1
    Dim current As Object = "--"
    Dim original As Object = "--"
    Dim rowState As DataRowState = table.Rows(i).RowState

    ' Attempt to retrieve the current value, which doesn't exist
    ' for deleted rows:
    If rowState <> DataRowState.Deleted Then
      current = table.Rows(i)("Name", DataRowVersion.Current)
    End If

    ' Attempt to retrieve the original value, which doesn't exist
    ' for added rows:
    If rowState <> DataRowState.Added Then
      original = table.Rows(i)("Name", DataRowVersion.Original)
    End If
    Console.WriteLine("{0}: {1}, {2} ({3})", i, _
      current, original, rowState)
  Next
End Sub

Private Function GetChangedCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable

  ' Create two columns, ID and Name.
  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(Integer))
  table.Columns.Add("Name", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {1, "XXX"})
  table.Rows.Add(New Object() {2, "XXX"})
  table.Rows.Add(New Object() {3, "XXX"})
  table.Rows.Add(New Object() {4, "XXX"})
  table.Rows.Add(New Object() {5, "XXX"})
  table.Rows.Add(New Object() {6, "XXX"})
  table.AcceptChanges()
  Return table
End Function

Private Function GetCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable

  ' Create two columns, ID and Name.
  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(Integer))
  table.Columns.Add("Name", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {1, "Mary"})
  table.Rows.Add(New Object() {2, "Andy"})
  table.Rows.Add(New Object() {3, "Peter"})
  table.Rows.Add(New Object() {4, "Russ"})
  table.AcceptChanges()
  Return table
End Function

Private Function GetIntegerTable() As DataTable
  ' Create sample table with a single Int32 column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(Integer))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {5})
  table.Rows.Add(New Object() {6})
  table.Rows.Add(New Object() {7})
  table.Rows.Add(New Object() {8})
  table.AcceptChanges()
  Return table
End Function

Private Function GetStringTable() As DataTable
  ' Create sample table with a single String column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {"Mary"})
  table.Rows.Add(New Object() {"Andy"})
  table.Rows.Add(New Object() {"Peter"})
  table.Rows.Add(New Object() {"Russ"})
  table.AcceptChanges()
  Return table
End Function

Private Sub PrintColumns( _
   ByVal table As DataTable)

  ' Loop through all the rows in the DataTableReader.
  For Each row As DataRow In table.Rows
    For Each col As DataColumn In table.Columns
      Console.Write(row(col).ToString() & " ")
    Next
    Console.WriteLine()
  Next
End Sub

Private Function SetupModifiedRows() As DataTable
  ' Fill a DataTable with customer info, and 
  ' then modify, delete, and add rows.

  Dim table As DataTable = GetCustomers()
  ' Row 0 is unmodified.
  ' Row 1 is modified.
  ' Row 2 is deleted.
  ' Row 5 is added.
  table.Rows(1)("Name") = "Sydney"
  table.Rows(2).Delete()
  Dim row As DataRow = table.NewRow
  row("ID") = 5
  row("Name") = "Melony"
  table.Rows.Add(row)

  ' Note that the code doesn't call
  ' table.AcceptChanges()
  Return table
End Function

Remarques

La Load méthode consomme le premier jeu de résultats du chargé IDataReaderet, une fois l’opération terminée, définit la position du lecteur sur le jeu de résultats suivant, le cas échéant.The Load method consumes the first result set from the loaded IDataReader, and after successful completion, sets the reader's position to the next result set, if any. Lors de la conversion de Load données, la méthode utilise les mêmes règles DbDataAdapter.Fill de conversion que la méthode.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

La Load méthode doit prendre en compte trois problèmes spécifiques lors du chargement des données à IDataReader partir d’une instance : schéma, données et opérations d’événement.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Lorsque vous travaillez avec le schéma, Load la méthode peut rencontrer des conditions, comme décrit dans le tableau suivant.When working with the schema, the Load method may encounter conditions as described in the following table. Les opérations de schéma sont effectuées pour tous les jeux de résultats importés, même ceux qui ne contiennent pas de données.The schema operations take place for all imported result sets, even those containing no data.

ConditionCondition ComportementBehavior
N' DataTable a pas de schéma.The DataTable has no schema. La Load méthode déduit le schéma en fonction du jeu de résultats du importé IDataReader.The Load method infers the schema based on the result set from the imported IDataReader.
Le DataTable a un schéma, mais il est incompatible avec le schéma chargé.The DataTable has a schema, but it is incompatible with the loaded schema. La Load méthode lève une exception correspondant à l’erreur particulière qui se produit lors de la tentative de chargement des données dans le schéma incompatible.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Les schémas sont compatibles, mais le schéma du jeu de résultats chargé contient des colonnes qui n’existent pas DataTabledans le.The schemas are compatible, but the loaded result set schema contains columns that do not exist in the DataTable. La Load méthode ajoute les colonnes supplémentaires au DataTableschéma de.The Load method adds the extra columns to DataTable's schema. La méthode lève une exception si les colonnes correspondantes dans DataTable le et le jeu de résultats chargé ne sont pas compatibles avec la valeur.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. La méthode récupère également les informations de contrainte du jeu de résultats pour toutes les colonnes ajoutées.The method also retrieves constraint information from the result set for all added columns. Sauf dans le cas d’une contrainte de clé primaire, cette information de contrainte est utilisée uniquement DataTable si le actuel ne contient aucune colonne au début de l’opération de chargement.Except for the case of Primary Key constraint, this constraint information is used only if the current DataTable does not contain any columns at the start of the load operation.
Les schémas sont compatibles, mais le schéma du jeu de résultats chargé contient moins de colonnes que DataTablele.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Si une colonne manquante a une valeur par défaut définie ou si le type de données de la Load colonne est Nullable, la méthode autorise l’ajout des lignes, en null substituant la valeur par défaut ou la valeur de la colonne manquante.If a missing column has a default value defined or the column's data type is nullable, the Load method allows the rows to be added, substituting the default or null value for the missing column. Si aucune valeur par défaut null ou ne peut être utilisée, Load la méthode lève une exception.If no default value or null can be used, then the Load method throws an exception. Si aucune valeur par défaut spécifique n’a été fournie Load , la méthode null utilise la valeur comme valeur par défaut implicite.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Avant de prendre en compte le Load comportement de la méthode en termes d’opérations de données, considérez DataTable que chaque ligne dans un gère à la fois la valeur actuelle et la valeur d’origine de chaque colonne.Before considering the behavior of the Load method in terms of data operations, consider that each row within a DataTable maintains both the current value and the original value for each column. Ces valeurs peuvent être équivalentes, ou peuvent être différentes si les données de la ligne ont été modifiées depuis le DataTableremplissage de.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Pour plus d’informations, consultez États des lignes et versions de ligne.For more information, see Row States and Row Versions.

Cette version de la Load méthode tente de conserver les valeurs actuelles de chaque ligne, ce qui laisse intact la valeur d’origine.This version of the Load method attempts to preserve the current values in each row, leaving the original value intact. (Si vous souhaitez contrôler plus précisément le comportement des données entrantes, DataTable.Loadconsultez.) Si la ligne existante et la ligne entrante contiennent des valeurs de clés primaires correspondantes, la ligne est traitée à l’aide de sa valeur d’état de ligne actuelle, sinon elle est traitée comme une nouvelle ligne.(If you want finer control over the behavior of incoming data, see DataTable.Load.) If the existing row and the incoming row contain corresponding primary key values, the row is processed using its current row state value, otherwise it's treated as a new row.

En termes d’opérations d’événement, RowChanging l’événement se produit avant la modification de chaque ligne RowChanged , et l’événement se produit après que chaque ligne a été modifiée.In terms of event operations, the RowChanging event occurs before each row is changed, and the RowChanged event occurs after each row has been changed. Dans chaque cas, la Action propriété de l' DataRowChangeEventArgs instance transmise au gestionnaire d’événements contient des informations sur l’action particulière associée à l’événement.In each case, the Action property of the DataRowChangeEventArgs instance passed to the event handler contains information about the particular action associated with the event. Cette valeur d’action dépend de l’état de la ligne avant l’opération de chargement.This action value depends on the state of the row before the load operation. Dans chaque cas, les deux événements se produisent et l’action est la même pour chaque.In each case, both events occur, and the action is the same for each. L’action peut être appliquée à la version actuelle ou à la version d’origine de chaque ligne, ou les deux, selon l’état actuel de la ligne.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

Le tableau suivant affiche le comportement de Load la méthode.The following table displays behavior for the Load method. La dernière ligne (étiquetée « (absent) ») décrit le comportement des lignes entrantes qui ne correspondent à aucune ligne existante.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Chaque cellule de ce tableau décrit les valeurs actuelles et d’origine d’un champ dans une ligne, ainsi que DataRowState la valeur de la valeur Load une fois que la méthode est terminée.Each cell in this table describes the current and original value for a field within a row, along with the DataRowState for the value after the Load method has completed. Dans ce cas, la méthode ne vous permet pas d’indiquer l’option de chargement et utilise la valeur PreserveChangespar défaut,.In this case, the method doesn't allow you to indicate the load option, and uses the default, PreserveChanges.

DataRowState existantExisting DataRowState Valeurs après Load la méthode et action d’événementValues after Load method, and event action
AddedAdded Actuel = <> existantesCurrent = <Existing>

Original = <> entrantOriginal = <Incoming>

État = <modifié >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
Modifiée leModified Actuel = <> existantesCurrent = <Existing>

Original = <> entrantOriginal = <Incoming>

État = <modifié >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
SuppriméDeleted Actuel = <non disponible >Current = <Not available>

Original = <> entrantOriginal = <Incoming>

État = <supprimé >State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
InchangéUnchanged Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
(Absent)(Not present) Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

Les valeurs d' DataColumn un peuvent être restreintes à l’aide de propriétés telles ReadOnly que AutoIncrementet.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. La Load méthode gère ces colonnes d’une manière qui est cohérente avec le comportement défini par les propriétés de la colonne.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. La contrainte en lecture seule sur DataColumn un est applicable uniquement aux modifications qui se produisent dans la mémoire.The read only constraint on a DataColumn is applicable only for changes that occur in memory. La Load méthode remplace les valeurs de colonne en lecture seule, si nécessaire.The Load method's overwrites the read-only column values, if needed.

Pour déterminer la version du champ de clé primaire à utiliser pour comparer la ligne actuelle à une ligne entrante, Load la méthode utilise la version d’origine de la valeur de clé primaire dans une ligne, si elle existe.To determine which version of the primary key field to use for comparing the current row with an incoming row, the Load method uses the original version of the primary key value within a row, if it exists. Sinon, la Load méthode utilise la version actuelle du champ de clé primaire.Otherwise, the Load method uses the current version of the primary key field.

Voir aussi

Load(IDataReader, LoadOption) Load(IDataReader, LoadOption) 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.

public:
 void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption);
public void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption);
member this.Load : System.Data.IDataReader * System.Data.LoadOption -> unit

Paramètres

reader
IDataReader IDataReader IDataReader IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.An IDataReader that provides one or more result sets.

loadOption
LoadOption LoadOption LoadOption LoadOption

Valeur issue de l'énumération LoadOption qui indique comment les lignes déjà présentes dans le DataTable sont associées aux lignes entrantes qui partagent la même clé primaire.A value from the LoadOption enumeration that indicates how rows already in the DataTable are combined with incoming rows that share the same primary key.

Exemples

L’exemple suivant illustre plusieurs des problèmes liés à l’appel de Load la méthode.The following example demonstrates several of the issues involved with calling the Load method. Tout d’abord, l’exemple se concentre sur les problèmes de schéma, notamment la IDataReaderdéduction d’un schéma à partir du chargé, puis la gestion des schémas incompatibles, et les schémas avec des colonnes manquantes ou supplémentaires.First, the example focuses on schema issues, including inferring a schema from the loaded IDataReader, and then handling incompatible schemas, and schemas with missing or additional columns. L’exemple se concentre ensuite sur les problèmes de données, notamment la gestion des différentes options de chargement.The example then focuses on data issues, including handling the various loading options.

static void Main()
{
    // This example examines a number of scenarios involving the 
    // DataTable.Load method.
    Console.WriteLine("Load a DataTable and infer its schema:");

    // The table has no schema. The Load method will infer the 
    // schema from the IDataReader:
    DataTable table = new DataTable();

    // Retrieve a data reader, based on the Customers data. In
    // an application, this data might be coming from a middle-tier
    // business object:
    DataTableReader reader = new DataTableReader(GetCustomers());

    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable from an incompatible IDataReader:");

    // Create a table with a single integer column. Attempt
    // to load data from a reader with a schema that is 
    // incompatible. Note the exception, determined
    // by the particular incompatibility:
    table = GetIntegerTable();
    reader = new DataTableReader(GetStringTable());
    try
    {
        table.Load(reader);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.GetType().Name + ":" + ex.Message);
    }

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has extra columns:");

    // Note that loading a reader with extra columns adds
    // the columns to the existing table, if possible:
    table = GetIntegerTable();
    reader = new DataTableReader(GetCustomers());
    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has missing columns:");

    // Note that loading a reader with missing columns causes 
    // the columns to be filled with null data, if possible:
    table = GetCustomers();
    reader = new DataTableReader(GetIntegerTable());
    table.Load(reader);
    PrintColumns(table);

    // Demonstrate the various possibilites when loading data into
    // a DataTable that already contains data.
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Demonstrate data considerations:");
    Console.WriteLine("Current value, Original value, (RowState)");
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Original table:");

    table = SetupModifiedRows();
    DisplayRowState(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine("Data in IDataReader to be loaded:");
    DisplayRowState(GetChangedCustomers());

    PerformDemo(LoadOption.OverwriteChanges);
    PerformDemo(LoadOption.PreserveChanges);
    PerformDemo(LoadOption.Upsert);

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

private static void DisplayRowState(DataTable table)
{
    for (int i = 0; i <= table.Rows.Count - 1; i++)
    {
        object current = "--";
        object original = "--";
        DataRowState rowState = table.Rows[i].RowState;

        // Attempt to retrieve the current value, which doesn't exist
        // for deleted rows:
        if (rowState != DataRowState.Deleted)
        {
            current = table.Rows[i]["Name", DataRowVersion.Current];
        }

        // Attempt to retrieve the original value, which doesn't exist
        // for added rows:
        if (rowState != DataRowState.Added)
        {
            original = table.Rows[i]["Name", DataRowVersion.Original];
        }
        Console.WriteLine("{0}: {1}, {2} ({3})", i, 
            current, original, rowState);
    }
}

private static DataTable GetChangedCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));
    table.Columns.Add("Name", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 0, "XXX" });
    table.Rows.Add(new object[] { 1, "XXX" });
    table.Rows.Add(new object[] { 2, "XXX" });
    table.Rows.Add(new object[] { 3, "XXX" });
    table.Rows.Add(new object[] { 4, "XXX" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetCustomers()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));
    table.Columns.Add("Name", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 0, "Mary" });
    table.Rows.Add(new object[] { 1, "Andy" });
    table.Rows.Add(new object[] { 2, "Peter" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetIntegerTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 4 });
    table.Rows.Add(new object[] { 5 });
    table.AcceptChanges();
    return table;
}

private static DataTable GetStringTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { "Mary" });
    table.Rows.Add(new object[] { "Andy" });
    table.Rows.Add(new object[] { "Peter" });
    table.AcceptChanges();
    return table;
}

private static void PerformDemo(LoadOption optionForLoad)
{

    // Load data into a DataTable, retrieve a DataTableReader containing
    // different data, and call the Load method. Depending on the
    // LoadOption value passed as a parameter, this procedure displays
    // different results in the DataTable.
    Console.WriteLine(" ============================= ");
    Console.WriteLine("table.Load(reader, {0})", optionForLoad);
    Console.WriteLine(" ============================= ");

    DataTable table = SetupModifiedRows();
    DataTableReader reader = new DataTableReader(GetChangedCustomers());
    table.RowChanging +=new DataRowChangeEventHandler(HandleRowChanging);

    table.Load(reader, optionForLoad);
    Console.WriteLine();
    DisplayRowState(table);
}

private static void PrintColumns(DataTable table)
{
    // Loop through all the rows in the DataTableReader
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0; i < table.Columns.Count; i++)
        {
            Console.Write(row[i] + " ");
        }
        Console.WriteLine();
    }
}

private static DataTable SetupModifiedRows()
{
    // Fill a DataTable with customer info, and 
    // then modify, delete, and add rows.

    DataTable table = GetCustomers();
    // Row 0 is unmodified.
    // Row 1 is modified.
    // Row 2 is deleted.
    // Row 3 is added.
    table.Rows[1]["Name"] = "Sydney";
    table.Rows[2].Delete();
    DataRow row = table.NewRow();
    row["ID"] = 3;
    row["Name"] = "Melony";
    table.Rows.Add(row);

    // Note that the code doesn't call
    // table.AcceptChanges()
    return table;
}

static void HandleRowChanging(object sender, DataRowChangeEventArgs e)
{
    Console.WriteLine(
        "RowChanging event: ID = {0}, action = {1}", e.Row["ID"], e.Action);
}
Sub Main()
  Dim table As New DataTable()

  ' This example examines a number of scenarios involving the
  '  DataTable.Load method.
  Console.WriteLine("Load a DataTable and infer its schema:")

  ' Retrieve a data reader, based on the Customers data. In
  ' an application, this data might be coming from a middle-tier
  ' business object:
  Dim reader As New DataTableReader(GetCustomers())

  ' The table has no schema. The Load method will infer the 
  ' schema from the IDataReader:
  table.Load(reader)
  PrintColumns(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable from an incompatible IDataReader:")

  ' Create a table with a single integer column. Attempt
  ' to load data from a reader with a schema that is 
  ' incompatible. Note the exception, determined
  ' by the particular incompatibility:
  table = GetIntegerTable()
  reader = New DataTableReader(GetStringTable())
  Try
    table.Load(reader)
  Catch ex As Exception
    Console.WriteLine(ex.GetType.Name & ":" & ex.Message())
  End Try

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable with an IDataReader that has extra columns:")

  ' Note that loading a reader with extra columns adds
  ' the columns to the existing table, if possible:
  table = GetIntegerTable()
  reader = New DataTableReader(GetCustomers())
  table.Load(reader)
  PrintColumns(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine( _
      "Load a DataTable with an IDataReader that has missing columns:")

  ' Note that loading a reader with missing columns causes 
  ' the columns to be filled with null data, if possible:
  table = GetCustomers()
  reader = New DataTableReader(GetIntegerTable())
  table.Load(reader)
  PrintColumns(table)

  ' Demonstrate the various possibilites when loading data into
  ' a DataTable that already contains data.
  Console.WriteLine(" ============================= ")
  Console.WriteLine("Demonstrate data considerations:")
  Console.WriteLine("Current value, Original value, (RowState)")
  Console.WriteLine(" ============================= ")
  Console.WriteLine("Original table:")

  table = SetupModifiedRows()
  DisplayRowState(table)

  Console.WriteLine(" ============================= ")
  Console.WriteLine("Data in IDataReader to be loaded:")
  DisplayRowState(GetChangedCustomers())

  PerformDemo(LoadOption.OverwriteChanges)
  PerformDemo(LoadOption.PreserveChanges)
  PerformDemo(LoadOption.Upsert)

  Console.WriteLine("Press any key to continue.")
  Console.ReadKey()
End Sub

Private Sub DisplayRowState(ByVal table As DataTable)
  For i As Integer = 0 To table.Rows.Count - 1
    Dim current As Object = "--"
    Dim original As Object = "--"
    Dim rowState As DataRowState = table.Rows(i).RowState

    ' Attempt to retrieve the current value, which doesn't exist
    ' for deleted rows:
    If rowState <> DataRowState.Deleted Then
      current = table.Rows(i)("Name", DataRowVersion.Current)
    End If

    ' Attempt to retrieve the original value, which doesn't exist
    ' for added rows:
    If rowState <> DataRowState.Added Then
      original = table.Rows(i)("Name", DataRowVersion.Original)
    End If
    Console.WriteLine("{0}: {1}, {2} ({3})", i, _
      current, original, rowState)
  Next
End Sub

Private Function GetChangedCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable

  ' Create two columns, ID and Name.
  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(Integer))
  table.Columns.Add("Name", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {0, "XXX"})
  table.Rows.Add(New Object() {1, "XXX"})
  table.Rows.Add(New Object() {2, "XXX"})
  table.Rows.Add(New Object() {3, "XXX"})
  table.Rows.Add(New Object() {4, "XXX"})
  table.AcceptChanges()
  Return table
End Function

Private Function GetCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable

  ' Create two columns, ID and Name.
  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(Integer))
  table.Columns.Add("Name", GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {0, "Mary"})
  table.Rows.Add(New Object() {1, "Andy"})
  table.Rows.Add(New Object() {2, "Peter"})
  table.AcceptChanges()
  Return table
End Function

Private Function GetIntegerTable() As DataTable
  ' Create sample table with a single Int32 column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(Integer))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {4})
  table.Rows.Add(New Object() {5})
  table.AcceptChanges()
  Return table
End Function

Private Function GetStringTable() As DataTable
  ' Create sample table with a single String column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {"Mary"})
  table.Rows.Add(New Object() {"Andy"})
  table.Rows.Add(New Object() {"Peter"})
  table.AcceptChanges()
  Return table
End Function

Private Sub PerformDemo(ByVal optionForLoad As LoadOption)

  ' Load data into a DataTable, retrieve a DataTableReader containing
  ' different data, and call the Load method. Depending on the
  ' LoadOption value passed as a parameter, this procedure displays
  ' different results in the DataTable.
  Console.WriteLine(" ============================= ")
  Console.WriteLine("table.Load(reader, {0})", optionForLoad)
  Console.WriteLine(" ============================= ")

  Dim table As DataTable = SetupModifiedRows()
  Dim reader As New DataTableReader(GetChangedCustomers())
  AddHandler table.RowChanging, New _
      DataRowChangeEventHandler(AddressOf HandleRowChanging)

  table.Load(reader, optionForLoad)
  Console.WriteLine()
  DisplayRowState(table)
End Sub

Private Sub PrintColumns( _
   ByVal table As DataTable)

  ' Loop through all the rows in the DataTableReader.
  For Each row As DataRow In table.Rows
    For Each col As DataColumn In table.Columns
      Console.Write(row(col).ToString() & " ")
    Next
    Console.WriteLine()
  Next
End Sub

Private Function SetupModifiedRows() As DataTable
  ' Fill a DataTable with customer info, and 
  ' then modify, delete, and add rows.

  Dim table As DataTable = GetCustomers()
  ' Row 0 is unmodified.
  ' Row 1 is modified.
  ' Row 2 is deleted.
  ' Row 3 is added.
  table.Rows(1)("Name") = "Sydney"
  table.Rows(2).Delete()
  Dim row As DataRow = table.NewRow
  row("ID") = 3
  row("Name") = "Melony"
  table.Rows.Add(row)

  ' Note that the code doesn't call
  ' table.AcceptChanges()
  Return table
End Function

Private Sub HandleRowChanging(ByVal sender As Object, _
      ByVal e As System.Data.DataRowChangeEventArgs)
  Console.WriteLine( _
      "RowChanging event: ID = {0}, action = {1}", e.Row("ID"), e.Action)
End Sub

Remarques

La Load méthode consomme le premier jeu de résultats du chargé IDataReaderet, une fois l’opération terminée, définit la position du lecteur sur le jeu de résultats suivant, le cas échéant.The Load method consumes the first result set from the loaded IDataReader, and after successful completion, sets the reader's position to the next result set, if any. Lors de la conversion de Load données, la méthode utilise les mêmes règles Fill de conversion que la méthode.When converting data, the Load method uses the same conversion rules as the Fill method.

La Load méthode doit prendre en compte trois problèmes spécifiques lors du chargement des données à IDataReader partir d’une instance : schéma, données et opérations d’événement.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Lorsque vous travaillez avec le schéma, Load la méthode peut rencontrer des conditions, comme décrit dans le tableau suivant.When working with the schema, the Load method may encounter conditions as described in the following table. Les opérations de schéma sont effectuées pour tous les jeux de résultats importés, même ceux qui ne contiennent pas de données.The schema operations take place for all imported result sets, even those containing no data.

ConditionCondition ComportementBehavior
N' DataTable a pas de schéma.The DataTable has no schema. La Load méthode déduit le schéma en fonction du jeu de résultats du importé IDataReader.The Load method infers the schema based on the result set from the imported IDataReader.
Le DataTable a un schéma, mais il est incompatible avec le schéma chargé.The DataTable has a schema, but it is incompatible with the loaded schema. La Load méthode lève une exception correspondant à l’erreur particulière qui se produit lors de la tentative de chargement des données dans le schéma incompatible.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Les schémas sont compatibles, mais le schéma du jeu de résultats chargé contient des colonnes qui n’existent DataTablepas dans le.The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. La Load méthode ajoute les colonnes supplémentaires au DataTableschéma de.The Load method adds the extra columns to DataTable's schema. La méthode lève une exception si les colonnes correspondantes dans DataTable le et le jeu de résultats chargé ne sont pas compatibles avec la valeur.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. La méthode récupère également les informations de contrainte du jeu de résultats pour toutes les colonnes ajoutées.The method also retrieves constraint information from the result set for all added columns. Sauf dans le cas d’une contrainte de clé primaire, cette information de contrainte est utilisée uniquement DataTable si le actuel ne contient aucune colonne au début de l’opération de chargement.Except for the case of Primary Key constraint, this constraint information is used only if the current DataTable does not contain any columns at the start of the load operation.
Les schémas sont compatibles, mais le schéma du jeu de résultats chargé contient moins de colonnes que DataTablele.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Si une colonne manquante a une valeur par défaut définie ou si le type de données de la Load colonne est Nullable, la méthode autorise l’ajout des lignes, en remplaçant la valeur par défaut ou null pour la colonne manquante.If a missing column has a default value defined or the column's data type is nullable, the Load method allows the rows to be added, substituting the default or null value for the missing column. Si aucune valeur par défaut ou NULL ne peut être utilisée, Load la méthode lève une exception.If no default value or null can be used, then the Load method throws an exception. Si aucune valeur par défaut spécifique n’a été fournie Load , la méthode utilise la valeur NULL comme valeur par défaut implicite.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Avant de prendre en compte le Load comportement de la méthode en termes d’opérations de données, considérez DataTable que chaque ligne dans un gère à la fois la valeur actuelle et la valeur d’origine de chaque colonne.Before considering the behavior of the Load method in terms of data operations, consider that each row within a DataTable maintains both the current value and the original value for each column. Ces valeurs peuvent être équivalentes, ou peuvent être différentes si les données de la ligne ont été modifiées depuis le DataTableremplissage de.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Pour plus d’informations , consultez États des lignes et versions de ligne .See Row States and Row Versions for more information.

Dans cet appel de méthode, le LoadOption paramètre spécifié influence le traitement des données entrantes.In this method call, the specified LoadOption parameter influences the processing of the incoming data. Comment la méthode Load doit-elle gérer le chargement de lignes ayant la même clé primaire en tant que lignes existantes ?How should the Load method handle loading rows that have the same primary key as existing rows? Dois-je modifier les valeurs actuelles, les valeurs d’origine ou les deux ?Should it modify current values, original values, or both? Ces problèmes, et bien plus encore, sont contrôlés par le loadOption paramètre.These issues, and more, are controlled by the loadOption parameter.

Si la ligne existante et la ligne entrante contiennent des valeurs de clés primaires correspondantes, la ligne est traitée à l’aide de sa valeur d’état de ligne actuelle, sinon elle est traitée comme une nouvelle ligne.If the existing row and the incoming row contain corresponding primary key values, the row is processed using its current row state value, otherwise it's treated as a new row.

En termes d’opérations d’événement, RowChanging l’événement se produit avant la modification de chaque ligne RowChanged , et l’événement se produit après que chaque ligne a été modifiée.In terms of event operations, the RowChanging event occurs before each row is changed, and the RowChanged event occurs after each row has been changed. Dans chaque cas, la Action propriété de l' DataRowChangeEventArgs instance transmise au gestionnaire d’événements contient des informations sur l’action particulière associée à l’événement.In each case, the Action property of the DataRowChangeEventArgs instance passed to the event handler contains information about the particular action associated with the event. Cette valeur d’action varie selon l’état de la ligne avant l’opération de chargement.This action value varies, depending on the state of the row before the load operation. Dans chaque cas, les deux événements se produisent et l’action est la même pour chaque.In each case, both events occur, and the action is the same for each. L’action peut être appliquée à la version actuelle ou à la version d’origine de chaque ligne, ou les deux, selon l’état actuel de la ligne.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

Le tableau suivant affiche le comportement de la méthode Load lorsqu’elle est appelée avec LoadOption chacune des valeurs, et montre également comment les valeurs interagissent avec l’état de ligne pour la ligne en cours de chargement.The following table displays behavior for the Load method when called with each of the LoadOption values, and also shows how the values interact with the row state for the row being loaded. La dernière ligne (étiquetée « (absent) ») décrit le comportement des lignes entrantes qui ne correspondent à aucune ligne existante.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Chaque cellule de ce tableau décrit les valeurs actuelles et d’origine d’un champ dans une ligne, ainsi que DataRowState la valeur de la valeur Load une fois que la méthode est terminée.Each cell in this table describes the current and original value for a field within a row, along with the DataRowState for the value after the Load method has completed.

DataRowState existantExisting DataRowState UpsertUpsert OverwriteChangesOverwriteChanges PreserveChanges (comportement par défaut)PreserveChanges (Default behavior)
AddedAdded Actuel = <> entrantCurrent = <Incoming>

Original =-<non disponible >Original = -<Not available>

État = <ajouté >State = <Added>

RowAction = modificationRowAction = Change
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> existantesCurrent = <Existing>

Original = <> entrantOriginal = <Incoming>

État = <modifié >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
Modifiée leModified Actuel = <> entrantCurrent = <Incoming>

Original = <> existantesOriginal = <Existing>

État = <modifié >State = <Modified>

RowAction = modificationRowAction = Change
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> existantesCurrent = <Existing>

Original = <> entrantOriginal = <Incoming>

État = <modifié >State = <Modified>

RowAction = ChangeOriginalRowAction =ChangeOriginal
SuppriméDeleted (Le chargement n’affecte pas les lignes supprimées)(Load does not affect deleted rows)

Actuel =---Current = ---

Original = <> existantesOriginal = <Existing>

État = <supprimé >State = <Deleted>

(Une nouvelle ligne est ajoutée avec les caractéristiques suivantes)(New row is added with the following characteristics)

Actuel = <> entrantCurrent = <Incoming>

Original = <non disponible >Original = <Not available>

État = <ajouté >State = <Added>

RowAction = ajouterRowAction = Add
Annuler la suppression etUndo delete and

Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <non disponible >Current = <Not available>

Original = <> entrantOriginal = <Incoming>

État = <supprimé >State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
InchangéUnchanged Actuel = <> entrantCurrent = <Incoming>

Original = <> existantesOriginal = <Existing>

Si la nouvelle valeur est identique à la valeur existante, alorsIf new value is the same as the existing value then

État = <inchangé >State = <Unchanged>

RowAction = NothingRowAction = Nothing

ElseElse

État = <modifié >State = <Modified>

RowAction = modificationRowAction = Change
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Absent)Not present) Actuel = <> entrantCurrent = <Incoming>

Original = <non disponible >Original = <Not available>

État = <ajouté >State = <Added>

RowAction = ajouterRowAction = Add
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

Les valeurs d' DataColumn un peuvent être restreintes à l’aide de propriétés telles ReadOnly que AutoIncrementet.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. La Load méthode gère ces colonnes d’une manière qui est cohérente avec le comportement défini par les propriétés de la colonne.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. La contrainte en lecture seule sur DataColumn un est applicable uniquement aux modifications qui se produisent dans la mémoire.The read only constraint on a DataColumn is applicable only for changes that occur in memory. La Load méthode remplace les valeurs de colonne en lecture seule, si nécessaire.The Load method's overwrites the read-only column values, if needed.

Si vous spécifiez les options OverwriteChanges ou PreserveChanges lors de Load l’appel de la méthode, l’hypothèse est faite que les données entrantes DataTableproviennent de la source de données principale de et le DataTable effectue le suivi des modifications et peut se propager les modifications apportées à la source de données.If you specify the OverwriteChanges or PreserveChanges options when calling the Load method, then the assumption is made that the incoming data is coming from the DataTable's primary data source, and the DataTable tracks changes and can propagate the changes back to the data source. Si vous sélectionnez l’option Upsert, il est supposé que les données proviennent d’une source de données secondaire, par exemple les données fournies par un composant de niveau intermédiaire, susceptibles d’être modifiées par un utilisateur.If you select the Upsert option, it is assumed that the data is coming from one of a secondary data source, such as data provided by a middle-tier component, perhaps altered by a user. Dans ce cas, l’objectif est de regrouper les données d’une ou de plusieurs sources de données dans DataTablele, puis de propager les données vers la source de données principale.In this case, the assumption is that the intent is to aggregate data from one or more data sources in the DataTable, and then perhaps propagate the data back to the primary data source. Le LoadOption paramètre est utilisé pour déterminer la version spécifique de la ligne à utiliser pour la comparaison de clés primaires.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. Le tableau ci-dessous fournit les détails.The table below provides the details.

Option de chargementLoad option Version DataRow utilisée pour la comparaison de clé primaireDataRow version used for primary key comparison
OverwriteChanges Version d’origine, si elle existe, sinon la version actuelleOriginal version, if it exists, otherwise Current version
PreserveChanges Version d’origine, si elle existe, sinon la version actuelleOriginal version, if it exists, otherwise Current version
Upsert Version actuelle, si elle existe, sinon la version d’origineCurrent version, if it exists, otherwise Original version
Voir aussi

Load(IDataReader, LoadOption, FillErrorEventHandler) Load(IDataReader, LoadOption, FillErrorEventHandler) 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.

public:
 virtual void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, System::Data::FillErrorEventHandler ^ errorHandler);
public virtual void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption, System.Data.FillErrorEventHandler errorHandler);
abstract member Load : System.Data.IDataReader * System.Data.LoadOption * System.Data.FillErrorEventHandler -> unit
override this.Load : System.Data.IDataReader * System.Data.LoadOption * System.Data.FillErrorEventHandler -> unit

Paramètres

reader
IDataReader IDataReader IDataReader IDataReader

Un IDataReader qui fournit un jeu de résultats.A IDataReader that provides a result set.

loadOption
LoadOption LoadOption LoadOption LoadOption

Valeur issue de l'énumération LoadOption qui indique comment les lignes déjà présentes dans le DataTable sont associées aux lignes entrantes qui partagent la même clé primaire.A value from the LoadOption enumeration that indicates how rows already in the DataTable are combined with incoming rows that share the same primary key.

errorHandler
FillErrorEventHandler FillErrorEventHandler FillErrorEventHandler FillErrorEventHandler

Un délégué FillErrorEventHandler à appeler lorsqu'une erreur se produit en chargeant des données.A FillErrorEventHandler delegate to call when an error occurs while loading data.

Exemples

static void Main()
{
    // Attempt to load data from a data reader in which
    // the schema is incompatible with the current schema.
    // If you use exception handling, you won't get the chance
    // to examine each row, and each individual table,
    // as the Load method progresses.
    // By taking advantage of the FillErrorEventHandler delegate,
    // you can interact with the Load process as an error occurs,
    // attempting to fix the problem, or simply continuing or quitting
    // the Load process:
    DataTable table = GetIntegerTable();
    DataTableReader reader = new DataTableReader(GetStringTable());
    table.Load(reader, LoadOption.OverwriteChanges, FillErrorHandler);

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

private static DataTable GetIntegerTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(int));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { 4 });
    table.Rows.Add(new object[] { 5 });
    table.AcceptChanges();
    return table;
}

private static DataTable GetStringTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", typeof(string));

    // Set the ID column as the primary key column.
    table.PrimaryKey = new DataColumn[] { idColumn };

    table.Rows.Add(new object[] { "Mary" });
    table.Rows.Add(new object[] { "Andy" });
    table.Rows.Add(new object[] { "Peter" });
    table.AcceptChanges();
    return table;
}

static void FillErrorHandler(object sender, FillErrorEventArgs e)
{
    // You can use the e.Errors value to determine exactly what
    // went wrong.
    if (e.Errors.GetType() == typeof(System.FormatException))
    {
        Console.WriteLine("Error when attempting to update the value: {0}", 
            e.Values[0]);
    }

    // Setting e.Continue to True tells the Load
    // method to continue trying. Setting it to False
    // indicates that an error has occurred, and the 
    // Load method raises the exception that got 
    // you here.
    e.Continue = true;
}
Sub Main()
  Dim table As New DataTable()

  ' Attempt to load data from a data reader in which
  ' the schema is incompatible with the current schema.
  ' If you use exception handling, you won't get the chance
  ' to examine each row, and each individual table,
  ' as the Load method progresses.
  ' By taking advantage of the FillErrorEventHandler delegate,
  ' you can interact with the Load process as an error occurs,
  ' attempting to fix the problem, or simply continuing or quitting
  ' the Load process:
  table = GetIntegerTable()
  Dim reader As New DataTableReader(GetStringTable())
  table.Load(reader, LoadOption.OverwriteChanges, _
      AddressOf FillErrorHandler)

  Console.WriteLine("Press any key to continue.")
  Console.ReadKey()
End Sub

Private Sub FillErrorHandler(ByVal sender As Object, _
  ByVal e As FillErrorEventArgs)
  ' You can use the e.Errors value to determine exactly what
  ' went wrong.
  If e.Errors.GetType Is GetType(System.FormatException) Then
    Console.WriteLine("Error when attempting to update the value: {0}", _
      e.Values(0))
  End If

  ' Setting e.Continue to True tells the Load
  ' method to continue trying. Setting it to False
  ' indicates that an error has occurred, and the 
  ' Load method raises the exception that got 
  ' you here.
  e.Continue = True
End Sub

Private Function GetIntegerTable() As DataTable
  ' Create sample table with a single Int32 column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", GetType(Integer))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {4})
  table.Rows.Add(New Object() {5})
  table.TableName = "IntegerTable"
  table.AcceptChanges()
  Return table
End Function

Private Function GetStringTable() As DataTable
  ' Create sample table with a single String column.
  Dim table As New DataTable

  Dim idColumn As DataColumn = table.Columns.Add("ID", _
      GetType(String))

  ' Set the ID column as the primary key column.
  table.PrimaryKey = New DataColumn() {idColumn}

  table.Rows.Add(New Object() {"Mary"})
  table.Rows.Add(New Object() {"Andy"})
  table.Rows.Add(New Object() {"Peter"})
  table.AcceptChanges()
  Return table
End Function

Private Sub PrintColumns( _
   ByVal table As DataTable)

  ' Loop through all the rows in the DataTableReader.
  For Each row As DataRow In table.Rows
    For Each col As DataColumn In table.Columns
      Console.Write(row(col).ToString() & " ")
    Next
    Console.WriteLine()
  Next
End Sub

Remarques

La Load méthode consomme le premier jeu de résultats du chargé IDataReaderet, une fois l’opération terminée, définit la position du lecteur sur le jeu de résultats suivant, le cas échéant.The Load method consumes the first result set from the loaded IDataReader, and after successful completion, sets the reader's position to the next result set, if any. Lors de la conversion de Load données, la méthode utilise les mêmes règles DbDataAdapter.Fill de conversion que la méthode.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

La Load méthode doit prendre en compte trois problèmes spécifiques lors du chargement des données à IDataReader partir d’une instance : schéma, données et opérations d’événement.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Lorsque vous travaillez avec le schéma, Load la méthode peut rencontrer des conditions, comme décrit dans le tableau suivant.When working with the schema, the Load method may encounter conditions as described in the following table. Les opérations de schéma sont effectuées pour tous les jeux de résultats importés, même ceux qui ne contiennent pas de données.The schema operations take place for all imported result sets, even those containing no data.

ConditionCondition ComportementBehavior
N' DataTable a pas de schéma.The DataTable has no schema. La Load méthode déduit le schéma en fonction du jeu de résultats du importé IDataReader.The Load method infers the schema based on the result set from the imported IDataReader.
Le DataTable a un schéma, mais il est incompatible avec le schéma chargé.The DataTable has a schema, but it is incompatible with the loaded schema. La Load méthode lève une exception correspondant à l’erreur particulière qui se produit lors de la tentative de chargement des données dans le schéma incompatible.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Les schémas sont compatibles, mais le schéma du jeu de résultats chargé contient des colonnes qui n’existent DataTablepas dans le.The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. La Load méthode ajoute la ou les colonnes supplémentaires au DataTableschéma de.The Load method adds the extra column(s) to DataTable's schema. La méthode lève une exception si les colonnes correspondantes dans DataTable le et le jeu de résultats chargé ne sont pas compatibles avec la valeur.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. La méthode récupère également les informations de contrainte du jeu de résultats pour toutes les colonnes ajoutées.The method also retrieves constraint information from the result set for all added columns. Sauf dans le cas d’une contrainte de clé primaire, cette information de contrainte est utilisée uniquement DataTable si le actuel ne contient aucune colonne au début de l’opération de chargement.Except for the case of Primary Key constraint, this constraint information is used only if the current DataTable does not contain any columns at the start of the load operation.
Les schémas sont compatibles, mais le schéma du jeu de résultats chargé contient moins de colonnes que DataTablele.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Si une colonne manquante a une valeur par défaut définie ou si le type de données de la Load colonne est Nullable, la méthode autorise l’ajout des lignes, en remplaçant la valeur par défaut ou null pour la colonne manquante.If a missing column has a default value defined or the column's data type is nullable, the Load method allows the rows to be added, substituting the default or null value for the missing column. Si aucune valeur par défaut ou NULL ne peut être utilisée, Load la méthode lève une exception.If no default value or null can be used, then the Load method throws an exception. Si aucune valeur par défaut spécifique n’a été fournie Load , la méthode utilise la valeur NULL comme valeur par défaut implicite.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Avant de prendre en compte le Load comportement de la méthode en termes d’opérations de données, considérez DataTable que chaque ligne dans un gère à la fois la valeur actuelle et la valeur d’origine de chaque colonne.Before considering the behavior of the Load method in terms of data operations, consider that each row within a DataTable maintains both the current value and the original value for each column. Ces valeurs peuvent être équivalentes, ou peuvent être différentes si les données de la ligne ont été modifiées depuis le DataTableremplissage de.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Pour plus d’informations , consultez États des lignes et versions de ligne .See Row States and Row Versions for more information.

Dans cet appel de méthode, le LoadOption paramètre spécifié influence le traitement des données entrantes.In this method call, the specified LoadOption parameter influences the processing of the incoming data. Comment la méthode Load doit-elle gérer le chargement de lignes ayant la même clé primaire en tant que lignes existantes ?How should the Load method handle loading rows that have the same primary key as existing rows? Dois-je modifier les valeurs actuelles, les valeurs d’origine ou les deux ?Should it modify current values, original values, or both? Ces problèmes, et bien plus encore, sont contrôlés par le loadOption paramètre.These issues, and more, are controlled by the loadOption parameter.

Si la ligne existante et la ligne entrante contiennent des valeurs de clés primaires correspondantes, la ligne est traitée à l’aide de sa valeur d’état de ligne actuelle, sinon elle est traitée comme une nouvelle ligne.If the existing row and the incoming row contain corresponding primary key values, the row is processed using its current row state value, otherwise it's treated as a new row.

En termes d’opérations d’événement, RowChanging l’événement se produit avant la modification de chaque ligne RowChanged , et l’événement se produit après que chaque ligne a été modifiée.In terms of event operations, the RowChanging event occurs before each row is changed, and the RowChanged event occurs after each row has been changed. Dans chaque cas, la Action propriété de l' DataRowChangeEventArgs instance transmise au gestionnaire d’événements contient des informations sur l’action particulière associée à l’événement.In each case, the Action property of the DataRowChangeEventArgs instance passed to the event handler contains information about the particular action associated with the event. Cette valeur d’action varie selon l’état de la ligne avant l’opération de chargement.This action value varies, depending on the state of the row before the load operation. Dans chaque cas, les deux événements se produisent et l’action est la même pour chaque.In each case, both events occur, and the action is the same for each. L’action peut être appliquée à la version actuelle ou à la version d’origine de chaque ligne, ou les deux, selon l’état actuel de la ligne.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

Le tableau suivant affiche le comportement de la méthode Load lorsqu’elle est appelée avec LoadOption chacune des valeurs, et montre également comment les valeurs interagissent avec l’état de ligne pour la ligne en cours de chargement.The following table displays behavior for the Load method when called with each of the LoadOption values, and also shows how the values interact with the row state for the row being loaded. La dernière ligne (étiquetée « (absent) ») décrit le comportement des lignes entrantes qui ne correspondent à aucune ligne existante.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Chaque cellule de ce tableau décrit les valeurs actuelles et d’origine d’un champ dans une ligne, ainsi que DataRowState la valeur de la valeur Load une fois que la méthode est terminée.Each cell in this table describes the current and original value for a field within a row, along with the DataRowState for the value after the Load method has completed.

DataRowState existantExisting DataRowState UpsertUpsert OverwriteChangesOverwriteChanges PreserveChanges (comportement par défaut)PreserveChanges (Default behavior)
AddedAdded Actuel = <> entrantCurrent = <Incoming>

Original =-<non disponible >Original = -<Not available>

État = <ajouté >State = <Added>

RowAction = modificationRowAction = Change
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> existantesCurrent = <Existing>

Original = <> entrantOriginal = <Incoming>

État = <modifié >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
Modifiée leModified Actuel = <> entrantCurrent = <Incoming>

Original = <> existantesOriginal = <Existing>

État = <modifié >State = <Modified>

RowAction = modificationRowAction = Change
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> existantesCurrent = <Existing>

Original = <> entrantOriginal = <Incoming>

État = <modifié >State = <Modified>

RowAction = ChangeOriginalRowAction =ChangeOriginal
eletedeleted (Le chargement n’affecte pas les lignes supprimées)(Load does not affect deleted rows)

Actuel =---Current = ---

Original = <> existantesOriginal = <Existing>

État = <supprimé >State = <Deleted>

(Une nouvelle ligne est ajoutée avec les caractéristiques suivantes)(New row is added with the following characteristics)

Actuel = <> entrantCurrent = <Incoming>

Original = <non disponible >Original = <Not available>

État = <ajouté >State = <Added>

RowAction = ajouterRowAction = Add
Annuler la suppression etUndo delete and

Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <non disponible >Current = <Not available>

Original = <> entrantOriginal = <Incoming>

État = <supprimé >State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
InchangéUnchanged Actuel = <> entrantCurrent = <Incoming>

Original = <> existantesOriginal = <Existing>

Si la nouvelle valeur est identique à la valeur existante, alorsIf new value is the same as the existing value then

État = <inchangé >State = <Unchanged>

RowAction = NothingRowAction = Nothing

ElseElse

État = <modifié >State = <Modified>

RowAction = modificationRowAction = Change
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Absent)Not present) Actuel = <> entrantCurrent = <Incoming>

Original = <non disponible >Original = <Not available>

État = <ajouté >State = <Added>

RowAction = ajouterRowAction = Add
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Actuel = <> entrantCurrent = <Incoming>

Original = <> entrantOriginal = <Incoming>

État = <inchangé >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

Les valeurs d' DataColumn un peuvent être restreintes à l’aide de propriétés telles ReadOnly que AutoIncrementet.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. La Load méthode gère ces colonnes d’une manière qui est cohérente avec le comportement défini par les propriétés de la colonne.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. La contrainte en lecture seule sur DataColumn un est applicable uniquement aux modifications qui se produisent dans la mémoire.The read only constraint on a DataColumn is applicable only for changes that occur in memory. La Load méthode remplace les valeurs de colonne en lecture seule, si nécessaire.The Load method's overwrites the read-only column values, if needed.

Si vous spécifiez les options OverwriteChanges ou PreserveChanges lors de Load l’appel de la méthode, l’hypothèse est faite que les données entrantes DataTableproviennent de la source de données principale de et le DataTable effectue le suivi des modifications et peut se propager les modifications apportées à la source de données.If you specify the OverwriteChanges or PreserveChanges options when calling the Load method, then the assumption is made that the incoming data is coming from the DataTable's primary data source, and the DataTable tracks changes and can propagate the changes back to the data source. Si vous sélectionnez l’option Upsert, il est supposé que les données proviennent d’une source de données secondaire, par exemple les données fournies par un composant de niveau intermédiaire, susceptibles d’être modifiées par un utilisateur.If you select the Upsert option, it is assumed that the data is coming from one of a secondary data source, such as data provided by a middle-tier component, perhaps altered by a user. Dans ce cas, l’objectif est de regrouper les données d’une ou de plusieurs sources de données dans DataTablele, puis de propager les données vers la source de données principale.In this case, the assumption is that the intent is to aggregate data from one or more data sources in the DataTable, and then perhaps propagate the data back to the primary data source. Le LoadOption paramètre est utilisé pour déterminer la version spécifique de la ligne à utiliser pour la comparaison de clés primaires.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. Le tableau ci-dessous fournit les détails.The table below provides the details.

Option de chargementLoad option Version DataRow utilisée pour la comparaison de clé primaireDataRow version used for primary key comparison
OverwriteChanges Version d’origine, si elle existe, sinon la version actuelleOriginal version, if it exists, otherwise Current version
PreserveChanges Version d’origine, si elle existe, sinon la version actuelleOriginal version, if it exists, otherwise Current version
Upsert Version actuelle, si elle existe, sinon la version d’origineCurrent version, if it exists, otherwise Original version

Le errorHandler paramètre est un FillErrorEventHandler délégué qui fait référence à une procédure qui est appelée lorsqu’une erreur se produit lors du chargement des données.The errorHandler parameter is a FillErrorEventHandler delegate that refers to a procedure that is called when an error occurs while loading data. Le FillErrorEventArgs paramètre passé à la procédure fournit des propriétés qui vous permettent de récupérer des informations sur l’erreur qui s’est produite, la ligne de données DataTable actuelle et le en cours de remplissage.The FillErrorEventArgs parameter passed to the procedure provides properties that allow you to retrieve information about the error that occurred, the current row of data, and the DataTable being filled. À l’aide de ce mécanisme délégué, plutôt qu’un bloc try/catch plus simple, vous permet de déterminer l’erreur, de gérer la situation et de poursuivre le traitement si vous le souhaitez.Using this delegate mechanism, rather than a simpler try/catch block, allows you to determine the error, handle the situation, and continue processing if you like. Le FillErrorEventArgs paramètre fournit une Continue propriété true : affectez à cette propriété la valeur pour indiquer que vous avez géré l’erreur et souhaitez continuer le traitement.The FillErrorEventArgs parameter supplies a Continue property: set this property to true to indicate that you have handled the error and wish to continue processing. Affectez à la false propriété la valeur pour indiquer que vous souhaitez interrompre le traitement.Set the property to false to indicate that you wish to halt processing. N’oubliez pas que la définition de false la propriété sur entraîne la levée d’une exception par le code qui a déclenché le problème.Be aware that setting the property to false causes the code that triggered the problem to throw an exception.

Voir aussi

S’applique à