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

Definizione

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.Fills a DataTable with values from a data source using the supplied IDataReader. Se DataTable contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

Overload

Load(IDataReader) Load(IDataReader) Load(IDataReader) Load(IDataReader)

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.Fills a DataTable with values from a data source using the supplied IDataReader. Se DataTable contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti.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)

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.Fills a DataTable with values from a data source using the supplied IDataReader. Se DataTable contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti, in base al valore del parametro 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)

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita, tramite un delegato di gestione degli errori.Fills a DataTable with values from a data source using the supplied IDataReader using an error-handling delegate.

Esempi

Nell'esempio seguente vengono illustrati alcuni dei problemi relativi alla chiamata Load al metodo.The following example demonstrates several of the issues involved with calling the Load method. In primo luogo, l'esempio è incentrato sui problemi dello schema, tra cui l'inferenza di uno schema dall'oggetto caricato IDataReadere la gestione degli schemi incompatibili e degli schemi con colonne mancanti o aggiuntive.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'esempio si concentra quindi sui problemi di dati, inclusa la gestione delle varie opzioni di caricamento.The example then focuses on data issues, including handling the various loading options.

Nota

In questo esempio viene illustrato come utilizzare una delle versioni di overload di Load.This example shows how to use one of the overloaded versions of Load. Per altri esempi che potrebbero essere disponibili, vedere i singoli argomenti sull'overload.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

Commenti

Il Load metodo può essere usato in diversi scenari comuni, tutti centrati intorno al recupero di dati da un'origine dati specificata e alla relativa aggiunta al contenitore di dati corrente (in questo DataTablecaso, 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). Questi scenari descrivono l'utilizzo standard DataTableper un, descrivendo il comportamento di aggiornamento e Unione.These scenarios describe standard usage for a DataTable, describing its update and merge behavior.

Un DataTable oggetto viene sincronizzato o aggiornato con una singola origine dati primaria.A DataTable synchronizes or updates with a single primary data source. DataTable Rileva le modifiche, consentendo la sincronizzazione con l'origine dati primaria.The DataTable tracks changes, allowing synchronization with the primary data source. Un oggetto DataTable può inoltre accettare dati incrementali da una o più origini dati secondarie.In addition, a DataTable can accept incremental data from one or more secondary data sources. Non DataTable è responsabile del rilevamento delle modifiche per consentire la sincronizzazione con l'origine dati secondaria.The DataTable isn't responsible for tracking changes in order to allow synchronization with the secondary data source.

Date queste due ipotetiche origini dati, è probabile che un utente richieda uno dei comportamenti seguenti:Given these two hypothetical data sources, a user is likely to require one of the following behaviors:

  • Inizializzare DataTable da un'origine dati primaria.Initialize DataTable from a primary data source. In questo scenario, l'utente desidera inizializzare un oggetto DataTable vuoto con i valori dell'origine dati primaria.In this scenario, the user wants to initialize an empty DataTable with values from the primary data source. Successivamente, l'utente intende propagare le modifiche all'origine dati primaria.Later the user intends to propagate changes back to the primary data source.

  • Mantenere le modifiche e ripetere la sincronizzazione dall'origine dati primaria.Preserve changes and re-synchronize from the primary data source. In questo scenario, l'utente desidera DataTable compilare lo scenario precedente ed eseguire una sincronizzazione incrementale con l'origine dati primaria, mantenendo le modifiche apportate DataTablein.In 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.

  • Feed di dati incrementali dalle origini dati secondarie.Incremental data feed from secondary data sources. In questo scenario, l'utente desidera unire le modifiche da una o più origini dati secondarie e propagare le modifiche nell'origine dati primaria.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.

Il Load metodo rende possibili tutti questi scenari.The Load method makes all these scenarios possible. Tutti gli overload di questo metodo, tranne uno, consentono di specificare un parametro di opzione Load, che indica in che modo le righe DataTable sono già presenti in un oggetto combinato con le righe caricate.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. (L'overload che non consente di specificare il comportamento utilizza l'opzione di caricamento predefinita). Nella tabella seguente vengono descritte le tre opzioni di caricamento fornite LoadOption dall'enumerazione.(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. In ogni caso, la descrizione indica il comportamento quando la chiave primaria di una riga nei dati in arrivo corrisponde alla chiave primaria di una riga esistente.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.

Opzione LoadLoad Option DescriptionDescription
PreserveChanges (impostazione predefinita)PreserveChanges (default) Aggiorna la versione originale della riga con il valore della riga in arrivo.Updates the original version of the row with the value of the incoming row.
OverwriteChanges Aggiorna le versioni correnti e originali della riga con il valore della riga in arrivo.Updates the current and original versions of the row with the value of the incoming row.
Upsert Aggiorna la versione corrente della riga con il valore della riga in arrivo.Updates the current version of the row with the value of the incoming row.

In generale, le PreserveChanges opzioni OverwriteChanges e sono destinate agli scenari in cui l' DataSet utente deve sincronizzare e le relative modifiche con l'origine dati primaria.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 opzione semplifica l'aggregazione delle modifiche da una o più origini dati secondarie.The Upsert option facilitates aggregating changes from one or more secondary data sources.

Load(IDataReader) Load(IDataReader) Load(IDataReader) Load(IDataReader)

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.Fills a DataTable with values from a data source using the supplied IDataReader. Se DataTable contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti.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)

Parametri

reader
IDataReader IDataReader IDataReader IDataReader

Interfaccia IDataReader che fornisce un gruppo di risultati.An IDataReader that provides a result set.

Esempi

Nell'esempio seguente vengono illustrati alcuni dei problemi relativi alla chiamata Load al metodo.The following example demonstrates several of the issues involved with calling the Load method. In primo luogo, l'esempio è incentrato sui problemi dello schema, tra cui l'inferenza di uno schema dall'oggetto caricato IDataReadere la gestione degli schemi incompatibili e degli schemi con colonne mancanti o aggiuntive.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. Nell'esempio viene quindi chiamato Load il metodo, visualizzando i dati prima e dopo l'operazione di caricamento.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

Commenti

Il Load metodo utilizza il primo set di risultati dall'oggetto caricato IDataReadere, al termine, imposta la posizione del Reader sul set di risultati successivo, se presente.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. Quando si convertono i Load dati, il metodo usa le stesse regole DbDataAdapter.Fill di conversione del metodo.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

Il Load metodo deve tenere conto di tre problemi specifici quando si caricano i dati IDataReader da un'istanza di: schema, dati e operazioni di eventi.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Quando si utilizza lo schema, il Load metodo può rilevare condizioni come descritto nella tabella seguente.When working with the schema, the Load method may encounter conditions as described in the following table. Le operazioni dello schema avvengono per tutti i set di risultati importati, anche quelli che non contengono dati.The schema operations take place for all imported result sets, even those containing no data.

CondizioneCondition ComportamentoBehavior
Non DataTable dispone di alcuno schema.The DataTable has no schema. Il Load metodo deduce lo schema in base al set di risultati dall'oggetto importato IDataReader.The Load method infers the schema based on the result set from the imported IDataReader.
DataTable Dispone di uno schema, ma non è compatibile con lo schema caricato.The DataTable has a schema, but it is incompatible with the loaded schema. Il Load metodo genera un'eccezione corrispondente all'errore specifico che si verifica quando si tenta di caricare i dati nello schema incompatibile.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Gli schemi sono compatibili, ma lo schema del set di risultati caricato contiene colonne che non esistono in DataTable.The schemas are compatible, but the loaded result set schema contains columns that do not exist in the DataTable. Il Load metodo aggiunge le colonne aggiuntive allo DataTableschema di.The Load method adds the extra columns to DataTable's schema. Il metodo genera un'eccezione se le colonne corrispondenti in DataTable e il set di risultati caricati non sono compatibili con i valori.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Il metodo recupera inoltre le informazioni sui vincoli dal set di risultati per tutte le colonne aggiunte.The method also retrieves constraint information from the result set for all added columns. Ad eccezione del caso del vincolo PRIMARY KEY, queste informazioni sui vincoli vengono utilizzate solo se l' DataTable oggetto corrente non contiene colonne all'inizio dell'operazione di caricamento.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.
Gli schemi sono compatibili, ma lo schema del set di risultati caricato contiene un minor numero di DataTablecolonne rispetto a.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Se per una colonna mancante è stato definito un valore predefinito o il tipo di dati della colonna ammette Load valori null, il metodo consente di aggiungere le righe, sostituendo null il valore predefinito o per la colonna mancante.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. Se non è null possibile usare alcun valore predefinito, il Load metodo genera un'eccezione.If no default value or null can be used, then the Load method throws an exception. Se non è stato fornito alcun valore predefinito specifico, Load il metodo usa null il valore come valore predefinito implicito.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Prima di considerare il comportamento del Load metodo in termini di operazioni sui dati, tenere presente che ogni riga DataTable all'interno di un oggetto mantiene sia il valore corrente che quello originale per ogni colonna.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. Questi valori possono essere equivalenti oppure possono essere diversi se i dati nella riga sono stati modificati dopo la compilazione di DataTable.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Per altre informazioni, vedere Stati di riga e versioni di riga.For more information, see Row States and Row Versions.

Questa versione del Load metodo tenta di mantenere i valori correnti in ogni riga, lasciando inalterato il valore originale.This version of the Load method attempts to preserve the current values in each row, leaving the original value intact. (Se si desidera un controllo più preciso sul comportamento dei dati in ingresso, DataTable.Loadvedere.) Se la riga esistente e la riga in arrivo contengono valori di chiave primaria corrispondenti, la riga viene elaborata usando il valore dello stato della riga corrente, in caso contrario viene considerata come una nuova riga.(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.

In termini di operazioni di evento, RowChanging l'evento si verifica prima che ogni riga venga modificata RowChanged e l'evento si verifica dopo la modifica di ogni riga.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. In ogni caso, la Action proprietà DataRowChangeEventArgs dell'istanza passata al gestore eventi contiene informazioni sulla particolare azione associata all'evento.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. Questo valore di azione dipende dallo stato della riga prima dell'operazione di caricamento.This action value depends on the state of the row before the load operation. In ogni caso, si verificano entrambi gli eventi e l'azione è la stessa per ogni evento.In each case, both events occur, and the action is the same for each. L'azione può essere applicata alla versione corrente o originale di ogni riga, o a seconda dello stato corrente della riga.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

Nella tabella seguente viene visualizzato il comportamento Load per il metodo.The following table displays behavior for the Load method. La riga finale (con etichetta "(non presente)") descrive il comportamento per le righe in entrata che non corrispondono ad alcuna riga esistente.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Ogni cella di questa tabella descrive il valore corrente e quello originale per un campo all'interno di una riga, DataRowState insieme a per il valore Load dopo il completamento del metodo.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. In questo caso, il metodo non consente di indicare l'opzione Load e usa il valore predefinito PreserveChanges.In this case, the method doesn't allow you to indicate the load option, and uses the default, PreserveChanges.

DataRowState esistenteExisting DataRowState Valori dopo Load il metodo e l'azione eventoValues after Load method, and event action
AggiuntoAdded Current = <> esistenteCurrent = <Existing>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <modificato >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
ModificatoModified Current = <> esistenteCurrent = <Existing>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <modificato >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
EliminatoDeleted Current = <non disponibile >Current = <Not available>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <eliminato >State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
UnchangedUnchanged Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
(Non presente)(Not present) Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

I valori in DataColumn un oggetto possono essere limitati tramite l'utilizzo di proprietà ReadOnly quali e AutoIncrement.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. Il Load metodo gestisce tali colonne in modo coerente con il comportamento definito dalle proprietà della colonna.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Il vincolo di sola lettura in DataColumn un è applicabile solo alle modifiche che si verificano in memoria.The read only constraint on a DataColumn is applicable only for changes that occur in memory. Se Load necessario, il metodo sovrascrive i valori della colonna di sola lettura.The Load method's overwrites the read-only column values, if needed.

Per determinare la versione del campo chiave primaria da usare per il confronto della riga corrente con una riga in arrivo, il Load metodo usa la versione originale del valore di chiave primaria all'interno di una riga, se esistente.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. In caso contrario Load , il metodo utilizza la versione corrente del campo chiave primaria.Otherwise, the Load method uses the current version of the primary key field.

Vedi anche

Load(IDataReader, LoadOption) Load(IDataReader, LoadOption) Load(IDataReader, LoadOption)

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.Fills a DataTable with values from a data source using the supplied IDataReader. Se DataTable contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti, in base al valore del parametro 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

Parametri

reader
IDataReader IDataReader IDataReader IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.An IDataReader that provides one or more result sets.

loadOption
LoadOption LoadOption LoadOption LoadOption

Valore dall'enumerazione della classe LoadOption, che indica come vengono combinate le righe già presenti nella classe DataTable con le righe in entrata che condividono la stessa chiave primaria.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.

Esempi

Nell'esempio seguente vengono illustrati alcuni dei problemi relativi alla chiamata Load al metodo.The following example demonstrates several of the issues involved with calling the Load method. In primo luogo, l'esempio è incentrato sui problemi dello schema, tra cui l'inferenza di uno schema dall'oggetto caricato IDataReadere la gestione degli schemi incompatibili e degli schemi con colonne mancanti o aggiuntive.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'esempio si concentra quindi sui problemi di dati, inclusa la gestione delle varie opzioni di caricamento.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

Commenti

Il Load metodo utilizza il primo set di risultati dall'oggetto caricato IDataReadere, al termine, imposta la posizione del Reader sul set di risultati successivo, se presente.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. Quando si convertono i Load dati, il metodo usa le stesse regole Fill di conversione del metodo.When converting data, the Load method uses the same conversion rules as the Fill method.

Il Load metodo deve tenere conto di tre problemi specifici quando si caricano i dati IDataReader da un'istanza di: schema, dati e operazioni di eventi.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Quando si utilizza lo schema, il Load metodo può rilevare condizioni come descritto nella tabella seguente.When working with the schema, the Load method may encounter conditions as described in the following table. Le operazioni dello schema avvengono per tutti i set di risultati importati, anche quelli che non contengono dati.The schema operations take place for all imported result sets, even those containing no data.

CondizioneCondition ComportamentoBehavior
Non DataTable dispone di alcuno schema.The DataTable has no schema. Il Load metodo deduce lo schema in base al set di risultati dall'oggetto importato IDataReader.The Load method infers the schema based on the result set from the imported IDataReader.
DataTable Dispone di uno schema, ma non è compatibile con lo schema caricato.The DataTable has a schema, but it is incompatible with the loaded schema. Il Load metodo genera un'eccezione corrispondente all'errore specifico che si verifica quando si tenta di caricare i dati nello schema incompatibile.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Gli schemi sono compatibili, ma lo schema del set di risultati caricato contiene le colonne che non esistono DataTablein.The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. Il Load metodo aggiunge le colonne aggiuntive allo DataTableschema di.The Load method adds the extra columns to DataTable's schema. Il metodo genera un'eccezione se le colonne corrispondenti in DataTable e il set di risultati caricati non sono compatibili con i valori.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Il metodo recupera inoltre le informazioni sui vincoli dal set di risultati per tutte le colonne aggiunte.The method also retrieves constraint information from the result set for all added columns. Ad eccezione del caso del vincolo PRIMARY KEY, queste informazioni sui vincoli vengono utilizzate solo se l' DataTable oggetto corrente non contiene colonne all'inizio dell'operazione di caricamento.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.
Gli schemi sono compatibili, ma lo schema del set di risultati caricato contiene un minor numero di DataTablecolonne rispetto a.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Se per una colonna mancante è stato definito un valore predefinito o il tipo di dati della colonna ammette Load valori null, il metodo consente di aggiungere le righe, sostituendo il valore predefinito o null per la colonna mancante.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. Se non è possibile usare alcun valore predefinito o null, il Load metodo genera un'eccezione.If no default value or null can be used, then the Load method throws an exception. Se non è stato fornito alcun valore predefinito specifico, Load il metodo usa il valore null come valore predefinito implicito.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Prima di considerare il comportamento del Load metodo in termini di operazioni sui dati, tenere presente che ogni riga DataTable all'interno di un oggetto mantiene sia il valore corrente che quello originale per ogni colonna.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. Questi valori possono essere equivalenti oppure possono essere diversi se i dati nella riga sono stati modificati dopo la compilazione di DataTable.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Per ulteriori informazioni, vedere Stati di riga e versioni di riga .See Row States and Row Versions for more information.

In questa chiamata al metodo, il LoadOption parametro specificato influisce sull'elaborazione dei dati in arrivo.In this method call, the specified LoadOption parameter influences the processing of the incoming data. In che modo il metodo Load gestisce il caricamento di righe con la stessa chiave primaria delle righe esistenti?How should the Load method handle loading rows that have the same primary key as existing rows? Modificare i valori correnti, i valori originali o entrambi?Should it modify current values, original values, or both? Questi problemi e molto altro sono controllati dal loadOption parametro.These issues, and more, are controlled by the loadOption parameter.

Se la riga esistente e la riga in arrivo contengono valori di chiave primaria corrispondenti, la riga viene elaborata usando il valore dello stato della riga corrente, in caso contrario viene considerata come una nuova riga.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.

In termini di operazioni di evento, RowChanging l'evento si verifica prima che ogni riga venga modificata RowChanged e l'evento si verifica dopo la modifica di ogni riga.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. In ogni caso, la Action proprietà DataRowChangeEventArgs dell'istanza passata al gestore eventi contiene informazioni sulla particolare azione associata all'evento.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. Il valore di questa azione varia a seconda dello stato della riga prima dell'operazione di caricamento.This action value varies, depending on the state of the row before the load operation. In ogni caso, si verificano entrambi gli eventi e l'azione è la stessa per ogni evento.In each case, both events occur, and the action is the same for each. L'azione può essere applicata alla versione corrente o originale di ogni riga, o a seconda dello stato corrente della riga.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

Nella tabella seguente viene visualizzato il comportamento per il metodo Load quando viene chiamato con LoadOption ognuno dei valori e viene inoltre illustrato il modo in cui i valori interagiscono con lo stato della riga per la riga da caricare.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 riga finale (con etichetta "(non presente)") descrive il comportamento per le righe in entrata che non corrispondono ad alcuna riga esistente.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Ogni cella di questa tabella descrive il valore corrente e quello originale per un campo all'interno di una riga, DataRowState insieme a per il valore Load dopo il completamento del metodo.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 esistenteExisting DataRowState UpsertUpsert OverwriteChangesOverwriteChanges PreserveChanges (comportamento predefinito)PreserveChanges (Default behavior)
AggiuntoAdded Current = <> in ingressoCurrent = <Incoming>

Originale =-<non disponibile >Original = -<Not available>

Stato = <aggiunto >State = <Added>

RowAction = modificaRowAction = Change
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> esistenteCurrent = <Existing>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <modificato >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
ModificatoModified Current = <> in ingressoCurrent = <Incoming>

Originale = <> esistenteOriginal = <Existing>

Stato = <modificato >State = <Modified>

RowAction = modificaRowAction = Change
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> esistenteCurrent = <Existing>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <modificato >State = <Modified>

RowAction =ChangeOriginalRowAction =ChangeOriginal
EliminatoDeleted (Il carico non influisce sulle righe eliminate)(Load does not affect deleted rows)

Current =---Current = ---

Originale = <> esistenteOriginal = <Existing>

Stato = <eliminato >State = <Deleted>

(Viene aggiunta una nuova riga con le caratteristiche seguenti)(New row is added with the following characteristics)

Current = <> in ingressoCurrent = <Incoming>

Originale = <non disponibile >Original = <Not available>

Stato = <aggiunto >State = <Added>

RowAction = AggiungiRowAction = Add
Annulla eliminazione eUndo delete and

Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <non disponibile >Current = <Not available>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <eliminato >State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
UnchangedUnchanged Current = <> in ingressoCurrent = <Incoming>

Originale = <> esistenteOriginal = <Existing>

Se il nuovo valore è uguale al valore esistente,If new value is the same as the existing value then

Stato = <invariato >State = <Unchanged>

RowAction = NothingRowAction = Nothing

ElseElse

Stato = <modificato >State = <Modified>

RowAction = modificaRowAction = Change
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Non presente)Not present) Current = <> in ingressoCurrent = <Incoming>

Originale = <non disponibile >Original = <Not available>

Stato = <aggiunto >State = <Added>

RowAction = AggiungiRowAction = Add
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

I valori in DataColumn un oggetto possono essere limitati tramite l'utilizzo di proprietà ReadOnly quali e AutoIncrement.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. Il Load metodo gestisce tali colonne in modo coerente con il comportamento definito dalle proprietà della colonna.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Il vincolo di sola lettura in DataColumn un è applicabile solo alle modifiche che si verificano in memoria.The read only constraint on a DataColumn is applicable only for changes that occur in memory. Se Load necessario, il metodo sovrascrive i valori della colonna di sola lettura.The Load method's overwrites the read-only column values, if needed.

Se si specificano le opzioni OverwriteChanges o PreserveChanges quando si Load chiama il metodo, si presuppone che i dati in arrivo provengano DataTabledall'origine dati primaria e che la DataTable rilevi le modifiche e possa propagarsi le modifiche vengono nuovamente apportate all'origine dati.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. Se si seleziona l'opzione Upsert, si presuppone che i dati provengano da una di un'origine dati secondaria, ad esempio i dati forniti da un componente di livello intermedio, probabilmente modificati da un utente.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. In questo caso, il presupposto è che lo scopo è quello di aggregare i dati da una o più DataTableorigini dati in e, successivamente, di propagare i dati all'origine dati primaria.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. Il LoadOption parametro viene utilizzato per determinare la versione specifica della riga da utilizzare per il confronto delle chiavi primarie.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. La tabella seguente fornisce i dettagli.The table below provides the details.

Opzione LoadLoad option Versione di DataRow utilizzata per il confronto delle chiavi primarieDataRow version used for primary key comparison
OverwriteChanges Versione originale, se esistente, in caso contrario versione correnteOriginal version, if it exists, otherwise Current version
PreserveChanges Versione originale, se esistente, in caso contrario versione correnteOriginal version, if it exists, otherwise Current version
Upsert Versione corrente, se esistente, in caso contrario versione originaleCurrent version, if it exists, otherwise Original version
Vedi anche

Load(IDataReader, LoadOption, FillErrorEventHandler) Load(IDataReader, LoadOption, FillErrorEventHandler) Load(IDataReader, LoadOption, FillErrorEventHandler)

Riempie una classe DataTable con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita, tramite un delegato di gestione degli errori.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

Parametri

reader
IDataReader IDataReader IDataReader IDataReader

Interfaccia IDataReader che fornisce un gruppo di risultati.A IDataReader that provides a result set.

loadOption
LoadOption LoadOption LoadOption LoadOption

Valore dall'enumerazione della classe LoadOption, che indica come vengono combinate le righe già presenti nella classe DataTable con le righe in entrata che condividono la stessa chiave primaria.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

Delegato FillErrorEventHandler da chiamare quando si verifica un errore durante il caricamento dei dati.A FillErrorEventHandler delegate to call when an error occurs while loading data.

Esempi

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

Commenti

Il Load metodo utilizza il primo set di risultati dall'oggetto caricato IDataReadere, al termine, imposta la posizione del Reader sul set di risultati successivo, se presente.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. Quando si convertono i Load dati, il metodo usa le stesse regole DbDataAdapter.Fill di conversione del metodo.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

Il Load metodo deve tenere conto di tre problemi specifici quando si caricano i dati IDataReader da un'istanza di: schema, dati e operazioni di eventi.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Quando si utilizza lo schema, il Load metodo può rilevare condizioni come descritto nella tabella seguente.When working with the schema, the Load method may encounter conditions as described in the following table. Le operazioni dello schema avvengono per tutti i set di risultati importati, anche quelli che non contengono dati.The schema operations take place for all imported result sets, even those containing no data.

CondizioneCondition ComportamentoBehavior
Non DataTable dispone di alcuno schema.The DataTable has no schema. Il Load metodo deduce lo schema in base al set di risultati dall'oggetto importato IDataReader.The Load method infers the schema based on the result set from the imported IDataReader.
DataTable Dispone di uno schema, ma non è compatibile con lo schema caricato.The DataTable has a schema, but it is incompatible with the loaded schema. Il Load metodo genera un'eccezione corrispondente all'errore specifico che si verifica quando si tenta di caricare i dati nello schema incompatibile.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Gli schemi sono compatibili, ma lo schema del set di risultati caricato contiene le colonne che non esistono DataTablein.The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. Il Load metodo aggiunge lo schema della colonna o DataTabledelle colonne aggiuntive.The Load method adds the extra column(s) to DataTable's schema. Il metodo genera un'eccezione se le colonne corrispondenti in DataTable e il set di risultati caricati non sono compatibili con i valori.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Il metodo recupera inoltre le informazioni sui vincoli dal set di risultati per tutte le colonne aggiunte.The method also retrieves constraint information from the result set for all added columns. Ad eccezione del caso del vincolo PRIMARY KEY, queste informazioni sui vincoli vengono utilizzate solo se l' DataTable oggetto corrente non contiene colonne all'inizio dell'operazione di caricamento.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.
Gli schemi sono compatibili, ma lo schema del set di risultati caricato contiene un minor numero di DataTablecolonne rispetto a.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Se per una colonna mancante è stato definito un valore predefinito o il tipo di dati della colonna ammette Load valori null, il metodo consente di aggiungere le righe, sostituendo il valore predefinito o null per la colonna mancante.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. Se non è possibile usare alcun valore predefinito o null, il Load metodo genera un'eccezione.If no default value or null can be used, then the Load method throws an exception. Se non è stato fornito alcun valore predefinito specifico, Load il metodo usa il valore null come valore predefinito implicito.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Prima di considerare il comportamento del Load metodo in termini di operazioni sui dati, tenere presente che ogni riga DataTable all'interno di un oggetto mantiene sia il valore corrente che quello originale per ogni colonna.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. Questi valori possono essere equivalenti oppure possono essere diversi se i dati nella riga sono stati modificati dopo la compilazione di DataTable.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Per ulteriori informazioni, vedere Stati di riga e versioni di riga .See Row States and Row Versions for more information.

In questa chiamata al metodo, il LoadOption parametro specificato influisce sull'elaborazione dei dati in arrivo.In this method call, the specified LoadOption parameter influences the processing of the incoming data. In che modo il metodo Load gestisce il caricamento di righe con la stessa chiave primaria delle righe esistenti?How should the Load method handle loading rows that have the same primary key as existing rows? Modificare i valori correnti, i valori originali o entrambi?Should it modify current values, original values, or both? Questi problemi e molto altro sono controllati dal loadOption parametro.These issues, and more, are controlled by the loadOption parameter.

Se la riga esistente e la riga in arrivo contengono valori di chiave primaria corrispondenti, la riga viene elaborata usando il valore dello stato della riga corrente, in caso contrario viene considerata come una nuova riga.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.

In termini di operazioni di evento, RowChanging l'evento si verifica prima che ogni riga venga modificata RowChanged e l'evento si verifica dopo la modifica di ogni riga.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. In ogni caso, la Action proprietà DataRowChangeEventArgs dell'istanza passata al gestore eventi contiene informazioni sulla particolare azione associata all'evento.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. Il valore di questa azione varia a seconda dello stato della riga prima dell'operazione di caricamento.This action value varies, depending on the state of the row before the load operation. In ogni caso, si verificano entrambi gli eventi e l'azione è la stessa per ogni evento.In each case, both events occur, and the action is the same for each. L'azione può essere applicata alla versione corrente o originale di ogni riga, o a seconda dello stato corrente della riga.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

Nella tabella seguente viene visualizzato il comportamento per il metodo Load quando viene chiamato con LoadOption ognuno dei valori e viene inoltre illustrato il modo in cui i valori interagiscono con lo stato della riga per la riga da caricare.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 riga finale (con etichetta "(non presente)") descrive il comportamento per le righe in entrata che non corrispondono ad alcuna riga esistente.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Ogni cella di questa tabella descrive il valore corrente e quello originale per un campo all'interno di una riga, DataRowState insieme a per il valore Load dopo il completamento del metodo.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 esistenteExisting DataRowState UpsertUpsert OverwriteChangesOverwriteChanges PreserveChanges (comportamento predefinito)PreserveChanges (Default behavior)
AggiuntoAdded Current = <> in ingressoCurrent = <Incoming>

Originale =-<non disponibile >Original = -<Not available>

Stato = <aggiunto >State = <Added>

RowAction = modificaRowAction = Change
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> esistenteCurrent = <Existing>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <modificato >State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
ModificatoModified Current = <> in ingressoCurrent = <Incoming>

Originale = <> esistenteOriginal = <Existing>

Stato = <modificato >State = <Modified>

RowAction = modificaRowAction = Change
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> esistenteCurrent = <Existing>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <modificato >State = <Modified>

RowAction =ChangeOriginalRowAction =ChangeOriginal
eliminataeleted (Il carico non influisce sulle righe eliminate)(Load does not affect deleted rows)

Current =---Current = ---

Originale = <> esistenteOriginal = <Existing>

Stato = <eliminato >State = <Deleted>

(Viene aggiunta una nuova riga con le caratteristiche seguenti)(New row is added with the following characteristics)

Current = <> in ingressoCurrent = <Incoming>

Originale = <non disponibile >Original = <Not available>

Stato = <aggiunto >State = <Added>

RowAction = AggiungiRowAction = Add
Annulla eliminazione eUndo delete and

Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <non disponibile >Current = <Not available>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <eliminato >State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
UnchangedUnchanged Current = <> in ingressoCurrent = <Incoming>

Originale = <> esistenteOriginal = <Existing>

Se il nuovo valore è uguale al valore esistente,If new value is the same as the existing value then

Stato = <invariato >State = <Unchanged>

RowAction = NothingRowAction = Nothing

ElseElse

Stato = <modificato >State = <Modified>

RowAction = modificaRowAction = Change
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Non presente)Not present) Current = <> in ingressoCurrent = <Incoming>

Originale = <non disponibile >Original = <Not available>

Stato = <aggiunto >State = <Added>

RowAction = AggiungiRowAction = Add
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Current = <> in ingressoCurrent = <Incoming>

Originale = <> in ingressoOriginal = <Incoming>

Stato = <invariato >State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

I valori in DataColumn un oggetto possono essere limitati tramite l'utilizzo di proprietà ReadOnly quali e AutoIncrement.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. Il Load metodo gestisce tali colonne in modo coerente con il comportamento definito dalle proprietà della colonna.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Il vincolo di sola lettura in DataColumn un è applicabile solo alle modifiche che si verificano in memoria.The read only constraint on a DataColumn is applicable only for changes that occur in memory. Se Load necessario, il metodo sovrascrive i valori della colonna di sola lettura.The Load method's overwrites the read-only column values, if needed.

Se si specificano le opzioni OverwriteChanges o PreserveChanges quando si Load chiama il metodo, si presuppone che i dati in arrivo provengano DataTabledall'origine dati primaria e che la DataTable rilevi le modifiche e possa propagarsi le modifiche vengono nuovamente apportate all'origine dati.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. Se si seleziona l'opzione Upsert, si presuppone che i dati provengano da una di un'origine dati secondaria, ad esempio i dati forniti da un componente di livello intermedio, probabilmente modificati da un utente.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. In questo caso, il presupposto è che lo scopo è quello di aggregare i dati da una o più DataTableorigini dati in e, successivamente, di propagare i dati all'origine dati primaria.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. Il LoadOption parametro viene utilizzato per determinare la versione specifica della riga da utilizzare per il confronto delle chiavi primarie.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. La tabella seguente fornisce i dettagli.The table below provides the details.

Opzione LoadLoad option Versione di DataRow utilizzata per il confronto delle chiavi primarieDataRow version used for primary key comparison
OverwriteChanges Versione originale, se esistente, in caso contrario versione correnteOriginal version, if it exists, otherwise Current version
PreserveChanges Versione originale, se esistente, in caso contrario versione correnteOriginal version, if it exists, otherwise Current version
Upsert Versione corrente, se esistente, in caso contrario versione originaleCurrent version, if it exists, otherwise Original version

Il errorHandler parametro è un FillErrorEventHandler delegato che fa riferimento a una routine chiamata quando si verifica un errore durante il caricamento dei dati.The errorHandler parameter is a FillErrorEventHandler delegate that refers to a procedure that is called when an error occurs while loading data. Il FillErrorEventArgs parametro passato alla stored procedure fornisce proprietà che consentono di recuperare informazioni sull'errore che si è verificato, sulla riga di dati corrente e sull' DataTable oggetto da riempire.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. Utilizzando questo meccanismo di delega, anziché un blocco try/catch più semplice, è possibile determinare l'errore, gestire la situazione e continuare l'elaborazione, se lo si desidera.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. Il FillErrorEventArgs parametro fornisce una Continue proprietà: impostare questa proprietà su true per indicare che l'errore è stato gestito e si desidera continuare l'elaborazione.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. Impostare la proprietà su false per indicare che si desidera interrompere l'elaborazione.Set the property to false to indicate that you wish to halt processing. Tenere presente che l'impostazione della proprietà false su determina la generazione di un'eccezione da parte del codice che ha generato il problema.Be aware that setting the property to false causes the code that triggered the problem to throw an exception.

Vedi anche

Si applica a