DataTable.Load Método

Referencia

Definición

Espacio de nombres:: System.Data

Ensamblado:: System.Data.Common.dll

Ensamblado:: System.Data.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada. Si el objeto DataTable ya contiene filas, los datos de entrada del origen de datos se combinan con las filas existentes.

Sobrecargas

Load(IDataReader)	Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada. Si el objeto DataTable ya contiene filas, los datos de entrada del origen de datos se combinan con las filas existentes.
Load(IDataReader, LoadOption)	Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada. Si el objeto `DataTable` ya contiene las filas, los datos de entrada del origen de datos se combinan con las filas existentes conforme al valor del parámetro `loadOption`.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada y un delegado de control de errores.

Ejemplos

En el ejemplo siguiente se muestran varios de los problemas relacionados con la llamada al Load método . En primer lugar, el ejemplo se centra en los problemas de esquema, incluida la inferencia de un esquema de la carga y IDataReader, a continuación, el control de esquemas incompatibles y esquemas con columnas que faltan o son adicionales. A continuación, el ejemplo se centra en los problemas de datos, incluido el control de las distintas opciones de carga.

Nota

En este ejemplo se muestra cómo usar una de las versiones sobrecargadas de Load. Para ver otros ejemplos que podrían estar disponibles, consulte los temas de sobrecarga individuales.

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

Comentarios

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 DataTable). En estos escenarios se describe el uso estándar de , DataTableque describe su comportamiento de actualización y combinación.

Sincroniza DataTable o actualiza con un único origen de datos principal. Realiza DataTable un seguimiento de los cambios, lo que permite la sincronización con el origen de datos principal. Además, un DataTable puede aceptar datos incrementales de uno o varios orígenes de datos secundarios. DataTable 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:

Inicializar DataTable a partir de un origen de datos principal. En este escenario, el usuario quiere inicializar un vacío DataTable con valores del origen de datos principal. Más adelante, el usuario pretende 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 rellenar el DataTable escenario anterior y realizar una sincronización incremental con el origen de datos principal, conservando las modificaciones realizadas en .DataTable
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. Todas las sobrecargas excepto una de las sobrecargas de este método permiten especificar un parámetro de opción de carga, lo que indica cómo las filas ya están en una DataTable combinación con las filas que se cargan. (La sobrecarga que no permite especificar el comportamiento usa la opción de carga predeterminada). 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)

Source:: DataTable.cs

Source:: DataTable.cs

Source:: DataTable.cs

Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada. Si el objeto DataTable ya contiene filas, los datos de entrada del origen de datos se combinan con las filas 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

Interfaz IDataReader que proporciona un conjunto de resultados.

Ejemplos

En el ejemplo siguiente se muestran varios de los problemas relacionados con la llamada al Load método . En primer lugar, el ejemplo se centra en los problemas de esquema, incluida la inferencia de un esquema de la carga y IDataReader, a continuación, el control de esquemas incompatibles y esquemas con columnas que faltan o son adicionales. A continuación, el ejemplo llama al Load método , que muestra los datos antes y después de la operación 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

Comentarios

El Load método consume el primer conjunto de resultados de la carga y IDataReader, después de la finalización correcta, establece la posición del lector en el siguiente conjunto de resultados, si existe. Al convertir datos, el Load método usa las mismas reglas de conversión que el DbDataAdapter.Fill método .

El Load método debe tener en cuenta tres problemas específicos al cargar los datos desde una IDataReader instancia: esquema, datos y operaciones de eventos. Al trabajar con el esquema, el Load método puede encontrar condiciones como se describe en la tabla siguiente. Las operaciones de esquema tienen lugar para todos los conjuntos de resultados importados, incluso aquellos que no contienen datos.

Condición	Comportamiento
no DataTable tiene ningún esquema.	El Load método deduce el esquema basándose en el conjunto de resultados del objeto importado IDataReader.
DataTable tiene un esquema, pero no es compatible con el esquema cargado.	El Load método produce una excepción correspondiente al error concreto que se produce al intentar cargar datos en el esquema incompatible.
Los esquemas son compatibles, pero el esquema del conjunto de resultados cargado contiene columnas que no existen en .DataTable	El Load método agrega las columnas adicionales al `DataTable`esquema de . El método produce una excepción si las columnas correspondientes de DataTable y el conjunto de resultados cargado no son compatibles con el valor. El método también recupera información de restricciones del conjunto de resultados para todas las columnas agregadas. Excepto en el caso de la restricción De clave principal, esta información de restricción solo se usa si el actual DataTable no contiene ninguna columna al principio de la operación de carga.
Los esquemas son compatibles, pero el esquema del conjunto de resultados cargado contiene menos columnas que .`DataTable`	Si una columna que falta tiene un valor predeterminado definido o el tipo de datos de la columna acepta valores NULL, el Load método permite agregar las filas, sustituyendo el valor predeterminado o `null` por el valor de la columna que falta. Si no se puede usar ningún valor predeterminado o `null` , el `Load` método produce una excepción. Si no se ha proporcionado ningún valor predeterminado específico, el `Load` método usa el `null` valor como valor predeterminado implícito.

Antes de considerar el comportamiento del Load método en términos de operaciones de datos, tenga en cuenta que cada fila de un DataTable mantiene el valor actual y el valor original de cada columna. Estos valores pueden ser equivalentes o pueden ser diferentes si los datos de la fila se han cambiado desde que se ha rellenado .DataTable Para obtener más información, vea Estados de fila y versiones de fila.

Esta versión del Load método intenta conservar los valores actuales en cada fila, dejando intacto el valor original. (Si desea un control más preciso sobre el comportamiento de los datos entrantes, consulte DataTable.Load). Si la fila existente y la fila entrante contienen los valores de clave principal correspondientes, la fila se procesa con su valor de estado de fila actual; de lo contrario, se trata como una nueva fila.

En términos de operaciones de eventos, el RowChanging evento se produce antes de que se cambie cada fila y el RowChanged evento se produce después de que se haya cambiado cada fila. En cada caso, la Action propiedad de la DataRowChangeEventArgs instancia que se pasa al controlador de eventos contiene información sobre la acción determinada asociada al evento. Este valor de acción depende del estado de la fila antes de la operación de carga. En cada caso, se producen ambos eventos y la acción es la misma para cada uno. La acción se puede aplicar a la versión actual o original de cada fila, o ambas, según el estado de fila actual.

En la tabla siguiente se muestra el comportamiento del Load método . La fila final (con la etiqueta "(No presente)") describe el comportamiento de las filas entrantes que no coinciden con ninguna fila existente. Cada celda de esta tabla describe el valor actual y original de un campo dentro de una fila, junto con para el DataRowState valor una vez completado el Load método. En este caso, el método no permite indicar la opción de carga y usa el valor predeterminado, PreserveChanges.

DataRowState existente	Valores después `Load` del método y acción de evento
Adición	Current = <Existing> Original = <Entrante> State = <Modified> RowAction = ChangeOriginal
Modificado	Current = <Existing> Original = <Entrante> State = <Modified> RowAction = ChangeOriginal
Deleted	Actual = <No disponible> Original = <Entrante> Estado = <Eliminado> RowAction = ChangeOriginal
Sin cambios	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal
(No está presente)	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal

Los valores de se DataColumn pueden restringir mediante el uso de propiedades como ReadOnly y AutoIncrement. El Load método controla estas columnas de forma coherente con el comportamiento definido por las propiedades de la columna. La restricción de solo lectura de es DataColumn aplicable solo a los cambios que se producen en la memoria. El Load método sobrescribe los valores de columna de solo lectura, si es necesario.

Para determinar qué versión del campo de clave principal se va a usar para comparar la fila actual con una fila entrante, el Load método usa la versión original del valor de clave principal dentro de una fila, si existe. De lo contrario, el Load método usa la versión actual del campo de clave principal.

Consulte también

Se aplica a

Load(IDataReader, LoadOption)

Source:: DataTable.cs

Source:: DataTable.cs

Source:: DataTable.cs

Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada. Si el objeto DataTable ya contiene las filas, los datos de entrada del origen de datos se combinan con las filas existentes conforme al valor del parámetro loadOption.

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

IDataReader que proporciona uno o varios conjuntos de resultados.

loadOption: LoadOption

Valor de la enumeración LoadOption que indica cómo se combinan las filas que ya existen en el objeto DataTable con las filas de entrada con las que comparten la misma clave principal.

Ejemplos

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

Comentarios

El Load método consume el primer conjunto de resultados de la carga y IDataReader, después de la finalización correcta, establece la posición del lector en el siguiente conjunto de resultados, si existe. Al convertir datos, el Load método usa las mismas reglas de conversión que el Fill método .

El Load método debe tener en cuenta tres problemas específicos al cargar los datos desde una IDataReader instancia: esquema, datos y operaciones de eventos. Al trabajar con el esquema, el Load método puede encontrar condiciones como se describe en la tabla siguiente. Las operaciones de esquema tienen lugar para todos los conjuntos de resultados importados, incluso aquellos que no contienen datos.

Condición	Comportamiento
no DataTable tiene ningún esquema.	El `Load` método deduce el esquema basándose en el conjunto de resultados del objeto importado IDataReader.
DataTable tiene un esquema, pero no es compatible con el esquema cargado.	El `Load` método produce una excepción correspondiente al error concreto que se produce al intentar cargar datos en el esquema incompatible.
Los esquemas son compatibles, pero el esquema del conjunto de resultados cargado contiene columnas que no existen en .`DataTable`	El `Load` método agrega las columnas adicionales al `DataTable`esquema de . El método produce una excepción si las columnas correspondientes de DataTable y el conjunto de resultados cargado no son compatibles con el valor. El método también recupera información de restricciones del conjunto de resultados para todas las columnas agregadas. Excepto en el caso de la restricción De clave principal, esta información de restricción solo se usa si el actual DataTable no contiene ninguna columna al principio de la operación de carga.
Los esquemas son compatibles, pero el esquema del conjunto de resultados cargado contiene menos columnas que .`DataTable`	Si una columna que falta tiene definido un valor predeterminado o el tipo de datos de la columna acepta valores NULL, el `Load` método permite agregar las filas, sustituyendo el valor predeterminado o null de la columna que falta. Si no se puede usar ningún valor predeterminado o null, el `Load` método produce una excepción. Si no se ha proporcionado ningún valor predeterminado específico, el `Load` método usa el valor NULL como valor predeterminado implícito.

Antes de considerar el comportamiento del Load método en términos de operaciones de datos, tenga en cuenta que cada fila de un DataTable mantiene el valor actual y el valor original de cada columna. Estos valores pueden ser equivalentes o pueden ser diferentes si los datos de la fila se han cambiado desde que se ha rellenado .DataTable Vea Row States and Row Versions (Estados de fila y versiones de fila ) para obtener más información.

En esta llamada al método, el parámetro especificado LoadOption influye en el procesamiento de los datos entrantes. ¿Cómo debe el método Load controlar la carga de filas que tienen la misma clave principal que las filas existentes? ¿Debe modificar los valores actuales, los valores originales o ambos? Estos problemas, y mucho más, se controlan mediante el loadOption parámetro .

Si la fila existente y la fila entrante contienen los valores de clave principal correspondientes, la fila se procesa con su valor de estado de fila actual; de lo contrario, se trata como una nueva fila.

En términos de operaciones de eventos, el RowChanging evento se produce antes de que se cambie cada fila y el RowChanged evento se produce después de que se haya cambiado cada fila. En cada caso, la Action propiedad de la DataRowChangeEventArgs instancia que se pasa al controlador de eventos contiene información sobre la acción determinada asociada al evento. Este valor de acción varía, según el estado de la fila antes de la operación de carga. En cada caso, se producen ambos eventos y la acción es la misma para cada uno. La acción se puede aplicar a la versión actual o original de cada fila, o ambas, según el estado de fila actual.

En la tabla siguiente se muestra el comportamiento del método Load cuando se llama con cada uno de los LoadOption valores y también se muestra cómo interactúan los valores con el estado de fila de la fila que se carga. La fila final (con la etiqueta "(No presente)") describe el comportamiento de las filas entrantes que no coinciden con ninguna fila existente. Cada celda de esta tabla describe el valor actual y original de un campo dentro de una fila, junto con para el DataRowState valor una vez completado el Load método.

DataRowState existente	Upsert	OverwriteChanges	PreserveChanges (comportamiento predeterminado)
Adición	Current = <Incoming> Original = -<No disponible> State = <Agregado> RowAction = Cambiar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Entrante> State = <Modified> RowAction = ChangeOriginal
Modificado	Current = <Incoming> Original = <Existente> State = <Modified> RowAction = Cambiar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Entrante> State = <Modified> RowAction =ChangeOriginal
Deleted	(La carga no afecta a las filas eliminadas) Current = --- Original = <Existente> Estado = <Eliminado> (Se agrega una nueva fila con las siguientes características) Current = <Incoming> Original = <No disponible> State = <Agregado> RowAction = Agregar	Deshacer eliminación y Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Actual = <No disponible> Original = <Entrante> Estado = <Eliminado> RowAction = ChangeOriginal
Sin cambios	Current = <Incoming> Original = <Existente> Si el nuevo valor es el mismo que el valor existente, State = <Unchanged> RowAction = Nothing Else State = <Modified> RowAction = Cambiar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal
No está presente)	Current = <Incoming> Original = <No disponible> State = <Added> RowAction = Agregar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal

Los valores de un DataColumn objeto se pueden restringir mediante el uso de propiedades como ReadOnly y AutoIncrement. El Load método controla estas columnas de forma coherente con el comportamiento definido por las propiedades de la columna. La restricción de solo lectura de un DataColumn objeto solo es aplicable a los cambios que se producen en la memoria. El Load método sobrescribe los valores de columna de solo lectura, si es necesario.

Si especifica las opciones OverwriteChanges o PreserveChanges al llamar al Load método , se supone que los datos entrantes proceden DataTabledel origen de datos principal y DataTable realiza un seguimiento de los cambios y pueden propagar los cambios al origen de datos. Si selecciona la opción Upsert, se supone que los datos proceden de uno de un origen de datos secundario, como los datos proporcionados por un componente de nivel intermedio, quizás modificados por un usuario. En este caso, la suposición es que la intención es agregar datos de uno o varios orígenes de datos en DataTabley, a continuación, puede propagar los datos de nuevo al origen de datos principal. El LoadOption parámetro se usa para determinar la versión específica de la fila que se va a usar para la comparación de clave principal. En la tabla siguiente se proporcionan los detalles.

Opción Cargar	Versión de DataRow usada para la comparación de claves principal
`OverwriteChanges`	Versión original, si existe, en caso contrario, versión actual
`PreserveChanges`	Versión original, si existe, en caso contrario, versión actual
`Upsert`	Versión actual, si existe, de lo contrario, versión original

Consulte también

Se aplica a

Load(IDataReader, LoadOption, FillErrorEventHandler)

Source:: DataTable.cs

Source:: DataTable.cs

Source:: DataTable.cs

Rellena un objeto DataTable con valores de un origen de datos utilizando la interfaz IDataReader proporcionada y un delegado de control de errores.

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

Interfaz IDataReader que proporciona un conjunto de resultados.

loadOption: LoadOption

Valor de la enumeración LoadOption que indica cómo se combinan las filas que ya existen en el objeto DataTable 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.

Ejemplos

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

Comentarios

El Load método consume el primer conjunto de resultados de la carga IDataReadery, después de la finalización correcta, establece la posición del lector en el siguiente conjunto de resultados, si existe. Al convertir datos, el Load método usa las mismas reglas de conversión que el DbDataAdapter.Fill método .

El Load método debe tener en cuenta tres problemas específicos al cargar los datos de una IDataReader instancia: esquema, datos y operaciones de eventos. Al trabajar con el esquema, el Load método puede encontrar condiciones como se describe en la tabla siguiente. Las operaciones de esquema tienen lugar para todos los conjuntos de resultados importados, incluso aquellos que no contienen datos.

Condición	Comportamiento
no DataTable tiene ningún esquema.	El `Load` método deduce el esquema basado en el conjunto de resultados del objeto importado IDataReader.
DataTable tiene un esquema, pero no es compatible con el esquema cargado.	El `Load` método produce una excepción correspondiente al error concreto que se produce al intentar cargar datos en el esquema incompatible.
Los esquemas son compatibles, pero el esquema del conjunto de resultados cargado contiene columnas que no existen en .`DataTable`	El `Load` método agrega las columnas adicionales al `DataTable`esquema. El método produce una excepción si las columnas correspondientes de DataTable y el conjunto de resultados cargados no son compatibles con el valor. El método también recupera información de restricciones del conjunto de resultados para todas las columnas agregadas. Excepto en el caso de la restricción De clave principal, esta información de restricción solo se usa si el actual DataTable no contiene ninguna columna al principio de la operación de carga.
Los esquemas son compatibles, pero el esquema del conjunto de resultados cargado contiene menos columnas de las que hace .`DataTable`	Si una columna que falta tiene un valor predeterminado definido o el tipo de datos de la columna acepta valores NULL, el `Load` método permite agregar las filas, sustituyendo el valor predeterminado o nulo de la columna que falta. Si no se puede usar ningún valor predeterminado o null, el `Load` método produce una excepción. Si no se ha proporcionado ningún valor predeterminado específico, el `Load` método usa el valor NULL como valor predeterminado implícito.

Antes de considerar el comportamiento del Load método en términos de operaciones de datos, tenga en cuenta que cada fila dentro de un DataTable mantiene el valor actual y el valor original para cada columna. Estos valores pueden ser equivalentes o pueden ser diferentes si los datos de la fila se han cambiado desde que se rellena .DataTable Consulte Row States and Row Versions (Estados de fila y versiones de fila ) para obtener más información.

En términos de operaciones de eventos, el RowChanging evento se produce antes de que se cambie cada fila y el RowChanged evento se produce después de que se haya cambiado cada fila. En cada caso, la Action propiedad de la DataRowChangeEventArgs instancia pasada al controlador de eventos contiene información sobre la acción determinada asociada al evento. Este valor de acción varía en función del estado de la fila antes de la operación de carga. En cada caso, se producen ambos eventos y la acción es la misma para cada uno. La acción se puede aplicar a la versión actual o original de cada fila, o ambas, en función del estado de fila actual.

En la tabla siguiente se muestra el comportamiento del método Load cuando se llama con cada uno de los LoadOption valores y también se muestra cómo interactúan los valores con el estado de fila de la fila que se carga. La fila final (etiquetada como "(No presente)") describe el comportamiento de las filas entrantes que no coinciden con ninguna fila existente. Cada celda de esta tabla describe el valor actual y original de un campo dentro de una fila, junto con para el DataRowState valor una vez completado el Load método.

DataRowState existente	Upsert	OverwriteChanges	PreserveChanges (comportamiento predeterminado)
Adición	Current = <Incoming> Original = -<Not available> State = <Added> RowAction = Cambiar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Entrante> State = <Modified> RowAction = ChangeOriginal
Modificado	Current = <Incoming> Original = <Existente> State = <Modified> RowAction = Cambiar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Entrante> State = <Modified> RowAction =ChangeOriginal
eleted	(La carga no afecta a las filas eliminadas) Current = --- Original = <Existente> Estado = <Eliminado> (Se agrega una nueva fila con las siguientes características) Current = <Incoming> Original = <No disponible> State = <Agregado> RowAction = Agregar	Deshacer eliminación y Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Actual = <No disponible> Original = <Entrante> Estado = <Eliminado> RowAction = ChangeOriginal
Sin cambios	Current = <Incoming> Original = <Existente> Si el nuevo valor es el mismo que el valor existente, State = <Unchanged> RowAction = Nothing Else State = <Modified> RowAction = Cambiar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal
No está presente)	Current = <Incoming> Original = <No disponible> State = <Agregado> RowAction = Agregar	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Entrante> State = <Unchanged> RowAction = ChangeCurrentAndOriginal

Si especifica las opciones OverwriteChanges o PreserveChanges al llamar al Load método , se supone que los datos entrantes proceden DataTabledel origen de datos principal y dataTable realiza un seguimiento de los cambios y pueden propagar los cambios al origen de datos. Si selecciona la opción Upsert, se supone que los datos proceden de uno de un origen de datos secundario, como los datos proporcionados por un componente de nivel intermedio, tal vez modificados por un usuario. En este caso, la suposición es que la intención es agregar datos de uno o varios orígenes de datos en DataTabley, a continuación, propagar los datos de nuevo al origen de datos principal. El LoadOption parámetro se usa para determinar la versión específica de la fila que se va a usar para la comparación de claves principales. En la tabla siguiente se proporcionan los detalles.

Opción Cargar	Versión de DataRow usada para la comparación de claves principales
`OverwriteChanges`	Versión original, si existe, en caso contrario, versión actual
`PreserveChanges`	Versión original, si existe, en caso contrario, versión actual
`Upsert`	Versión actual, si existe, en caso contrario, versión original

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 delegado, en lugar de un bloque try/catch más sencillo, le permite determinar el error, controlar la situación y continuar el procesamiento 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 desencadenó el problema produzca una excepción.

Consulte también

Se aplica a

Compartir vía

DataTable.Load Método

Definición

Sobrecargas

Ejemplos

Comentarios

Load(IDataReader)

Parámetros

Ejemplos

Comentarios

Consulte también

Se aplica a

Load(IDataReader, LoadOption)

Parámetros

Ejemplos

Comentarios

Consulte también

Se aplica a

Load(IDataReader, LoadOption, FillErrorEventHandler)

Parámetros

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales