DataSet.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 DataSet com valores de uma fonte de dados usando o IDataReaderfornecido.

Sobrecargas

Load(IDataReader, LoadOption, DataTable[])	Preenche um DataSet com valores de uma fonte de dados usando o IDataReader fornecido, usando uma matriz de instâncias DataTable para fornecer o esquema e as informações de namespace.
Load(IDataReader, LoadOption, String[])	Preenche um DataSet com valores de uma fonte de dados usando o IDataReader, usando uma matriz de cadeias de caracteres para fornecer os nomes das tabelas dentro de `DataSet`.
Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])	Preenche um DataSet com valores de uma fonte de dados usando o IDataReader fornecido, usando uma matriz de instâncias DataTable para fornecer o esquema e as informações de namespace.

Comentários

O método Load fornece uma técnica para preencher um único DataTable com dados, recuperado a partir de uma instância IDataReader. Esse método fornece a mesma funcionalidade, mas permite carregar vários conjuntos de resultados de uma IDataReader em várias tabelas dentro de um DataSet.

Se o DataSet já contiver linhas, os dados de entrada da fonte de dados serão mesclados com as linhas existentes.

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 DataSet). Esses cenários descrevem o uso padrão para um DataSet, descrevendo seu comportamento de atualização e mesclagem.

Uma DataSet sincronização ou atualizações com uma única fonte de dados primária. As DataSet faixas são alteradas, permitindo a sincronização com a fonte de dados primária. Além disso, um DataSet pode aceitar dados incrementais de uma ou mais fontes de dados secundárias. Não DataSet é responsável por controlar 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 DataSet de uma fonte de dados primária. Nesse cenário, o usuário deseja inicializar um vazio DataSet com valores da fonte de dados primária. Um ou mais conteúdos do DataTable são modificados. 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 DataSet cenário anterior preenchido e executar uma sincronização incremental com a fonte de dados primária, preservando as modificações feitas no DataSet.
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. Esse método permite 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 tabela a seguir descreve as três opções de carregamento fornecidas pela enumeração LoadOption. 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, LoadOption, DataTable[])

Preenche um DataSet com valores de uma fonte de dados usando o IDataReader fornecido, usando uma matriz de instâncias DataTable para fornecer o esquema e as informações de namespace.

public:
 void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, ... cli::array <System::Data::DataTable ^> ^ tables);

public void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption, params System.Data.DataTable[] tables);

member this.Load : System.Data.IDataReader * System.Data.LoadOption * System.Data.DataTable[] -> unit

Public Sub Load (reader As IDataReader, loadOption As LoadOption, ParamArray tables As DataTable())

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 nas instâncias DataTable em DataSet serão combinadas com linhas de entrada que compartilham a mesma chave primária.

tables: DataTable[]

Uma matriz de instâncias DataTable, da qual o método Load(IDataReader, LoadOption, DataTable[]) recupera informações de nome e namespace. Cada uma dessas tabelas deve ser um membro do DataTableCollection contido por este DataSet.

Exemplos

O exemplo a seguir cria um novo DataSet, adiciona duas DataTable instâncias ao DataSete preenche o DataSet método usando, Load recuperando dados de um DataTableReader que contém dois conjuntos de resultados. Por fim, o exemplo exibe o conteúdo das tabelas na janela do console.

static void Main()
{
    DataSet dataSet = new DataSet();

    DataTable customerTable = new DataTable();
    DataTable productTable = new DataTable();

    // This information is cosmetic, only.
    customerTable.TableName = "Customers";
    productTable.TableName = "Products";

    // Add the tables to the DataSet:
    dataSet.Tables.Add(customerTable);
    dataSet.Tables.Add(productTable);

    // Load the data into the existing DataSet.
    DataTableReader reader = GetReader();
    dataSet.Load(reader, LoadOption.OverwriteChanges,
        customerTable, productTable);

    // Print out the contents of each table:
    foreach (DataTable table in dataSet.Tables)
    {
        PrintColumns(table);
    }

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

private static DataTable GetCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();
    table.TableName = "Customers";

    // 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 GetProducts()
{
    // Create sample Products table.
    DataTable table = new DataTable();
    table.TableName = "Products";

    // 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, "Wireless Network Card" });
    table.Rows.Add(new object[] { 1, "Hard Drive" });
    table.Rows.Add(new object[] { 2, "Monitor" });
    table.Rows.Add(new object[] { 3, "CPU" });
    table.AcceptChanges();
    return table;
}

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

private static DataTableReader GetReader()
{
    // Return a DataTableReader containing multiple
    // result sets, just for the sake of this demo.
    DataSet dataSet = new DataSet();
    dataSet.Tables.Add(GetCustomers());
    dataSet.Tables.Add(GetProducts());
    return dataSet.CreateDataReader();
}

Sub Main()
    Dim dataSet As New DataSet

    Dim customerTable As New DataTable
    Dim productTable As New DataTable

    ' This information is cosmetic, only.
    customerTable.TableName = "Customers"
    productTable.TableName = "Products"

    ' Add the tables to the DataSet:
    dataSet.Tables.Add(customerTable)
    dataSet.Tables.Add(productTable)

    ' Load the data into the existing DataSet. 
    Dim reader As DataTableReader = GetReader()
    dataSet.Load(reader, LoadOption.OverwriteChanges, _
        customerTable, productTable)

    ' Print out the contents of each table:
    For Each table As DataTable In dataSet.Tables
        PrintColumns(table)
    Next

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

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

    ' 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 GetProducts() As DataTable
    ' Create sample Products table, in order
    ' to demonstrate the behavior of the DataTableReader.
    Dim table As New DataTable
    table.TableName = "Products"

    ' 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, "Wireless Network Card"})
    table.Rows.Add(New Object() {1, "Hard Drive"})
    table.Rows.Add(New Object() {2, "Monitor"})
    table.Rows.Add(New Object() {3, "CPU"})
    Return table
End Function

Private Function GetReader() As DataTableReader
    ' Return a DataTableReader containing multiple
    ' result sets, just for the sake of this demo.
    Dim dataSet As New DataSet
    dataSet.Tables.Add(GetCustomers())
    dataSet.Tables.Add(GetProducts())
    Return dataSet.CreateDataReader()
End Function

Private Sub PrintColumns( _
   ByVal table As DataTable)

    Console.WriteLine()
    Console.WriteLine(table.TableName)
    Console.WriteLine("=========================")
    ' Loop through all the rows in the table.
    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 método Load fornece uma técnica para preencher um único DataTable com dados, recuperado a partir de uma instância IDataReader. Esse método fornece a mesma funcionalidade, mas permite que você carregue vários conjuntos de resultados de uma IDataReader em várias tabelas dentro de uma DataSet.

Observação

A operação de carga falhará com uma se qualquer uma InvalidOperationException das colunas de dados de origem na entrada reader for colunas computadas.

O loadOption parâmetro permite especificar como você deseja que os dados importados interajam com os dados existentes e pode ser qualquer um dos valores da LoadOption enumeração. Consulte a documentação do DataTable Load método para obter mais informações sobre como usar esse parâmetro.

O tables parâmetro permite que você especifique uma matriz de DataTable instâncias, indicando a ordem das tabelas correspondentes a cada conjunto de resultados carregado do leitor. O Load método preenche cada instância fornecida DataTable com dados de um único conjunto de resultados do leitor de dados de origem. Após cada conjunto de resultados, o Load método passa para o próximo conjunto de resultados dentro do leitor, até que não haja mais conjuntos de resultados.

O esquema de resolução de nomes para esse método é o mesmo que o seguido pelo Fill método da DbDataAdapter classe.

Confira também

Usando Conjuntos de Dados no ADO.NET

Aplica-se a

Load(IDataReader, LoadOption, String[])

Preenche um DataSet com valores de uma fonte de dados usando o IDataReader, usando uma matriz de cadeias de caracteres para fornecer os nomes das tabelas dentro de DataSet.

public:
 void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, ... cli::array <System::String ^> ^ tables);

public void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption, params string[] tables);

member this.Load : System.Data.IDataReader * System.Data.LoadOption * string[] -> unit

Public Sub Load (reader As IDataReader, loadOption As LoadOption, ParamArray tables As String())

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 nas instâncias DataTable em DataSet serão combinadas com linhas de entrada que compartilham a mesma chave primária.

tables: String[]

Uma matriz de cadeias de caracteres da qual o Load método recupera informações de nome de tabela.

Exemplos

O exemplo de aplicativo console a seguir primeiro cria tabelas e carrega dados de um leitor em um DataSet, usando o Load método. Em seguida, o exemplo adiciona tabelas a um DataSet e tenta preencher as tabelas com dados de um DataTableReader. Neste exemplo, como os parâmetros passados para o Load método indicam um nome de tabela que não existe, o Load método cria uma nova tabela para corresponder ao nome passado como um parâmetro. Depois que os dados forem carregados, o exemplo exibirá o conteúdo de todas as suas tabelas na janela Console.

static void Main()
{
    DataSet dataSet = new DataSet();

    DataTableReader reader = GetReader();

    // The tables listed as parameters for the Load method
    // should be in the same order as the tables within the IDataReader.
    dataSet.Load(reader, LoadOption.Upsert, "Customers", "Products");
    foreach (DataTable table in dataSet.Tables)
    {
        PrintColumns(table);
    }

    // Now try the example with the DataSet
    // already filled with data:
    dataSet = new DataSet();
    dataSet.Tables.Add(GetCustomers());
    dataSet.Tables.Add(GetProducts());

    // Retrieve a data reader containing changed data:
    reader = GetReader();

    // Load the data into the existing DataSet. Retrieve the order of the
    // the data in the reader from the
    // list of table names in the parameters. If you specify
    // a new table name here, the Load method will create
    // a corresponding new table.
    dataSet.Load(reader, LoadOption.Upsert,
        "NewCustomers", "Products");
    foreach (DataTable table in dataSet.Tables)
    {
        PrintColumns(table);
    }

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

private static DataTable GetCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();
    table.TableName = "Customers";

    // 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 GetProducts()
{
    // Create sample Products table.
    DataTable table = new DataTable();
    table.TableName = "Products";

    // 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, "Wireless Network Card" });
    table.Rows.Add(new object[] { 1, "Hard Drive" });
    table.Rows.Add(new object[] { 2, "Monitor" });
    table.Rows.Add(new object[] { 3, "CPU" });
    table.AcceptChanges();
    return table;
}

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

private static DataTableReader GetReader()
{
    // Return a DataTableReader containing multiple
    // result sets, just for the sake of this demo.
    DataSet dataSet = new DataSet();
    dataSet.Tables.Add(GetCustomers());
    dataSet.Tables.Add(GetProducts());
    return dataSet.CreateDataReader();
}

Sub Main()
  Dim dataSet As New DataSet
  Dim table As DataTable

  Dim reader As DataTableReader = GetReader()

  ' The tables listed as parameters for the Load method 
  ' should be in the same order as the tables within the IDataReader.
  dataSet.Load(reader, LoadOption.Upsert, "Customers", "Products")
  For Each table In dataSet.Tables
    PrintColumns(table)
  Next

  ' Now try the example with the DataSet
  ' already filled with data:
  dataSet = New DataSet
  dataSet.Tables.Add(GetCustomers())
  dataSet.Tables.Add(GetProducts())

  ' Retrieve a data reader containing changed data:
  reader = GetReader()

  ' Load the data into the existing DataSet. Retrieve the order of the
  ' the data in the reader from the
  ' list of table names in the parameters. If you specify
  ' a new table name here, the Load method will create
  ' a corresponding new table.
  dataSet.Load(reader, LoadOption.Upsert, "NewCustomers", "Products")
  For Each table In dataSet.Tables
    PrintColumns(table)
  Next

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

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

  ' 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 GetProducts() As DataTable
  ' Create sample Products table, in order
  ' to demonstrate the behavior of the DataTableReader.
  Dim table As New DataTable
  table.TableName = "Products"

  ' 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, "Wireless Network Card"})
  table.Rows.Add(New Object() {1, "Hard Drive"})
  table.Rows.Add(New Object() {2, "Monitor"})
  table.Rows.Add(New Object() {3, "CPU"})
  Return table
End Function

Private Function GetReader() As DataTableReader
  ' Return a DataTableReader containing multiple
  ' result sets, just for the sake of this demo.
  Dim dataSet As New DataSet
  dataSet.Tables.Add(GetCustomers())
  dataSet.Tables.Add(GetProducts())
  Return dataSet.CreateDataReader()
End Function

Private Sub PrintColumns( _
   ByVal table As DataTable)

  Console.WriteLine()
  Console.WriteLine(table.TableName)
  Console.WriteLine("=========================")
  ' Loop through all the rows in the table.
  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 método Load fornece uma técnica para preencher um único DataTable com dados, recuperado a partir de uma instância IDataReader. Esse método fornece a mesma funcionalidade, mas permite que você carregue vários conjuntos de resultados de uma IDataReader em várias tabelas dentro de uma DataSet.

Observação

A operação de carga falhará com uma se qualquer uma InvalidOperationException das colunas de dados de origem na entrada reader for colunas computadas.

O loadOption parâmetro permite especificar como você deseja que os dados importados interajam com os dados existentes e pode ser qualquer um dos valores da LoadOption enumeração. Consulte a documentação do Load método para obter mais informações sobre como usar esse parâmetro.

O tables parâmetro permite especificar uma matriz de nomes de tabela, indicando a ordem das tabelas correspondentes a cada conjunto de resultados carregado do leitor. O Load método tenta localizar uma tabela dentro do DataSet nome correspondente encontrado na matriz de nomes de tabela, em ordem. Se uma tabela correspondente for encontrada, essa tabela será carregada com o conteúdo do conjunto de resultados atual. Se nenhuma tabela correspondente for encontrada, uma tabela será criada usando o nome fornecido na matriz de nomes de tabela e o esquema da nova tabela será inferido do conjunto de resultados. Após cada conjunto de resultados, o Load método passa para o próximo conjunto de resultados dentro do leitor, até que não haja mais conjuntos de resultados.

O namespace padrão associado DataSeta, se houver, está associado a cada recém-criado DataTable. O esquema de resolução de nomes para esse método é o mesmo que o seguido pelo Fill método da DbDataAdapter classe.

Confira também

Usando Conjuntos de Dados no ADO.NET

Aplica-se a

Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])

Preenche um DataSet com valores de uma fonte de dados usando o IDataReader fornecido, usando uma matriz de instâncias DataTable para fornecer o esquema e as informações de namespace.

public:
 virtual void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, System::Data::FillErrorEventHandler ^ errorHandler, ... cli::array <System::Data::DataTable ^> ^ tables);

public virtual void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption, System.Data.FillErrorEventHandler? errorHandler, params System.Data.DataTable[] tables);

public virtual void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption, System.Data.FillErrorEventHandler errorHandler, params System.Data.DataTable[] tables);

abstract member Load : System.Data.IDataReader * System.Data.LoadOption * System.Data.FillErrorEventHandler * System.Data.DataTable[] -> unit
override this.Load : System.Data.IDataReader * System.Data.LoadOption * System.Data.FillErrorEventHandler * System.Data.DataTable[] -> unit

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

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 nas instâncias DataTable em DataSet serã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.

tables: DataTable[]

Uma matriz de instâncias DataTable, da qual o método Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) recupera informações de nome e namespace.

Exemplos

O exemplo a seguir adiciona uma tabela a uma DataSete, em seguida, tenta usar o Load método para carregar dados de um DataTableReader que contém um esquema incompatível. Em vez de prender o erro, este exemplo usa um FillErrorEventHandler delegado para investigar e manipular o erro. A saída é exibida na janela do console.

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.:
    DataSet dataSet = new DataSet();
    DataTable table = GetIntegerTable();
    dataSet.Tables.Add(table);
    DataTableReader reader = new DataTableReader(GetStringTable());
    dataSet.Load(reader, LoadOption.OverwriteChanges,
        FillErrorHandler, table);

    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 dataSet As New DataSet
  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.:
  dataSet = New DataSet()
  table = GetIntegerTable()
  dataSet.Tables.Add(table)
  Dim reader As New DataTableReader(GetStringTable())
  dataSet.Load(reader, LoadOption.OverwriteChanges, _
      AddressOf FillErrorHandler, table)

  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 método Load fornece uma técnica para preencher um único DataTable com dados, recuperado a partir de uma instância IDataReader. Esse método fornece a mesma funcionalidade, mas permite que você carregue vários conjuntos de resultados de uma IDataReader em várias tabelas dentro de uma DataSet.

Observação

A operação de carga falhará com uma se qualquer uma InvalidOperationException das colunas de dados de origem na entrada reader for colunas computadas.

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

O esquema de resolução de nomes para esse método é o mesmo que o seguido pelo Fill método da DbDataAdapter classe.

Confira também

Usando Conjuntos de Dados no ADO.NET

Aplica-se a

DataSet.Load Método

Definição

Sobrecargas

Comentários

Load(IDataReader, LoadOption, DataTable[])

Parâmetros

Exemplos

Comentários

Confira também

Aplica-se a

Load(IDataReader, LoadOption, String[])

Parâmetros

Exemplos

Comentários

Confira também

Aplica-se a

Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])

Parâmetros

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais