DataTable.Load Método

Referência

Definição

Namespace:: System.Data

Assembly:: System.Data.Common.dll

Assembly:: System.Data.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Preenche um DataTable com valores de uma fonte de dados usando o IDataReaderfornecido. Se o DataTable já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes.

Sobrecargas

Load(IDataReader)	Preenche um DataTable com valores de uma fonte de dados usando o IDataReaderfornecido. Se o DataTable já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes.
Load(IDataReader, LoadOption)	Preenche um DataTable com valores de uma fonte de dados usando o IDataReaderfornecido. Se o `DataTable` já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes de acordo com o valor do parâmetro `loadOption`.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Preenche um DataTable com valores de uma fonte de dados usando o IDataReader fornecido comum delegado de tratamento de erro.

Exemplos

O exemplo a seguir demonstra vários dos problemas envolvidos ao chamar o Load método . Primeiro, o exemplo se concentra em problemas de esquema, inclusive inferindo um esquema a partir do IDataReadercarregado e, em seguida, tratando esquemas incompatíveis e esquemas com colunas ausentes ou adicionais. Em seguida, o exemplo se concentra em problemas de dados, incluindo o tratamento das várias opções de carregamento.

Observação

Este exemplo mostra como usar uma das versões sobrecarregadas do Load. Para obter outros exemplos que possam estar disponíveis, consulte os tópicos de sobrecarga individuais.

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

Comentários

O Load método pode ser usado em vários cenários comuns, todos centrados em obter dados de uma fonte de dados especificada e adicioná-los ao contêiner de dados atual (nesse caso, um DataTable). Esses cenários descrevem o uso padrão de um DataTable, descrevendo seu comportamento de atualização e mesclagem.

Um DataTable sincroniza ou atualiza com uma única fonte de dados primária. O DataTable acompanha as alterações, permitindo a sincronização com a fonte de dados primária. Além disso, um DataTable pode aceitar dados incrementais de uma ou mais fontes de dados secundárias. O DataTable não é responsável por acompanhar as alterações para permitir a sincronização com a fonte de dados secundária.

Dadas essas duas fontes de dados hipotéticas, um usuário deve exigir um dos seguintes comportamentos:

Inicializar DataTable de uma fonte de dados primária. Nesse cenário, o usuário deseja inicializar um vazio DataTable com valores da fonte de dados primária. Posteriormente, o usuário deseja propagar alterações de volta para a fonte de dados primária.
Preservar alterações e ressincronizar a partir da fonte de dados primária. Nesse cenário, o usuário deseja usar o DataTable preenchido no cenário anterior e executar uma sincronização incremental com a fonte de dados primária, preservando as modificações feitas no DataTable.
Feed de dados incremental das fontes de dados secundárias. Nesse cenário, o usuário deseja mesclar alterações de uma ou mais fontes de dados secundárias e propaga essas alterações de volta para a fonte de dados primária.

O Load método possibilita todos esses cenários. Todas, exceto uma das sobrecargas desse método, permitem que você especifique um parâmetro de opção de carga, indicando como as linhas já estão em uma DataTable combinação com linhas sendo carregadas. (A sobrecarga que não permite que você especifique o comportamento usa a opção de carga padrão.) A tabela a seguir descreve as três opções de carga fornecidas pela LoadOption enumeração . Em cada caso, a descrição indica o comportamento quando a chave primária de uma linha nos dados de entrada corresponde à chave primária de uma linha existente.

Carregar Opção	Descrição
`PreserveChanges` (padrão)	Atualiza a versão original da linha com o valor da linha de entrada.
`OverwriteChanges`	Atualiza as versões atual e original da linha com o valor da linha de entrada.
`Upsert`	Atualiza a versão atual da linha com o valor da linha de entrada.

Em geral, as opções PreserveChanges e OverwriteChanges se destinam a cenários nos quais o usuário precisa sincronizar o DataSet e suas alterações com a fonte de dados primária. A opção Upsert facilita a agregação de alterações de uma ou mais fontes de dados secundárias.

Load(IDataReader)

Origem:: DataTable.cs

Origem:: DataTable.cs

Origem:: DataTable.cs

Preenche um DataTable com valores de uma fonte de dados usando o IDataReaderfornecido. Se o DataTable já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes.

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)

Parâmetros

reader: IDataReader

Um IDataReader que fornece um conjunto de resultados.

Exemplos

O exemplo a seguir demonstra vários dos problemas envolvidos ao chamar o Load método . Primeiro, o exemplo se concentra em problemas de esquema, inclusive inferindo um esquema a partir do IDataReadercarregado e, em seguida, tratando esquemas incompatíveis e esquemas com colunas ausentes ou adicionais. Em seguida, o exemplo chama o Load método , exibindo os dados antes e depois da operação de carga.

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

Comentários

O Load método consome o primeiro conjunto de resultados do carregado IDataReadere, após a conclusão bem-sucedida, define a posição do leitor para o próximo conjunto de resultados, se houver. Ao converter dados, o Load método usa as mesmas regras de conversão que o DbDataAdapter.Fill método .

O Load método deve levar em conta três problemas específicos ao carregar os dados de uma IDataReader instância: esquema, dados e operações de evento. Ao trabalhar com o esquema, o Load método pode encontrar condições conforme descrito na tabela a seguir. As operações de esquema ocorrem para todos os conjuntos de resultados importados, mesmo aqueles que não contêm dados.

Condição	Comportamento
O DataTable não tem esquema.	O Load método infere o esquema com base no conjunto de resultados do importado IDataReader.
O DataTable tem um esquema, mas é incompatível com o esquema carregado.	O Load método gera uma exceção correspondente ao erro específico que ocorre ao tentar carregar dados no esquema incompatível.
Os esquemas são compatíveis, mas o esquema de conjunto de resultados carregado contém colunas que não existem no DataTable.	O Load método adiciona as colunas extras ao `DataTable`esquema de . O método gerará uma exceção se as DataTable colunas correspondentes no e o conjunto de resultados carregado não forem compatíveis com valor. O método também recupera informações de restrição do conjunto de resultados para todas as colunas adicionadas. Exceto para o caso da restrição de Chave Primária, essas informações de restrição serão usadas somente se a atual DataTable não contiver colunas no início da operação de carga.
Os esquemas são compatíveis, mas o esquema de conjunto de resultados carregado contém menos colunas do que o `DataTable`.	Se uma coluna ausente tiver um valor padrão definido ou o tipo de dados da coluna for anulável, o Load método permitirá que as linhas sejam adicionadas, substituindo o padrão ou `null` o valor da coluna ausente. Se nenhum valor padrão ou `null` puder ser usado, o `Load` método gerará uma exceção. Se nenhum valor padrão específico tiver sido fornecido, o `Load` método usará o `null` valor como o valor padrão implícito.

Antes de considerar o comportamento do Load método em termos de operações de dados, considere que cada linha dentro de um DataTable mantém o valor atual e o valor original para cada coluna. Esses valores podem ser equivalentes ou podem ser diferentes se os dados na linha tiverem sido alterados desde o preenchimento do DataTable. Para obter mais informações, consulte Estados de linha e versões de linha.

Esta versão do Load método tenta preservar os valores atuais em cada linha, deixando o valor original intacto. (Se você quiser ter um controle mais fino sobre o comportamento dos dados de entrada, consulte DataTable.Load.) Se a linha existente e a linha de entrada contiverem valores de chave primária correspondentes, a linha será processada usando seu valor de estado de linha atual, caso contrário, ela será tratada como uma nova linha.

Em termos de operações de evento, o RowChanging evento ocorre antes de cada linha ser alterada e o RowChanged evento ocorre depois que cada linha é alterada. Em cada caso, a Action propriedade da DataRowChangeEventArgs instância passada para o manipulador de eventos contém informações sobre a ação específica associada ao evento. Esse valor de ação depende do estado da linha antes da operação de carga. Em cada caso, ambos os eventos ocorrem e a ação é a mesma para cada um. A ação pode ser aplicada à versão atual ou original de cada linha ou ambas, dependendo do estado da linha atual.

A tabela a seguir exibe o comportamento do Load método . A linha final (rotulada como "(Não presente)") descreve o comportamento de linhas de entrada que não correspondem a nenhuma linha existente. Cada célula nesta tabela descreve o valor atual e original de um campo dentro de uma linha, juntamente com o DataRowState para o valor após a conclusão do Load método. Nesse caso, o método não permite que você indique a opção de carregamento e usa o padrão, PreserveChanges.

DataRowState existente	Valores após `Load` o método e a ação de evento
Adicionado	Atual = <Existente> Original = <Entrada> Estado = <Modificado> RowAction = ChangeOriginal
Modificado	Atual = <Existente> Original = <Entrada> Estado = <Modificado> RowAction = ChangeOriginal
Excluído	Atual = <Não disponível> Original = <Entrada> Estado = <Excluído> RowAction = ChangeOriginal
Inalterado	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal
(Não presente)	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal

Os valores em um DataColumn podem ser restritos por meio do uso de propriedades como ReadOnly e AutoIncrement. O Load método manipula essas colunas de uma maneira consistente com o comportamento definido pelas propriedades da coluna. A restrição somente leitura em um DataColumn é aplicável apenas a alterações que ocorrem na memória. O Load método substitui os valores de coluna somente leitura, se necessário.

Para determinar qual versão do campo de chave primária usar para comparar a linha atual com uma linha de entrada, o Load método usará a versão original do valor da chave primária dentro de uma linha, se ela existir. Caso contrário, o Load método usará a versão atual do campo de chave primária.

Confira também

Aplica-se a

Load(IDataReader, LoadOption)

Origem:: DataTable.cs

Origem:: DataTable.cs

Origem:: DataTable.cs

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

Public Sub Load (reader As IDataReader, loadOption As LoadOption)

Parâmetros

reader: IDataReader

Um IDataReader que fornece um ou vários conjuntos de resultados.

loadOption: LoadOption

Um valor da enumeração LoadOption que indica como as linhas que já estão no DataTable são combinadas com linhas de entrada que compartilham a mesma chave primária.

Exemplos

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

Comentários

O Load método consome o primeiro conjunto de resultados do carregado IDataReadere, após a conclusão bem-sucedida, define a posição do leitor para o próximo conjunto de resultados, se houver. Ao converter dados, o Load método usa as mesmas regras de conversão que o Fill método .

O Load método deve levar em conta três problemas específicos ao carregar os dados de uma IDataReader instância: esquema, dados e operações de evento. Ao trabalhar com o esquema, o Load método pode encontrar condições conforme descrito na tabela a seguir. As operações de esquema ocorrem para todos os conjuntos de resultados importados, mesmo aqueles que não contêm dados.

Condição	Comportamento
O DataTable não tem esquema.	O `Load` método infere o esquema com base no conjunto de resultados do importado IDataReader.
O DataTable tem um esquema, mas é incompatível com o esquema carregado.	O `Load` método gera uma exceção correspondente ao erro específico que ocorre ao tentar carregar dados no esquema incompatível.
Os esquemas são compatíveis, mas o esquema de conjunto de resultados carregado contém colunas que não existem no `DataTable`.	O `Load` método adiciona as colunas extras ao `DataTable`esquema de . O método gerará uma exceção se as DataTable colunas correspondentes no e o conjunto de resultados carregado não forem compatíveis com valor. O método também recupera informações de restrição do conjunto de resultados para todas as colunas adicionadas. Exceto para o caso da restrição de Chave Primária, essas informações de restrição serão usadas somente se a atual DataTable não contiver colunas no início da operação de carga.
Os esquemas são compatíveis, mas o esquema de conjunto de resultados carregado contém menos colunas do que o `DataTable`.	Se uma coluna ausente tiver um valor padrão definido ou o tipo de dados da coluna for anulável, o `Load` método permitirá que as linhas sejam adicionadas, substituindo o valor padrão ou nulo para a coluna ausente. Se nenhum valor padrão ou nulo puder ser usado, o `Load` método gerará uma exceção. Se nenhum valor padrão específico tiver sido fornecido, o `Load` método usará o valor nulo como o valor padrão implícito.

Antes de considerar o comportamento do Load método em termos de operações de dados, considere que cada linha dentro de um DataTable mantém o valor atual e o valor original para cada coluna. Esses valores podem ser equivalentes ou podem ser diferentes se os dados na linha tiverem sido alterados desde o preenchimento do DataTable. Consulte Estados de Linha e Versões de Linha para obter mais informações.

Nessa chamada de método, o parâmetro especificado LoadOption influencia o processamento dos dados de entrada. Como o método Load deve lidar com o carregamento de linhas que têm a mesma chave primária que as linhas existentes? Ele deve modificar valores atuais, valores originais ou ambos? Esses problemas e muito mais são controlados pelo loadOption parâmetro .

Se a linha existente e a linha de entrada contiverem valores de chave primária correspondentes, a linha será processada usando seu valor de estado de linha atual, caso contrário, ela será tratada como uma nova linha.

Em termos de operações de evento, o RowChanging evento ocorre antes de cada linha ser alterada e o RowChanged evento ocorre depois que cada linha é alterada. Em cada caso, a Action propriedade da DataRowChangeEventArgs instância passada para o manipulador de eventos contém informações sobre a ação específica associada ao evento. Esse valor de ação varia, dependendo do estado da linha antes da operação de carga. Em cada caso, ambos os eventos ocorrem e a ação é a mesma para cada um. A ação pode ser aplicada à versão atual ou original de cada linha ou ambas, dependendo do estado da linha atual.

A tabela a seguir exibe o comportamento do método Load quando chamado com cada um dos LoadOption valores e também mostra como os valores interagem com o estado da linha para a linha que está sendo carregada. A linha final (rotulada como "(Não presente)") descreve o comportamento de linhas de entrada que não correspondem a nenhuma linha existente. Cada célula nesta tabela descreve o valor atual e original de um campo dentro de uma linha, juntamente com o DataRowState para o valor após a conclusão do Load método.

DataRowState existente	Upsert	Overwritechanges	PreserveChanges (comportamento padrão)
Adicionado	Current = <Entrada> Original = -<Não disponível> Estado = <Adicionado> RowAction = Change	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Existente> Original = <Entrada> Estado = <Modificado> RowAction = ChangeOriginal
Modificado	Current = <Entrada> Original = <Existente> Estado = <Modificado> RowAction = Change	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Existente> Original = <Entrada> Estado = <Modificado> RowAction =ChangeOriginal
Excluído	(A carga não afeta linhas excluídas) Current = --- Original = <Existente> Estado = <Excluído> (Nova linha é adicionada com as seguintes características) Current = <Entrada> Original = <Não disponível> Estado = <Adicionado> RowAction = Add	Desfazer exclusão e Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Não disponível> Original = <Entrada> Estado = <Excluído> RowAction = ChangeOriginal
Inalterado	Current = <Entrada> Original = <Existente> Se novo valor for o mesmo que o valor existente, então Estado = <Inalterado> RowAction = Nothing Else Estado = <Modificado> RowAction = Change	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal
Não está presente)	Atual = <Entrada> Original = <Não disponível> State = <Added> RowAction = Add	Atual = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal

Os valores em um DataColumn podem ser restritos por meio do uso de propriedades como ReadOnly e AutoIncrement. O Load método manipula essas colunas de uma maneira consistente com o comportamento definido pelas propriedades da coluna. A restrição somente leitura em um DataColumn é aplicável somente para alterações que ocorrem na memória. O Load método substitui os valores de coluna somente leitura, se necessário.

Se você especificar as opções OverwriteChanges ou PreserveChanges ao chamar o Load método , será feita a suposição de que os dados de entrada são provenientes da fonte de DataTabledados primária e a DataTable controla as alterações e pode propagar as alterações de volta para a fonte de dados. Se você selecionar a opção Upsert, supõe-se que os dados sejam provenientes de uma fonte de dados secundária, como dados fornecidos por um componente de camada intermediária, talvez alterados por um usuário. Nesse caso, a suposição é que a intenção é agregar dados de uma ou mais fontes de dados no DataTablee, em seguida, talvez propagar os dados de volta para a fonte de dados primária. O LoadOption parâmetro é usado para determinar a versão específica da linha que deve ser usada para comparação de chave primária. A tabela a seguir fornece os detalhes.

Opção Carregar	Versão do DataRow usada para comparação de chave primária
`OverwriteChanges`	Versão Original, caso exista, ou a versão Atual
`PreserveChanges`	Versão Original, caso exista, ou a versão Atual
`Upsert`	Versão atual, se existir, caso contrário, Versão original

Confira também

Aplica-se a

Load(IDataReader, LoadOption, FillErrorEventHandler)

Origem:: DataTable.cs

Origem:: DataTable.cs

Origem:: DataTable.cs

Preenche um DataTable com valores de uma fonte de dados usando o IDataReader fornecido comum delegado de tratamento de erro.

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);

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

Public Overridable Sub Load (reader As IDataReader, loadOption As LoadOption, errorHandler As FillErrorEventHandler)

Parâmetros

reader: IDataReader

Um IDataReader que fornece um conjunto de resultados.

loadOption: LoadOption

Um valor da enumeração LoadOption que indica como as linhas que já estão no DataTable são combinadas com linhas de entrada que compartilham a mesma chave primária.

errorHandler: FillErrorEventHandler

Um delegado FillErrorEventHandler a ser chamado quando ocorrer um erro ao carregar os dados.

Exemplos

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

Comentários

O Load método consome o primeiro conjunto de resultados do carregado IDataReadere, após a conclusão bem-sucedida, define a posição do leitor como o próximo conjunto de resultados, se houver. Ao converter dados, o Load método usa as mesmas regras de conversão que o DbDataAdapter.Fill método .

O Load método deve levar em conta três problemas específicos ao carregar os dados de uma IDataReader instância: esquema, dados e operações de evento. Ao trabalhar com o esquema, o Load método pode encontrar condições, conforme descrito na tabela a seguir. As operações de esquema ocorrem para todos os conjuntos de resultados importados, mesmo aqueles que não contêm dados.

Condição	Comportamento
O DataTable não tem esquema.	O `Load` método infere o esquema com base no conjunto de resultados do importado IDataReader.
O DataTable tem um esquema, mas é incompatível com o esquema carregado.	O `Load` método gera uma exceção correspondente ao erro específico que ocorre ao tentar carregar dados no esquema incompatível.
Os esquemas são compatíveis, mas o esquema do conjunto de resultados carregado contém colunas que não existem no `DataTable`.	O `Load` método adiciona as colunas extras ao `DataTable`esquema de . O método gerará uma exceção se as DataTable colunas correspondentes no e o conjunto de resultados carregados não forem compatíveis com valor. O método também recupera informações de restrição do conjunto de resultados para todas as colunas adicionadas. Exceto para o caso da restrição de Chave Primária, essas informações de restrição serão usadas somente se o atual DataTable não contiver colunas no início da operação de carregamento.
Os esquemas são compatíveis, mas o esquema do conjunto de resultados carregado contém menos colunas do que o `DataTable`.	Se uma coluna ausente tiver um valor padrão definido ou o tipo de dados da coluna for anulável, o `Load` método permitirá que as linhas sejam adicionadas, substituindo o valor padrão ou nulo pela coluna ausente. Se nenhum valor padrão ou nulo puder ser usado, o `Load` método gerará uma exceção. Se nenhum valor padrão específico tiver sido fornecido, o `Load` método usará o valor nulo como o valor padrão implícito.

Antes de considerar o comportamento do Load método em termos de operações de dados, considere que cada linha dentro de um DataTable mantém o valor atual e o valor original para cada coluna. Esses valores podem ser equivalentes ou podem ser diferentes se os dados na linha tiverem sido alterados desde o preenchimento do DataTable. Consulte Estados de linha e versões de linha para obter mais informações.

Em termos de operações de evento, o RowChanging evento ocorre antes de cada linha ser alterada e o RowChanged evento ocorre após cada linha ter sido alterada. Em cada caso, a Action propriedade da DataRowChangeEventArgs instância passada para o manipulador de eventos contém informações sobre a ação específica associada ao evento. Esse valor de ação varia, dependendo do estado da linha antes da operação de carregamento. Em cada caso, ambos os eventos ocorrem e a ação é a mesma para cada um. A ação pode ser aplicada à versão atual ou original de cada linha ou a ambas, dependendo do estado da linha atual.

A tabela a seguir exibe o comportamento do método Load quando chamado com cada um LoadOption dos valores e também mostra como os valores interagem com o estado da linha para a linha que está sendo carregada. A linha final (rotulada como "(Não presente)") descreve o comportamento de linhas de entrada que não correspondem a nenhuma linha existente. Cada célula nesta tabela descreve o valor atual e original de um campo dentro de uma linha, juntamente com o DataRowState para o valor após a conclusão do Load método.

DataRowState existente	Upsert	Overwritechanges	PreserveChanges (comportamento padrão)
Adicionado	Atual = <Entrada> Original = -<Não disponível> State = <Added> RowAction = Change	Atual = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Existente> Original = <Entrada> Estado = <Modificado> RowAction = ChangeOriginal
Modificado	Atual = <Entrada> Original = <Existente> Estado = <Modificado> RowAction = Change	Atual = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Existente> Original = <Entrada> Estado = <Modificado> RowAction =ChangeOriginal
eleted	(A carga não afeta linhas excluídas) Current = --- Original = <Existente> Estado = <Excluído> (Nova linha é adicionada com as seguintes características) Current = <Entrada> Original = <Não disponível> Estado = <Adicionado> RowAction = Add	Desfazer exclusão e Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Atual = <Não disponível> Original = <Entrada> Estado = <Excluído> RowAction = ChangeOriginal
Inalterado	Current = <Entrada> Original = <Existente> Se novo valor for o mesmo que o valor existente, então Estado = <Inalterado> RowAction = Nothing Else Estado = <Modificado> RowAction = Change	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal
Não está presente)	Current = <Entrada> Original = <Não disponível> Estado = <Adicionado> RowAction = Add	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal	Current = <Entrada> Original = <Entrada> Estado = <Inalterado> RowAction = ChangeCurrentAndOriginal

Se você especificar as opções OverwriteChanges ou PreserveChanges ao chamar o Load método, será feita a suposição de que os dados de entrada são provenientes da fonte de DataTabledados primária e a DataTable controla as alterações e pode propagar as alterações de volta para a fonte de dados. Se você selecionar a opção Upsert, supõe-se que os dados sejam provenientes de uma fonte de dados secundária, como dados fornecidos por um componente de camada intermediária, talvez alterados por um usuário. Nesse caso, a suposição é que a intenção é agregar dados de uma ou mais fontes de dados no e, em DataTableseguida, talvez propagar os dados de volta para a fonte de dados primária. O LoadOption parâmetro é usado para determinar a versão específica da linha que deve ser usada para comparação de chave primária. A tabela abaixo fornece os detalhes.

Opção carregar	Versão do DataRow usada para comparação de chave primária
`OverwriteChanges`	Versão Original, caso exista, ou a versão Atual
`PreserveChanges`	Versão Original, caso exista, ou a versão Atual
`Upsert`	Versão atual, se existir, caso contrário, versão original

O errorHandler parâmetro é um FillErrorEventHandler delegado que se refere a um procedimento chamado quando ocorre um erro ao carregar dados. O FillErrorEventArgs parâmetro passado para o procedimento fornece propriedades que permitem que você recupere informações sobre o erro ocorrido, a linha de dados atual e o DataTable que está sendo preenchido. Usar esse mecanismo delegado, em vez de um bloco try/catch mais simples, permite determinar o erro, lidar com a situação e continuar o processamento, se desejar. O FillErrorEventArgs parâmetro fornece uma Continue propriedade: defina essa propriedade como true para indicar que você lidou com o erro e deseja continuar o processamento. Defina a propriedade como false para indicar que você deseja interromper o processamento. Lembre-se de que definir a propriedade como false faz com que o código que disparou o problema gere uma exceção.

Confira também

Aplica-se a

DataTable.Load Método

Definição

Sobrecargas

Exemplos

Comentários

Load(IDataReader)

Parâmetros

Exemplos

Comentários

Confira também

Aplica-se a

Load(IDataReader, LoadOption)

Parâmetros

Exemplos

Comentários

Confira também

Aplica-se a

Load(IDataReader, LoadOption, FillErrorEventHandler)

Parâmetros

Exemplos

Comentários

Confira também

Aplica-se a

Comentários

Recursos adicionais