Compartir vía

DataSet.Load Método

  • Referencia

Definición

Espacio de nombres:
System.Data
Ensamblado:
System.Data.Common.dll
Ensamblado:
System.Data.dll
Ensamblado:
netstandard.dll

Rellena un objeto DataSet con valores de un origen de datos utilizando la interfaz IDataReader proporcionada.

Sobrecargas

Load(IDataReader, LoadOption, DataTable[])

Rellena un objeto DataSet de valores de un origen de datos utilizando la interfaz IDataReader proporcionada, que usa una matriz de instancias de DataTable para suministrar la información sobre el espacio de nombres y el esquema.
Load(IDataReader, LoadOption, String[])

Rellena un objeto DataSet de valores de un origen de datos utilizando la interfaz IDataReader proporcionada, que usa una matriz de cadenas para suministrar los nombres para las tablas de DataSet.
Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])

Rellena un objeto DataSet de valores de un origen de datos utilizando la interfaz IDataReader proporcionada, que usa una matriz de instancias de DataTable para suministrar la información sobre el espacio de nombres y el esquema.

Comentarios

El Load método proporciona una técnica para rellenar un único DataTable con datos, recuperados de una IDataReader instancia. Este método proporciona la misma funcionalidad, pero permite cargar varios conjuntos de resultados de una en IDataReader varias tablas dentro de .DataSet

Si el objeto DataSet ya contiene filas, los datos de entrada del origen de datos se combinan con las filas existentes.

El Load método se puede usar en varios escenarios comunes, centrados en obtener datos de un origen de datos especificado y agregarlos al contenedor de datos actual (en este caso, un DataSet). En estos escenarios se describe el uso estándar de , DataSetque describe su comportamiento de actualización y combinación.

Sincroniza DataSet o actualiza con un único origen de datos principal. DataSet Realiza un seguimiento de los cambios, lo que permite la sincronización con el origen de datos principal. Además, un DataSet puede aceptar datos incrementales de uno o varios orígenes de datos secundarios. DataSet No es responsable del seguimiento de los cambios para permitir la sincronización con el origen de datos secundario.

Dados estos dos orígenes de datos hipotéticos, es probable que un usuario requiera uno de los siguientes comportamientos:

  • Inicialice DataSet a partir de un origen de datos principal. En este escenario, el usuario quiere inicializar un vacío DataSet con valores del origen de datos principal. Se modifican uno o varios contenidos de DataTable. Más adelante, el usuario piensa propagar los cambios al origen de datos principal.

  • Conserve los cambios y vuelva a sincronizarse desde el origen de datos principal. En este escenario, el usuario quiere tomar el DataSet relleno en el escenario anterior y realizar una sincronización incremental con el origen de datos principal, conservando las modificaciones realizadas en .DataSet

  • Fuente de distribución de datos incremental de orígenes de datos secundarios. En este escenario, el usuario quiere combinar los cambios de uno o varios orígenes de datos secundarios y propagar esos cambios al origen de datos principal.

El Load método hace posible todos estos escenarios. Este método permite especificar un parámetro de opción de carga, lo que indica cómo se cargan las filas que ya están en una DataTable combinación con las filas que se cargan. En la tabla siguiente se describen las tres opciones de carga proporcionadas por la LoadOption enumeración . En cada caso, la descripción indica el comportamiento cuando la clave principal de una fila de los datos entrantes coincide con la clave principal de una fila existente.

Opción de carga Descripción
PreserveChanges (valor predeterminado) Novedades la versión original de la fila con el valor de la fila entrante.
OverwriteChanges Novedades las versiones actuales y originales de la fila con el valor de la fila entrante.
Upsert Novedades la versión actual de la fila con el valor de la fila entrante.

En general, las PreserveChanges opciones y OverwriteChanges están pensadas para escenarios en los que el usuario necesita sincronizar y DataSet sus cambios con el origen de datos principal. La Upsert opción facilita la agregación de cambios de uno o varios orígenes de datos secundarios.

Load(IDataReader, LoadOption, DataTable[])

Source:
DataSet.cs
Source:
DataSet.cs
Source:
DataSet.cs

Rellena un objeto DataSet de valores de un origen de datos utilizando la interfaz IDataReader proporcionada, que usa una matriz de instancias de DataTable para suministrar la información sobre el espacio de nombres y el esquema.

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

IDataReader que proporciona uno o varios conjuntos de resultados.

loadOption
LoadOption

Valor de la enumeración LoadOption que indica cómo se van a combinar las filas que ya se encuentran en las instancias de DataTable, incluidas en el objeto DataSet, con las filas de entrada con las que comparten la misma clave principal.

tables
DataTable[]

Matriz de instancias de DataTable de las que el método Load(IDataReader, LoadOption, DataTable[]) recupera la información sobre el espacio de nombres y el nombre. Cada una de estas tablas debe ser un miembro de la colección DataTableCollection que incluye este objeto DataSet.

Ejemplos

En el ejemplo siguiente se crea un nuevo DataSet, se agregan dos DataTable instancias a y, a DataSetcontinuación, se rellena mediante el Load método y se recuperan datos de un DataTableReader objeto que contiene dos conjuntos DataSet de resultados. Por último, en el ejemplo se muestra el contenido de las tablas en la ventana de la consola.

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

Comentarios

El Load método proporciona una técnica para rellenar un único DataTable con datos, recuperados de una IDataReader instancia. Este método proporciona la misma funcionalidad, pero permite cargar varios conjuntos de resultados de una en IDataReader varias tablas dentro de .DataSet

Nota

La operación de carga producirá un InvalidOperationException error si alguna de las columnas de datos de origen de la entrada reader son columnas calculadas.

El loadOption parámetro permite especificar cómo desea que los datos importados interactúen con los datos existentes y pueden ser cualquiera de los valores de la LoadOption enumeración. Consulte la documentación del DataTableLoad método para obtener más información sobre el uso de este parámetro.

El tables parámetro permite especificar una matriz de DataTable instancias, que indica el orden de las tablas correspondientes a cada conjunto de resultados cargado desde el lector. El Load método rellena cada instancia proporcionada DataTable con datos de un único conjunto de resultados del lector de datos de origen. Después de cada conjunto de resultados, el Load método pasa al siguiente conjunto de resultados dentro del lector, hasta que no haya más conjuntos de resultados.

El esquema de resolución de nombres para este método es el mismo que seguido del Fill método de la DbDataAdapter clase .

Consulte también

Se aplica a

Load(IDataReader, LoadOption, String[])

Source:
DataSet.cs
Source:
DataSet.cs
Source:
DataSet.cs

Rellena un objeto DataSet de valores de un origen de datos utilizando la interfaz IDataReader proporcionada, que usa una matriz de cadenas para suministrar los nombres para las tablas 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

IDataReader que proporciona uno o varios conjuntos de resultados.

loadOption
LoadOption

Valor de la enumeración LoadOption que indica cómo se van a combinar las filas que ya se encuentran en las instancias de DataTable, incluidas en el objeto DataSet, con las filas de entrada con las que comparten la misma clave principal.

tables
String[]

Matriz de cadenas de las que el método Load recupera la información sobre el nombre de tabla.

Ejemplos

En el siguiente ejemplo de aplicación de consola se crean primero tablas y se cargan datos de un lector en , DataSetmediante el Load método . A continuación, en el ejemplo se agregan tablas a DataSet y se intenta rellenar las tablas con datos de .DataTableReader En este ejemplo, dado que los parámetros pasados al Load método indican un nombre de tabla que no existe, el Load método crea una nueva tabla para que coincida con el nombre pasado como parámetro. Una vez cargados los datos, el ejemplo muestra el contenido de todas sus tablas en la ventana Consola.

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

Comentarios

El Load método proporciona una técnica para rellenar un único DataTable con datos, recuperados de una IDataReader instancia. Este método proporciona la misma funcionalidad, pero permite cargar varios conjuntos de resultados de una en IDataReader varias tablas dentro de .DataSet

Nota

La operación de carga producirá un InvalidOperationException error si alguna de las columnas de datos de origen de la entrada reader son columnas calculadas.

El loadOption parámetro permite especificar cómo desea que los datos importados interactúen con los datos existentes y pueden ser cualquiera de los valores de la LoadOption enumeración. Consulte la documentación del Load método para obtener más información sobre el uso de este parámetro.

El tables parámetro permite especificar una matriz de nombres de tabla, que indica el orden de las tablas correspondientes a cada conjunto de resultados cargado desde el lector. El Load método intenta buscar una tabla dentro del DataSet nombre que se encuentra en la matriz de nombres de tabla, en orden. Si se encuentra una tabla coincidente, esa tabla se carga con el contenido del conjunto de resultados actual. Si no se encuentra ninguna tabla coincidente, se crea una tabla con el nombre proporcionado en la matriz de nombres de tabla y el esquema de la nueva tabla se deduce del conjunto de resultados. Después de cada conjunto de resultados, el Load método pasa al siguiente conjunto de resultados dentro del lector, hasta que no haya más conjuntos de resultados.

El espacio de nombres predeterminado asociado a DataSet, si existe, está asociado a cada objeto recién creado DataTable. El esquema de resolución de nombres para este método es el mismo que seguido del Fill método de la DbDataAdapter clase .

Consulte también

Se aplica a

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

Source:
DataSet.cs
Source:
DataSet.cs
Source:
DataSet.cs

Rellena un objeto DataSet de valores de un origen de datos utilizando la interfaz IDataReader proporcionada, que usa una matriz de instancias de DataTable para suministrar la información sobre el espacio de nombres y el esquema.

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

IDataReader que proporciona uno o varios conjuntos de resultados.

loadOption
LoadOption

Valor de la enumeración LoadOption que indica cómo se van a combinar las filas que ya se encuentran en las instancias de DataTable, incluidas en el objeto DataSet, con las filas de entrada con las que comparten la misma clave principal.

errorHandler
FillErrorEventHandler

Delegado FillErrorEventHandler al que se va a llamar cuando se produzca un error mientras se cargan los datos.

tables
DataTable[]

Matriz de instancias de DataTable de las que el método Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) recupera la información sobre el espacio de nombres y el nombre.

Ejemplos

En el ejemplo siguiente se agrega una tabla a y, a DataSetcontinuación, se intenta usar el Load método para cargar datos de un DataTableReader objeto que contiene un esquema incompatible. En lugar de capturar el error, en este ejemplo se usa un FillErrorEventHandler delegado para investigar y controlar el error. La salida se muestra en la ventana de la consola.

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

Comentarios

El Load método proporciona una técnica para rellenar un único DataTable con datos, recuperados de una IDataReader instancia. Este método proporciona la misma funcionalidad, pero permite cargar varios conjuntos de resultados de una en IDataReader varias tablas dentro de .DataSet

Nota

La operación de carga producirá un InvalidOperationException error si alguna de las columnas de datos de origen de la entrada reader son columnas calculadas.

El loadOption parámetro permite especificar cómo desea que los datos importados interactúen con los datos existentes y pueden ser cualquiera de los valores de la LoadOption enumeración. Consulte la documentación del DataTableLoad método para obtener más información sobre el uso de este parámetro.

El errorHandler parámetro es un FillErrorEventHandler delegado que hace referencia a un procedimiento al que se llama cuando se produce un error al cargar datos. El FillErrorEventArgs parámetro pasado al procedimiento proporciona propiedades que permiten recuperar información sobre el error que se produjo, la fila actual de datos y el DataTable que se va a rellenar. El uso de este mecanismo de delegado, en lugar de un bloque try/catch más sencillo, le permite determinar el error, controlar la situación y continuar procesando si lo desea. El FillErrorEventArgs parámetro proporciona una Continue propiedad: establezca esta propiedad en true para indicar que ha controlado el error y desea continuar el procesamiento; establezca la propiedad false en para indicar que desea detener el procesamiento. Tenga en cuenta que establecer la propiedad en false hace que el código que desencadene el problema produzca una excepción.

El tables parámetro permite especificar una matriz de DataTable instancias, que indica el orden de las tablas correspondientes a cada conjunto de resultados cargado desde el lector. El Load método rellena cada instancia proporcionada DataTable con datos de un único conjunto de resultados del lector de datos de origen. Después de cada conjunto de resultados, el Load método pasa al siguiente conjunto de resultados dentro del lector, hasta que no haya más conjuntos de resultados.

El esquema de resolución de nombres para este método es el mismo que seguido del Fill método de la DbDataAdapter clase .

Consulte también

Se aplica a