DataTable.Load Metoda

Definice

Obor názvů:: System.Data

Sestavení:: netstandard.dll, System.Data.Common.dll

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í hodnoty ze zdroje dat pomocí zadaného IDataReaderobjektu . DataTable Pokud už řádky obsahují, příchozí data ze zdroje dat se sloučí s existujícími řádky.

Přetížení

Name	Description
Load(IDataReader)	DataTable Vyplní hodnoty ze zdroje dat pomocí zadaného IDataReaderobjektu . DataTable Pokud už řádky obsahují, příchozí data ze zdroje dat se sloučí s existujícími řádky.
Load(IDataReader, LoadOption)	DataTable Vyplní hodnoty ze zdroje dat pomocí zadaného IDataReaderobjektu . `DataTable` Pokud už řádky obsahují, příchozí data ze zdroje dat se sloučí 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. Nejprve se příklad zaměřuje na problémy se schématem, včetně odvození schématu z načteného IDataReadersouboru a 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í Load. Další příklady, které mohou být k dispozici, najdete v jednotlivých tématech přetížení.

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é jsou zaměřené na získávání dat ze zadaného zdroje dat a jejich přidání do aktuálního kontejneru dat (v tomto případě a DataTable). Tyto scénáře popisují standardní použití , DataTablepopisující jeho chování při aktualizaci a sloučení.

Synchronizuje DataTable nebo aktualizuje s jedním primárním zdrojem dat. Sleduje DataTable změny, což umožňuje synchronizaci s primárním zdrojem dat. Kromě toho DataTable může přijímat 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.

Vzhledem k těmto dvěma hypotetickým zdrojům dat bude uživatel pravděpodobně vyžadovat jedno z následujících chování:

Inicializace DataTable 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 chce uživatel rozšířit změny zpět do primárního zdroje dat.
Zachovat změny a znovu synchronizovat z primárního zdroje dat. V tomto scénáři chce uživatel převzít DataTable vyplněný předchozí scénář a provést přírůstkovou synchronizaci s primárním zdrojem dat a zachovat změny provedené v souboru DataTable.
Přírůstkový datový kanál 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 tyto změny rozšířit zpět do primárního zdroje dat.

Tato Load metoda umožňuje všechny tyto scénáře. Všechna ale jedna z přetížení pro tuto metodu umožňuje zadat parametr možnosti načtení, který označuje, jak řádky již v DataTable kombinaci s řádky, které se načítají. (Přetížení, které neumožňuje určit 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. V každém případě popis označuje chování, když primární klíč řádku v příchozích datech odpovídá primárnímu klíči existujícího řádku.

Možnost načtení	Description
`PreserveChanges` (výchozí)	Aktualizuje původní verzi řádku hodnotou příchozího řádku.
`OverwriteChanges`	Aktualizuje aktuální a původní verze řádku hodnotou příchozího řádku.
`Upsert`	Aktualizuje aktuální verzi řádku hodnotou příchozího řádku.

Obecně platí, že PreserveChanges možnosti a OverwriteChanges možnosti jsou určené pro scénáře, ve kterých musí uživatel synchronizovat DataSet změny a změny s primárním zdrojem dat. Možnost Upsert 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

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

DataTable Vyplní hodnoty ze zdroje dat pomocí zadaného IDataReaderobjektu . DataTable Pokud už řádky obsahují, příchozí data ze zdroje dat se sloučí s existujícími řádky.

public:
 void Load(System::Data::IDataReader ^ reader);

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Members from types used in the expression column to be trimmed if not referenced directly.")]
public void Load(System.Data.IDataReader reader);

public void Load(System.Data.IDataReader reader);

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Members from types used in the expression column to be trimmed if not referenced directly.")>]
member this.Load : System.Data.IDataReader -> unit

member this.Load : System.Data.IDataReader -> unit

Public Sub Load (reader As IDataReader)

Parametry

reader: IDataReader

Sada IDataReader výsledků poskytuje sadu výsledků.

Atributy: RequiresUnreferencedCodeAttribute

Příklady

Následující příklad ukazuje několik problémů souvisejících s voláním Load metody. Nejprve se příklad zaměřuje na problémy se schématem, včetně odvození schématu z načteného IDataReadersouboru a 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 , 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ů načtené IDataReadera po úspěšném dokončení nastaví pozici čtenáře na další sadu výsledků, pokud existuje. Při převodu Load dat používá metoda stejná pravidla převodu DbDataAdapter.Fill jako metoda.

Metoda Load musí vzít v úvahu tři konkrétní problémy při načítání dat z IDataReader instance: schématu, dat a operací událostí. Při práci se schématem Load může metoda narazit na 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 importu IDataReader.
Schéma DataTable má, 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á sada 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žívají pouze v případě, že aktuální DataTable sloupec na začátku operace načítání neobsahuje žádné sloupce.
Schémata jsou kompatibilní, ale schéma načtené sady výsledků obsahuje méně sloupců, než je tomu u schématu `DataTable`.	Pokud chybějící sloupec má definovanou výchozí hodnotu nebo datový typ sloupce má hodnotu null, Load metoda umožňuje přidat řádky, nahradit výchozí hodnotu nebo `null` hodnotu chybějícího sloupce. Pokud žádná výchozí hodnota nebo `null` nelze použít, vyvolá `Load` metoda výjimku. Pokud nebyla zadána žádná konkrétní výchozí hodnota, `Load` metoda použije `null` hodnotu jako implicitní výchozí hodnotu.

Než začnete zvažovat chování metody z hlediska datových Load operací, vezměte v úvahu, že každý řádek v rámci DataTable sloupce udržuje aktuální i původní hodnotu. Tyto hodnoty můžou být ekvivalentní nebo se mohou lišit, pokud se data v řádku od vyplnění DataTablezměnila . Další informace naleznete v tématu Stavy řádků a verze řádků.

Tato verze Load metody se pokusí zachovat aktuální hodnoty v každém řádku, takže původní hodnota zůstane nedotčená. (Pokud chcete jemně řídit chování příchozích dat, přečtěte si článek DataTable.Load.) Pokud existující řádek a příchozí řádek obsahují odpovídající hodnoty primárního klíče, řádek se zpracuje pomocí aktuální hodnoty stavu řádku, jinak se považuje za nový řádek.

Pokud jde o operace událostí, RowChanging nastane událost 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ě dochází k oběma událostem a akce je pro každou z nich stejná. Akce se může použít na aktuální nebo původní verzi každého řádku nebo obojího v závislosti na aktuálním stavu řádku.

Následující tabulka zobrazuje chování metody Load . Poslední řádek (označený jako "(Není k dispozici)") 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 v řádku spolu s DataRowState hodnotou po Load dokončení metody. V tomto případě metoda neumožňuje indikovat možnost načtení a používá výchozí hodnotu PreserveChanges.

Existující dataRowState	Hodnoty po `Load` metodě a akci události
Přidáno	Current = <Existing> Original = <Incoming> State = <Modified> RowAction = ChangeOriginal
Změněno	Current = <Existing> Original = <Incoming> State = <Modified> RowAction = ChangeOriginal
Odstraněno	Current = <Není k dispozici> Original = <Incoming> State = <Deleted> RowAction = ChangeOriginal
Nezměněný	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal
(Není k dispozici)	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal

Hodnoty v objektu DataColumn mohou být omezeny použitím vlastností, jako ReadOnly AutoIncrementjsou a . Metoda Load zpracovává tyto sloupce způsobem, který je konzistentní s chováním definovaným vlastnostmi sloupce. Omezení jen pro čtení je DataColumn použitelné pouze pro změny, ke kterým dochází v paměti. Metoda Load v případě potřeby přepíše hodnoty sloupce jen pro čtení.

K určení verze pole primárního klíče, které se má použít pro porovnání aktuálního řádku s příchozím řádkem, Load metoda používá původní verzi hodnoty primárního klíče v řádku, pokud existuje. V opačném případě metoda Load používá 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

Zdroj:: DataTable.cs

Zdroj:: DataTable.cs

DataTable Vyplní hodnoty ze zdroje dat pomocí zadaného IDataReaderobjektu . DataTable Pokud už řádky obsahují, příchozí data ze zdroje dat se sloučí s existujícími řádky podle hodnoty parametruloadOption.

public:
 void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption);

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Using LoadOption may cause members from types used in the expression column to be trimmed if not referenced directly.")]
public void Load(System.Data.IDataReader reader, System.Data.LoadOption loadOption);

public void Load(System.Data.IDataReader reader, System.Data.LoadOption loadOption);

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Using LoadOption may cause members from types used in the expression column to be trimmed if not referenced directly.")>]
member this.Load : System.Data.IDataReader * System.Data.LoadOption -> unit

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

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

Parametry

reader: IDataReader

Poskytuje IDataReader jednu nebo více sad výsledků.

loadOption: LoadOption

Hodnota z výčtu LoadOption , která označuje, jak se řádky v dané DataTable oblasti kombinují s příchozími řádky, které sdílejí stejný primární klíč.

Atributy: RequiresUnreferencedCodeAttribute

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ů načtené IDataReadera po úspěšném dokončení nastaví pozici čtenáře na další sadu výsledků, pokud existuje. Při převodu Load dat používá metoda stejná pravidla převodu Fill jako metoda.

Metoda Load musí vzít v úvahu tři konkrétní problémy při načítání dat z IDataReader instance: schématu, dat a operací událostí. Při práci se schématem Load může metoda narazit na 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 importu IDataReader.
Schéma DataTable má, 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 schéma načtené 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á sada 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žívají pouze v případě, že aktuální DataTable sloupec na začátku operace načítání neobsahuje žádné sloupce.
Schémata jsou kompatibilní, ale schéma načtené sady výsledků obsahuje méně sloupců, než je tomu u schématu `DataTable`.	Pokud chybějící sloupec má definovanou výchozí hodnotu nebo datový typ sloupce má hodnotu null, `Load` metoda umožňuje přidat řádky, nahradit výchozí nebo nulovou hodnotu chybějícího sloupce. 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 zadaný LoadOption parametr ovlivňuje zpracování příchozích dat. Jak by metoda Load zpracovávala načítání řádků, které mají stejný primární klíč jako existující řádky? Má upravit aktuální hodnoty, původní hodnoty nebo obojí? Tyto problémy 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, řádek se zpracuje pomocí aktuální hodnoty stavu řádku, jinak se považuje za nový řádek.

Pokud jde o operace událostí, RowChanging nastane událost 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ě dochází k oběma událostem a akce je pro každou z nich stejná. Akce se může použít na aktuální nebo původní verzi každého řádku nebo obojího v závislosti na aktuálním stavu řádku.

Následující tabulka zobrazuje chování metody Load při zavolání s jednotlivými LoadOption hodnotami a také ukazuje, jak hodnoty interagují se stavem řádku pro načtený řádek. Poslední řádek (označený jako "(Není k dispozici)") 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 v řádku spolu s DataRowState hodnotou po Load dokončení metody.

Existující dataRowState	Upsert	PřepsáníChanges	PreserveChanges (výchozí chování)
Přidáno	Current = <Incoming> Original = -<Not available> State = <Added> RowAction = Změnit	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> State = <Modified> RowAction = ChangeOriginal
Změněno	Current = <Incoming> Original = <Existing> State = <Modified> RowAction = Změnit	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> State = <Modified> RowAction =ChangeOriginal
Odstraněno	(Načtení nemá vliv na odstraněné řádky) Current = --- Original = <Existing> State = <Deleted> (Nový řádek se přidá s následujícími charakteristikami) Current = <Incoming> Původní = <Není k dispozici> State = <Added> RowAction = Přidat	Zpět odstranění a odstranění Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Není k dispozici> Original = <Incoming> State = <Deleted> RowAction = ChangeOriginal
Nezměněný	Current = <Incoming> Original = <Existing> Pokud je nová hodnota stejná jako existující hodnota, State = <beze změny> RowAction = Nothing Jiného State = <Modified> RowAction = Změnit	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal
Není k dispozici)	Current = <Incoming> Původní = <Není k dispozici> State = <Added> RowAction = Přidat	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal

Pokud při volání Load metody zadáte možnosti OverwriteChanges nebo PreserveChanges, pak se předpokládá, že příchozí data pocházejí z DataTableprimárního zdroje dat a DataTable sleduje změny a může změny rozšířit zpět do zdroje dat. Pokud vyberete možnost Upsert, předpokládá se, že data pocházejí z jednoho 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ě předpokládáme, že záměrem je agregovat data z jednoho nebo více zdrojů dat v objektu DataTablea pak je možná rozšířit zpět do primárního zdroje dat. Parametr LoadOption slouží 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í	Porovnání primárních klíčů se používá verze DataRow
`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

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Using LoadOption may cause members from types used in the expression column to be trimmed if not referenced directly.")]
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);

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Using LoadOption may cause members from types used in the expression column to be trimmed if not referenced directly.")>]
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

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 se řádky v dané DataTable oblasti kombinují s příchozími řádky, které sdílejí stejný primární klíč.

errorHandler: FillErrorEventHandler

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

Atributy: RequiresUnreferencedCodeAttribute

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 importu IDataReader.
Schéma DataTable má, 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 schéma načtené 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á sada 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žívají pouze v případě, že aktuální DataTable sloupec na začátku operace načítání neobsahuje žádné sloupce.
Schémata jsou kompatibilní, ale schéma načtené sady výsledků obsahuje méně sloupců, než je tomu u schématu `DataTable`.	Pokud chybějící sloupec má definovanou výchozí hodnotu nebo datový typ sloupce má hodnotu null, `Load` metoda umožňuje přidat řádky, nahradit výchozí nebo nulovou hodnotu chybějícího sloupce. 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 nastane událost 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ě dochází k oběma událostem a akce je pro každou z nich stejná. Akce se může použít na aktuální nebo původní verzi každého řádku nebo obojího v závislosti na aktuálním stavu řádku.

Existující dataRowState	Upsert	PřepsáníChanges	PreserveChanges (výchozí chování)
Přidáno	Current = <Incoming> Original = -<Not available> State = <Added> RowAction = Změnit	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> State = <Modified> RowAction = ChangeOriginal
Změněno	Current = <Incoming> Original = <Existing> State = <Modified> RowAction = Změnit	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> State = <Modified> RowAction =ChangeOriginal
eleted	(Načtení nemá vliv na odstraněné řádky) Current = --- Original = <Existing> State = <Deleted> (Nový řádek se přidá s následujícími charakteristikami) Current = <Incoming> Původní = <Není k dispozici> State = <Added> RowAction = Přidat	Zpět odstranění a odstranění Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Není k dispozici> Original = <Incoming> State = <Deleted> RowAction = ChangeOriginal
Nezměněný	Current = <Incoming> Original = <Existing> Pokud je nová hodnota stejná jako existující hodnota, State = <beze změny> RowAction = Nothing Jiného State = <Modified> RowAction = Změnit	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal
Není k dispozici)	Current = <Incoming> Původní = <Není k dispozici> State = <Added> RowAction = Přidat	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> State = <beze změny> RowAction = ChangeCurrentAndOriginal

Možnost Načtení	Porovnání primárních klíčů se používá verze DataRow
`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ž dojde k chybě při načítání dat. Parametr FillErrorEventArgs předaný postupu poskytuje vlastnosti, které umožňují načíst informace o chybě, ke které došlo, aktuálním řádku dat a DataTable vyplně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 tak, aby true indikovala, že jste chybu zpracovali a chcete pokračovat ve zpracování. Nastavte vlastnost tak, aby false označila, že chcete zastavit zpracování. Mějte na paměti, že nastavení vlastnosti způsobí false , že kód, který problém aktivoval vyvolá výjimku.

Viz také

Platí pro

Váš názor

Byla tato stránka užitečná?

Sdílet prostřednictvím

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