DataTable.Load Metoda

Reference

Definice

Obor názvů:: System.Data

Sestavení:: System.Data.Common.dll

Sestavení:: System.Data.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

DataTable Vyplní hodnotu hodnotami ze zdroje dat pomocí zadaného IDataReader. DataTable Pokud už objekt obsahuje řádky, sloučí se příchozí data ze zdroje dat s existujícími řádky.

Přetížení

Load(IDataReader)	DataTable Vyplní hodnotu hodnotami ze zdroje dat pomocí zadané IDataReaderhodnoty . DataTable Pokud již obsahuje řádky, příchozí data ze zdroje dat se sloučí s existujícími řádky.
Load(IDataReader, LoadOption)	DataTable Vyplní hodnotu hodnotami ze zdroje dat pomocí zadané IDataReaderhodnoty . `DataTable` Pokud již obsahuje řádky, jsou příchozí data ze zdroje dat sloučena s existujícími řádky podle hodnoty parametru`loadOption`.
Load(IDataReader, LoadOption, FillErrorEventHandler)	DataTable Vyplní hodnoty ze zdroje dat pomocí zadaného IDataReader delegáta zpracování chyb.

Příklady

Následující příklad ukazuje několik problémů souvisejících s voláním Load metody. Příklad se nejprve zaměřuje na problémy se schématem, včetně odvození schématu z načteného IDataReadera následného zpracování nekompatibilních schémat a schémat s chybějícími nebo dalšími sloupci. Příklad se pak zaměřuje na problémy s daty, včetně zpracování různých možností načítání.

Poznámka

Tento příklad ukazuje, jak použít jednu z přetížených verzí nástroje Load. Další příklady, které mohou být k dispozici, naleznete v popisu jednotlivých přetížených verzí.

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

Poznámky

Tuto Load metodu lze použít v několika běžných scénářích, které se soustředí na získání dat ze zadaného zdroje dat a jejich přidání do aktuálního kontejneru dat (v tomto případě DataTable). Tyto scénáře popisují standardní použití objektu DataTable, který popisuje jeho chování při aktualizaci a slučování.

Nástroj DataTable se synchronizuje nebo aktualizuje s jedním primárním zdrojem dat. Sleduje DataTable změny a umožňuje synchronizaci s primárním zdrojem dat. Kromě toho může přijímat DataTable přírůstková data z jednoho nebo více sekundárních zdrojů dat. Není DataTable zodpovědný za sledování změn, aby bylo možné synchronizaci se sekundárním zdrojem dat.

Pokud budou k dispozici tyto dva hypotetické zdroje dat, bude uživatel pravděpodobně vyžadovat jedno z následujících chování:

Inicializuje DataTable se z primárního zdroje dat. V tomto scénáři chce uživatel inicializovat prázdnou DataTable hodnotu s hodnotami z primárního zdroje dat. Později hodlá uživatel přenést tyto změny zpět do primárního zdroje dat.
Zachovat změny a znovu provést synchronizaci z primárního zdroje dat. V tomto scénáři chce uživatel převzít DataTable vyplněný v předchozím scénáři a provést přírůstkovou synchronizaci s primárním zdrojem dat, přičemž se zachová změny provedené v objektu DataTable.
Načítat data postupně ze sekundárních zdrojů dat. V tomto scénáři chce uživatel sloučit změny z jednoho nebo více sekundárních zdrojů dat a přenést tyto změny zpět do primárního zdroje dat.

Metoda Load umožňuje všechny tyto scénáře. Všechny přetížení pro tuto metodu kromě jednoho umožňují zadat parametr možnosti načtení, který označuje, jak řádky již v DataTable kombinaci s řádky jsou načteny. (Přetížení, které neumožňuje zadat chování, používá výchozí možnost načtení.) Následující tabulka popisuje tři možnosti načtení, které LoadOption poskytuje výčet. Popis jednotlivých možností poskytuje informace o chování v případě, že se primární klíč řádku v příchozích datech shoduje s primárním klíčem existujícího řádku.

Možnost metody Load	Description
`PreserveChanges` (výchozí)	Aktualizuje původní verzi řádku s použitím hodnoty z příchozího řádku.
`OverwriteChanges`	Aktualizuje aktuální a původní verze řádku s použitím hodnoty z příchozího řádku.
`Upsert`	Aktualizuje aktuální verzi řádku s použitím hodnoty z příchozího řádku.

Obecně platí, že možnosti a OverwriteChanges jsou určeny pro scénáře, PreserveChanges ve kterých uživatel potřebuje synchronizovat DataSet a jeho změny s primárním zdrojem dat. Tato Upsert možnost usnadňuje agregaci změn z jednoho nebo více sekundárních zdrojů dat.

Load(IDataReader)

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

DataTable Vyplní hodnotu hodnotami ze zdroje dat pomocí zadané IDataReaderhodnoty . DataTable Pokud již obsahuje řádky, příchozí data ze zdroje dat se sloučí s existujícími řádky.

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)

Parametry

reader: IDataReader

Soubor IDataReader , který poskytuje sadu výsledků.

Příklady

Následující příklad ukazuje několik problémů souvisejících s voláním Load metody. Příklad se nejprve zaměřuje na problémy se schématem, včetně odvození schématu z načteného IDataReadera následného zpracování nekompatibilních schémat a schémat s chybějícími nebo dalšími sloupci. Příklad pak zavolá metodu Load a zobrazí data před i po operaci načtení.

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

Poznámky

Metoda Load využívá první sadu výsledků z načtené IDataReadersady a po úspěšném dokončení nastaví pozici čtenáře na další sadu výsledků, pokud existuje. Při převodu Load dat metoda používá stejná pravidla převodu DbDataAdapter.Fill jako metoda.

Metoda Load musí brát v úvahu tři konkrétní problémy při načítání dat z IDataReader instance: schéma, data a operace událostí. Při práci se schématem může metoda narazit na Load podmínky popsané v následující tabulce. Operace schématu probíhají pro všechny importované sady výsledků, a to i pro ty, které neobsahují žádná data.

Podmínka	Chování
Nemá DataTable žádné schéma.	Metoda Load odvodí schéma na základě sady výsledků z importovaného IDataReaderobjektu .
Má DataTable schéma, ale není kompatibilní s načteným schématem.	Metoda Load vyvolá výjimku odpovídající konkrétní chybě, ke které dochází při pokusu o načtení dat do nekompatibilního schématu.
Schémata jsou kompatibilní, ale načtené schéma sady výsledků obsahuje sloupce, které neexistují v objektu DataTable.	Metoda Load přidá další sloupce do `DataTable`schématu . Metoda vyvolá výjimku, pokud odpovídající sloupce v DataTable a načtené sadě výsledků nejsou kompatibilní s hodnotou. Metoda také načte informace o omezení ze sady výsledků pro všechny přidané sloupce. S výjimkou případu omezení primárního klíče se tyto informace o omezení použijí pouze v případě, že aktuální DataTable neobsahuje žádné sloupce na začátku operace načítání.
Schémata jsou kompatibilní, ale načtené schéma sady výsledků obsahuje méně sloupců než `DataTable`.	Pokud má chybějící sloupec definovanou výchozí hodnotu nebo datový typ sloupce má hodnotu null, Load metoda umožňuje přidat řádky a nahradit výchozí nebo `null` hodnotu chybějícího sloupce. Pokud není výchozí hodnota nebo `null` lze použít, `Load` vyvolá metoda výjimku. Pokud nebyla zadána žádná konkrétní výchozí hodnota, `Load` metoda použije `null` hodnotu jako implicitní výchozí hodnotu.

Před zvážením Load chování metody z hlediska operací s daty zvažte, že každý řádek v rámci objektu DataTable zachovává aktuální i původní hodnotu pro každý sloupec. Tyto hodnoty můžou být ekvivalentní nebo se můžou lišit, pokud se data v řádku od vyplnění DataTablezměnila. Další informace najdete v tématu Stavy řádků a Verze řádků.

Tato verze Load metody se pokusí zachovat aktuální hodnoty v každém řádku a původní hodnotu ponechá nedotčenou. (Pokud chcete mít nad chováním příchozích dat podrobnější kontrolu, přečtěte si téma DataTable.Load.) Pokud existující řádek a příchozí řádek obsahují odpovídající hodnoty primárního klíče, je řádek zpracován pomocí aktuální hodnoty stavu řádku, jinak se považuje za nový řádek.

Pokud jde o operace událostí, RowChanging událost nastane před změnou každého řádku a RowChanged událost nastane po změně každého řádku. V každém případě Action vlastnost DataRowChangeEventArgs instance předaná obslužné rutině události obsahuje informace o konkrétní akci přidružené k události. Tato hodnota akce závisí na stavu řádku před operací načtení. V každém případě dojde k oběma událostem a akce je pro každou z nich stejná. Akce se může v závislosti na aktuálním stavu řádku použít buď na aktuální nebo původní verzi každého řádku, nebo na obě.

V následující tabulce je uvedené chování metody Load . Poslední řádek (označený "(Není)) popisuje chování příchozích řádků, které neodpovídají žádnému existujícímu řádku. Každá buňka v této tabulce popisuje aktuální a původní hodnotu pole na řádku spolu s DataRowState hodnotou pro hodnotu po Load dokončení metody. V tomto případě metoda neumožňuje označit možnost načtení a použije výchozí PreserveChangeshodnotu .

Existující dataRowState	Hodnoty za `Load` metodou a akcí události
Přidáno	Current = <Existing> Původní = <Příchozí> Stav = <Změněno> AkceŘádku = ZměnitPůvodní
Upraveno	Current = <Existing> Původní = <Příchozí> Stav = <Změněno> AkceŘádku = ZměnitPůvodní
Odstraněné	Aktuální = <Není k dispozici> Původní = <Příchozí> Stav = <Odstraněno> AkceŘádku = ZměnitPůvodní
Nezměněn	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní
(Není k dispozici)	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní

Hodnoty v objektu DataColumn lze omezit pomocí vlastností, jako ReadOnly jsou a AutoIncrement. Metoda Load zpracovává tyto sloupce způsobem, který je konzistentní s chováním definovaným vlastnostmi sloupce. Omezení jen pro čtení se vztahuje pouze na DataColumn změny, ke kterým dojde v paměti. Metoda Load v případě potřeby přepíše hodnoty sloupců jen pro čtení.

Pokud chcete zjistit, jakou verzi pole primárního klíče použít pro porovnání aktuálního řádku s příchozím řádkem, Load použije metoda původní verzi hodnoty primárního klíče v řádku, pokud existuje. V opačném Load případě metoda použije aktuální verzi pole primárního klíče.

Viz také

Platí pro

Load(IDataReader, LoadOption)

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

DataTable Vyplní hodnotu hodnotami ze zdroje dat pomocí zadané IDataReaderhodnoty . DataTable Pokud již obsahuje řádky, jsou příchozí data ze zdroje dat sloučena s existujícími řádky podle hodnoty parametruloadOption.

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)

Parametry

reader: IDataReader

Objekt IDataReader , který poskytuje jednu nebo více sad výsledků.

loadOption: LoadOption

Hodnota z výčtu LoadOption , která označuje, jak jsou řádky již v objektu DataTable kombinovány s příchozími řádky, které sdílejí stejný primární klíč.

Příklady

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

Poznámky

Metoda Load využívá první sadu výsledků z načtené IDataReadersady a po úspěšném dokončení nastaví pozici čtenáře na další sadu výsledků, pokud existuje. Při převodu Load dat metoda používá stejná pravidla převodu Fill jako metoda.

Metoda Load musí brát v úvahu tři konkrétní problémy při načítání dat z IDataReader instance: schéma, data a operace událostí. Při práci se schématem může metoda narazit na Load podmínky popsané v následující tabulce. Operace schématu probíhají pro všechny importované sady výsledků, a to i pro ty, které neobsahují žádná data.

Podmínka	Chování
Nemá DataTable žádné schéma.	Metoda `Load` odvodí schéma na základě sady výsledků z importovaného IDataReaderobjektu .
Má DataTable schéma, ale není kompatibilní s načteným schématem.	Metoda `Load` vyvolá výjimku odpovídající konkrétní chybě, ke které dochází při pokusu o načtení dat do nekompatibilního schématu.
Schémata jsou kompatibilní, ale načtené schéma sady výsledků obsahuje sloupce, které v objektu `DataTable`neexistují.	Metoda `Load` přidá další sloupce do `DataTable`schématu . Metoda vyvolá výjimku, pokud odpovídající sloupce v DataTable a načtené sadě výsledků nejsou kompatibilní s hodnotou. Metoda také načte informace o omezení ze sady výsledků pro všechny přidané sloupce. S výjimkou případu omezení primárního klíče se tyto informace o omezení použijí pouze v případě, že aktuální DataTable neobsahuje žádné sloupce na začátku operace načítání.
Schémata jsou kompatibilní, ale načtené schéma sady výsledků obsahuje méně sloupců než `DataTable`.	Pokud má chybějící sloupec definovanou výchozí hodnotu nebo datový typ sloupce má hodnotu null, `Load` metoda umožňuje přidat řádky a nahradit chybějícím sloupcem výchozí nebo nulovou hodnotu. Pokud nelze použít žádnou výchozí hodnotu nebo hodnotu null, `Load` vyvolá metoda výjimku. Pokud nebyla zadána žádná konkrétní výchozí hodnota, `Load` metoda použije hodnotu null jako implicitní výchozí hodnotu.

V tomto volání metody má zadaný LoadOption parametr vliv na zpracování příchozích dat. Jak by měla metoda Load zpracovávat načítání řádků, které mají stejný primární klíč jako existující řádky? Má se změnit aktuální hodnoty, původní hodnoty nebo obojí? Tyto a další problémy jsou řízeny parametrem loadOption .

Pokud existující řádek a příchozí řádek obsahují odpovídající hodnoty primárního klíče, je řádek zpracován pomocí aktuální hodnoty stavu řádku, jinak se považuje za nový řádek.

Pokud jde o operace událostí, RowChanging událost nastane před změnou každého řádku a RowChanged událost nastane po změně každého řádku. V každém případě Action vlastnost DataRowChangeEventArgs instance předaná obslužné rutině události obsahuje informace o konkrétní akci přidružené k události. Tato hodnota akce se liší v závislosti na stavu řádku před operací načtení. V každém případě dojde k oběma událostem a akce je pro každou z nich stejná. Akce se může v závislosti na aktuálním stavu řádku použít buď na aktuální nebo původní verzi každého řádku, nebo na obě.

Následující tabulka zobrazuje chování metody Load při zavolání s každou z LoadOption hodnot a také ukazuje, jak hodnoty interagují se stavem řádku pro řádek, který se načítá. Poslední řádek (označený "(Není)) popisuje chování příchozích řádků, které neodpovídají žádnému existujícímu řádku. Každá buňka v této tabulce popisuje aktuální a původní hodnotu pole na řádku spolu s DataRowState hodnotou pro hodnotu po Load dokončení metody.

Existující dataRowState	Upsert	OverwriteChanges	PreserveChanges (výchozí chování)
Přidáno	Current = <Incoming> Původní = -<Není k dispozici> State = <Added> AkceŘádku = Změnit	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Existing> Původní = <Příchozí> Stav = <Změněno> AkceŘádku = ZměnitPůvodní
Upraveno	Current = <Incoming> Původní = <existující> Stav = <Změněno> AkceŘádku = Změnit	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Existing> Původní = <Příchozí> Stav = <Změněno> RowAction =ChangeOriginal
Odstraněné	(Načtení nemá vliv na odstraněné řádky.) Current = --- Původní = <existující> Stav = <Odstraněno> (Přidá se nový řádek s následujícími charakteristikami.) Current = <Incoming> Původní = <Není k dispozici> State = <Added> AkceŘádku = Přidat	Zpět odstranění a Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Aktuální = <Není k dispozici> Původní = <Příchozí> Stav = <Odstraněno> AkceŘádku = ZměnitPůvodní
Nezměněn	Current = <Incoming> Původní = <existující> Pokud je nová hodnota stejná jako stávající hodnota, pak Stav = <Beze změny> RowAction = Nothing Jiného Stav = <Změněno> AkceŘádku = Změnit	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní
Není k dispozici)	Current = <Incoming> Původní = <Není k dispozici> State = <Added> AkceŘádku = Přidat	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní

Pokud při volání Load metody zadáte možnosti OverwriteChanges nebo PreserveChanges, předpokládá se, že příchozí data pocházejí z DataTableprimárního zdroje dat a tabulka DataTable sleduje změny a může změny šířit zpět do zdroje dat. Pokud vyberete možnost Upsert, předpokládá se, že data pocházejí ze sekundárního zdroje dat, jako jsou data poskytovaná komponentou střední vrstvy, možná změněná uživatelem. V tomto případě se předpokládá, že záměrem je agregovat data z jednoho nebo více zdrojů dat v DataTablesouboru a pak je třeba rozšířit zpět do primárního zdroje dat. Parametr LoadOption se používá k určení konkrétní verze řádku, který se má použít pro porovnání primárního klíče. Podrobnosti najdete v následující tabulce.

Možnost načtení	Verze DataRow použitá pro porovnání primárního klíče
`OverwriteChanges`	Původní verze, pokud existuje, jinak aktuální verze
`PreserveChanges`	Původní verze, pokud existuje, jinak aktuální verze
`Upsert`	Aktuální verze, pokud existuje, jinak původní verze

Viz také

Platí pro

Load(IDataReader, LoadOption, FillErrorEventHandler)

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

DataTable Vyplní hodnoty ze zdroje dat pomocí zadaného IDataReader delegáta zpracování chyb.

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)

Parametry

reader: IDataReader

A IDataReader , který poskytuje sadu výsledků.

loadOption: LoadOption

Hodnota z výčtu LoadOption , která označuje, jak jsou řádky již v objektu DataTable kombinovány s příchozími řádky, které sdílejí stejný primární klíč.

errorHandler: FillErrorEventHandler

Delegát, FillErrorEventHandler který se má volat, když při načítání dat dojde k chybě.

Příklady

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

Poznámky

Podmínka	Chování
Nemá DataTable žádné schéma.	Metoda `Load` odvodí schéma na základě sady výsledků z importovaného IDataReaderobjektu .
Má DataTable schéma, ale není kompatibilní s načteným schématem.	Metoda `Load` vyvolá výjimku odpovídající konkrétní chybě, ke které dochází při pokusu o načtení dat do nekompatibilního schématu.
Schémata jsou kompatibilní, ale načtené schéma sady výsledků obsahuje sloupce, které v objektu `DataTable`neexistují.	Metoda `Load` přidá další sloupce do `DataTable`schématu . Metoda vyvolá výjimku, pokud odpovídající sloupce v DataTable a načtené sadě výsledků nejsou kompatibilní s hodnotou. Metoda také načte informace o omezení ze sady výsledků pro všechny přidané sloupce. S výjimkou případu omezení primárního klíče se tyto informace o omezení použijí pouze v případě, že aktuální DataTable neobsahuje žádné sloupce na začátku operace načítání.
Schémata jsou kompatibilní, ale načtené schéma sady výsledků obsahuje méně sloupců než `DataTable`.	Pokud má chybějící sloupec definovanou výchozí hodnotu nebo datový typ sloupce má hodnotu null, `Load` metoda umožňuje přidat řádky a nahradit chybějícím sloupcem výchozí nebo nulovou hodnotu. Pokud nelze použít žádnou výchozí hodnotu nebo hodnotu null, `Load` vyvolá metoda výjimku. Pokud nebyla zadána žádná konkrétní výchozí hodnota, `Load` metoda použije hodnotu null jako implicitní výchozí hodnotu.

Pokud jde o operace událostí, RowChanging událost nastane před změnou každého řádku a RowChanged událost nastane po změně každého řádku. V každém případě Action vlastnost DataRowChangeEventArgs instance předaná obslužné rutině události obsahuje informace o konkrétní akci přidružené k události. Tato hodnota akce se liší v závislosti na stavu řádku před operací načtení. V každém případě dojde k oběma událostem a akce je pro každou z nich stejná. Akce se může v závislosti na aktuálním stavu řádku použít buď na aktuální nebo původní verzi každého řádku, nebo na obě.

Existující dataRowState	Upsert	OverwriteChanges	PreserveChanges (výchozí chování)
Přidáno	Current = <Incoming> Původní = -<Není k dispozici> State = <Added> AkceŘádku = Změnit	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Existing> Původní = <Příchozí> Stav = <Změněno> AkceŘádku = ZměnitPůvodní
Upraveno	Current = <Incoming> Původní = <existující> Stav = <Změněno> AkceŘádku = Změnit	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Existing> Původní = <Příchozí> Stav = <Změněno> RowAction =ChangeOriginal
Eleted	(Načtení nemá vliv na odstraněné řádky.) Current = --- Původní = <existující> Stav = <Odstraněno> (Přidá se nový řádek s následujícími charakteristikami.) Current = <Incoming> Původní = <Není k dispozici> State = <Added> AkceŘádku = Přidat	Zpět odstranění a Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Aktuální = <Není k dispozici> Původní = <Příchozí> Stav = <Odstraněno> AkceŘádku = ZměnitPůvodní
Nezměněn	Current = <Incoming> Původní = <existující> Pokud je nová hodnota stejná jako stávající hodnota, pak Stav = <Beze změny> RowAction = Nothing Jiného Stav = <Změněno> AkceŘádku = Změnit	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní
Není k dispozici)	Current = <Incoming> Původní = <Není k dispozici> State = <Added> AkceŘádku = Přidat	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní	Current = <Incoming> Původní = <Příchozí> Stav = <Beze změny> AkceŘádku = ZměnitAktuálníAPůvodní

Možnost načtení	Verze DataRow použitá pro porovnání primárního klíče
`OverwriteChanges`	Původní verze, pokud existuje, jinak aktuální verze
`PreserveChanges`	Původní verze, pokud existuje, jinak aktuální verze
`Upsert`	Aktuální verze, pokud existuje, jinak původní verze

Parametr errorHandler je FillErrorEventHandler delegát, který odkazuje na proceduru, která se volá, když při načítání dat dojde k chybě. Parametr FillErrorEventArgs předaný do procedury poskytuje vlastnosti, které umožňují načíst informace o chybě, ke které došlo, aktuálním řádku dat a DataTable vyplňování. Použití tohoto mechanismu delegáta místo jednoduššího bloku try/catch umožňuje určit chybu, zpracovat situaci a pokračovat ve zpracování, pokud chcete. Parametr FillErrorEventArgs poskytuje Continue vlastnost: Nastavte tuto vlastnost na hodnotu true , která označuje, že jste chybu zvládli a chcete pokračovat ve zpracování. Nastavte vlastnost na hodnotu false , která označuje, že chcete zastavit zpracování. Mějte na paměti, že nastavení vlastnosti na false způsobí, že kód, který problém aktivoval, vyvolá výjimku.

Viz také

Platí pro

DataTable.Load Metoda

Definice

Přetížení

Příklady

Poznámky

Load(IDataReader)

Parametry

Příklady

Poznámky

Viz také

Platí pro

Load(IDataReader, LoadOption)

Parametry

Příklady

Poznámky

Viz také

Platí pro

Load(IDataReader, LoadOption, FillErrorEventHandler)

Parametry

Příklady

Poznámky

Viz také

Platí pro

Váš názor

Další materiály