DataTable.Load Metoda

Definicja

Wypełnia DataTable wartości wartościami ze źródła danych przy użyciu dostarczonego elementu IDataReader .Fills a DataTable with values from a data source using the supplied IDataReader. Jeśli DataTable zawiera już wiersze, dane przychodzące ze źródła danych zostaną scalone z istniejącymi wierszami.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

Przeciążenia

Load(IDataReader)

Wypełnia DataTable wartości wartościami ze źródła danych przy użyciu dostarczonego elementu IDataReader .Fills a DataTable with values from a data source using the supplied IDataReader. Jeśli DataTable zawiera już wiersze, dane przychodzące ze źródła danych zostaną scalone z istniejącymi wierszami.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

Load(IDataReader, LoadOption)

Wypełnia DataTable wartości wartościami ze źródła danych przy użyciu dostarczonego elementu IDataReader .Fills a DataTable with values from a data source using the supplied IDataReader. Jeśli DataTable zawiera już wiersze, dane przychodzące ze źródła danych zostaną scalone z istniejącymi wierszami zgodnie z wartością loadOption parametru.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows according to the value of the loadOption parameter.

Load(IDataReader, LoadOption, FillErrorEventHandler)

Wypełnia DataTable wartości wartościami ze źródła danych za pomocą podanego IDataReader delegata obsługi błędu.Fills a DataTable with values from a data source using the supplied IDataReader using an error-handling delegate.

Przykłady

Poniższy przykład ilustruje kilka problemów związanych z wywołaniem Load metody.The following example demonstrates several of the issues involved with calling the Load method. Pierwszy przykład koncentruje się na problemach ze schematami, w tym wnioskowanie schematu z załadowanego IDataReader , a następnie obsługę niezgodnych schematów i schematów z brakującymi lub dodatkowymi kolumnami.First, the example focuses on schema issues, including inferring a schema from the loaded IDataReader, and then handling incompatible schemas, and schemas with missing or additional columns. Przykład koncentruje się na problemach z danymi, w tym obsługi różnych opcji ładowania.The example then focuses on data issues, including handling the various loading options.

Uwaga

Ten przykład pokazuje, jak używać jednej ze przeciążonych wersji programu Load .This example shows how to use one of the overloaded versions of Load. Inne przykłady, które mogą być dostępne, można znaleźć w tematach dotyczących poszczególnych przeciążeń.For other examples that might be available, see the individual overload topics.

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

Uwagi

LoadMetoda może być używana w kilku typowych scenariuszach, w których wszystkie wyśrodkowane są pobieranie danych z określonego źródła danych i dodawanie ich do bieżącego kontenera danych (w tym przypadku DataTable ).The Load method can be used in several common scenarios, all centered around getting data from a specified data source and adding it to the current data container (in this case, a DataTable). W tych scenariuszach opisano standardowe użycie programu DataTable , opisujące jego zachowanie aktualizacji i scalania.These scenarios describe standard usage for a DataTable, describing its update and merge behavior.

DataTableSynchronizuje lub aktualizuje z jednym podstawowym źródłem danych.A DataTable synchronizes or updates with a single primary data source. DataTableŚcieżki są zmieniane, co pozwala na synchronizację z podstawowym źródłem danych.The DataTable tracks changes, allowing synchronization with the primary data source. Ponadto program DataTable może akceptować dane przyrostowe z jednego lub większej liczby pomocniczych źródeł danych.In addition, a DataTable can accept incremental data from one or more secondary data sources. DataTableNie odpowiada za śledzenie zmian w celu umożliwienia synchronizacji z pomocniczym źródłem danych.The DataTable isn't responsible for tracking changes in order to allow synchronization with the secondary data source.

Mając te dwa hipotetyczne źródła danych, użytkownik może wymagać jednego z następujących zachowań:Given these two hypothetical data sources, a user is likely to require one of the following behaviors:

  • Zainicjuj DataTable z podstawowego źródła danych.Initialize DataTable from a primary data source. W tym scenariuszu użytkownik chce zainicjować pustą wartość z DataTable poziomu podstawowego źródła danych.In this scenario, the user wants to initialize an empty DataTable with values from the primary data source. Później użytkownik zamierza propagować zmiany z powrotem do podstawowego źródła danych.Later the user intends to propagate changes back to the primary data source.

  • Zachowaj zmiany i zsynchronizuj je ponownie z podstawowym źródłem danych.Preserve changes and re-synchronize from the primary data source. W tym scenariuszu użytkownik chce wykonać DataTable wypełnienie w poprzednim scenariuszu i przeprowadzić synchronizację przyrostową z podstawowym źródłem danych, zachowując modyfikacje wprowadzone w DataTable .In this scenario, the user wants to take the DataTable filled in the previous scenario and perform an incremental synchronization with the primary data source, preserving modifications made in the DataTable.

  • Przyrostowe źródło danych z pomocniczych źródeł danych.Incremental data feed from secondary data sources. W tym scenariuszu użytkownik chce scalić zmiany z jednego lub kilku dodatkowych źródeł danych i propagować te zmiany z powrotem do podstawowego źródła danych.In this scenario, the user wants to merge changes from one or more secondary data sources, and propagate those changes back to the primary data source.

LoadMetoda wykonuje wszystkie te scenariusze.The Load method makes all these scenarios possible. Wszystkie, ale jedno z przeciążeń dla tej metody pozwala określić parametr opcji ładowania, wskazujący sposób, w jaki wiersze już DataTable łączą się z ładowanymi wierszami.All but one of the overloads for this method allows you to specify a load option parameter, indicating how rows already in a DataTable combine with rows being loaded. (Przeciążenie, które nie pozwala na określenie zachowania, używa opcji ładowania domyślnego). W poniższej tabeli opisano trzy opcje ładowania dostarczone przez LoadOption Wyliczenie.(The overload that doesn't allow you to specify the behavior uses the default load option.) The following table describes the three load options provided by the LoadOption enumeration. W każdym przypadku opis wskazuje zachowanie, gdy klucz podstawowy wiersza w danych przychodzących jest zgodny z kluczem podstawowym istniejącego wiersza.In each case, the description indicates the behavior when the primary key of a row in the incoming data matches the primary key of an existing row.

Opcja ładowaniaLoad Option OpisDescription
PreserveChanges wartooćPreserveChanges (default) Aktualizuje oryginalną wersję wiersza za pomocą wartości wiersza przychodzącego.Updates the original version of the row with the value of the incoming row.
OverwriteChanges Aktualizuje bieżące i oryginalne wersje wiersza za pomocą wartości wiersza przychodzącego.Updates the current and original versions of the row with the value of the incoming row.
Upsert Aktualizuje bieżącą wersję wiersza za pomocą wartości wiersza przychodzącego.Updates the current version of the row with the value of the incoming row.

Ogólnie rzecz biorąc, PreserveChanges OverwriteChanges Opcje i są przeznaczone dla scenariuszy, w których użytkownik musi zsynchronizować te DataSet zmiany z podstawowym źródłem danych.In general, the PreserveChanges and OverwriteChanges options are intended for scenarios in which the user needs to synchronize the DataSet and its changes with the primary data source. UpsertOpcja ułatwia agregowanie zmian z jednego lub większej liczby pomocniczych źródeł danych.The Upsert option facilitates aggregating changes from one or more secondary data sources.

Load(IDataReader)

Wypełnia DataTable wartości wartościami ze źródła danych przy użyciu dostarczonego elementu IDataReader .Fills a DataTable with values from a data source using the supplied IDataReader. Jeśli DataTable zawiera już wiersze, dane przychodzące ze źródła danych zostaną scalone z istniejącymi wierszami.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

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

IDataReaderZawiera zestaw wyników.An IDataReader that provides a result set.

Przykłady

Poniższy przykład ilustruje kilka problemów związanych z wywołaniem Load metody.The following example demonstrates several of the issues involved with calling the Load method. Pierwszy przykład koncentruje się na problemach ze schematami, w tym wnioskowanie schematu z załadowanego IDataReader , a następnie obsługę niezgodnych schematów i schematów z brakującymi lub dodatkowymi kolumnami.First, the example focuses on schema issues, including inferring a schema from the loaded IDataReader, and then handling incompatible schemas, and schemas with missing or additional columns. Przykład następnie wywołuje Load metodę, wyświetlając dane zarówno przed, jak i po operacji ładowania.The example then calls the Load method, displaying the data both before and after the load operation.

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

Uwagi

LoadMetoda korzysta z pierwszego zestawu wyników z załadowanego IDataReader i po pomyślnym zakończeniu, ustawia pozycję czytnika do następnego zestawu wyników (jeśli istnieje).The Load method consumes the first result set from the loaded IDataReader, and after successful completion, sets the reader's position to the next result set, if any. Podczas konwertowania danych Load Metoda używa tych samych reguł konwersji co DbDataAdapter.Fill Metoda.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

LoadMetoda musi uwzględniać trzy określone problemy podczas ładowania danych z IDataReader wystąpienia: schemat, dane i operacje zdarzeń.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Podczas pracy ze schematem Load Metoda może napotkać warunki zgodnie z opisem w poniższej tabeli.When working with the schema, the Load method may encounter conditions as described in the following table. Operacje schematu są wykonywane dla wszystkich zaimportowanych zestawów wyników, nawet tych, które nie zawierają danych.The schema operations take place for all imported result sets, even those containing no data.

WarunekCondition ZachowanieBehavior
DataTableBrak schematu.The DataTable has no schema. LoadMetoda wnioskuje schemat na podstawie zestawu wyników zaimportowanego IDataReader .The Load method infers the schema based on the result set from the imported IDataReader.
DataTableZawiera schemat, ale jest niezgodny z załadowanym schematem.The DataTable has a schema, but it is incompatible with the loaded schema. LoadMetoda zgłasza wyjątek odpowiadający konkretnemu wystąpieniu błędu, który występuje podczas próby załadowania danych do niezgodnego schematu.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Schematy są zgodne, ale schemat zestawu wyników załadowanych zawiera kolumny, które nie znajdują się w DataTable .The schemas are compatible, but the loaded result set schema contains columns that do not exist in the DataTable. LoadMetoda dodaje dodatkowe kolumny do DataTable schematu.The Load method adds the extra columns to DataTable's schema. Metoda zgłasza wyjątek, jeśli odpowiednie kolumny w DataTable i załadowany zestaw wyników nie są zgodne z wartością.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Metoda pobiera również informacje o ograniczeniach z zestawu wyników dla wszystkich dodanych kolumn.The method also retrieves constraint information from the result set for all added columns. Z wyjątkiem ograniczenia PRIMARY KEY, te informacje ograniczenia są używane tylko wtedy, gdy bieżąca DataTable nie zawiera żadnych kolumn na początku operacji ładowania.Except for the case of Primary Key constraint, this constraint information is used only if the current DataTable does not contain any columns at the start of the load operation.
Schematy są zgodne, ale schemat zestawu wyników załadowanych zawiera mniej kolumn niż DataTable .The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Jeśli brakująca kolumna ma zdefiniowaną wartość domyślną lub typem danych kolumny jest nullable, Load Metoda zezwala na dodawanie wierszy, zastępując domyślną lub null wartość brakującej kolumny.If a missing column has a default value defined or the column's data type is nullable, the Load method allows the rows to be added, substituting the default or null value for the missing column. Jeśli nie zostanie użyta wartość domyślna lub nie null można jej użyć, Load Metoda zgłasza wyjątek.If no default value or null can be used, then the Load method throws an exception. Jeśli nie podano określonej wartości domyślnej, Load Metoda używa null wartości jako implikowanej wartości domyślnej.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Przed uwzględnieniem zachowania Load metody w zakresie operacji na danych, należy wziąć pod uwagę, że każdy wiersz w obrębie DataTable zachowuje zarówno bieżącą wartość, jak i oryginalną wartość dla każdej kolumny.Before considering the behavior of the Load method in terms of data operations, consider that each row within a DataTable maintains both the current value and the original value for each column. Te wartości mogą być równoważne lub mogą być różne, jeśli dane w wierszu zostały zmienione od wypełnienia DataTable .These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Aby uzyskać więcej informacji, zobacz sekcję Stany wiersza i wersje wierszy.For more information, see Row States and Row Versions.

Ta wersja Load metody próbuje zachować bieżące wartości w każdym wierszu, pozostawiając pierwotną wartość bez zmian.This version of the Load method attempts to preserve the current values in each row, leaving the original value intact. (Jeśli potrzebujesz bardziej precyzyjnej kontroli nad zachowaniem przychodzących danych, zobacz DataTable.Load .) Jeśli istniejący wiersz i przychodzący wiersz zawierają odpowiednie wartości klucza podstawowego, wiersz jest przetwarzany przy użyciu jego bieżącej wartości stanu wiersza, w przeciwnym razie jest traktowany jako nowy wiersz.(If you want finer control over the behavior of incoming data, see DataTable.Load.) If the existing row and the incoming row contain corresponding primary key values, the row is processed using its current row state value, otherwise it's treated as a new row.

W odniesieniu do operacji zdarzeń RowChanging zdarzenie występuje przed zmianą każdego wiersza, a RowChanged zdarzenie występuje po zmianie każdego wiersza.In terms of event operations, the RowChanging event occurs before each row is changed, and the RowChanged event occurs after each row has been changed. W każdym przypadku Action Właściwość DataRowChangeEventArgs wystąpienia przeniesiona do programu obsługi zdarzeń zawiera informacje o określonej akcji skojarzonej ze zdarzeniem.In each case, the Action property of the DataRowChangeEventArgs instance passed to the event handler contains information about the particular action associated with the event. Ta wartość akcji zależy od stanu wiersza przed operacją ładowania.This action value depends on the state of the row before the load operation. W każdym przypadku występują oba zdarzenia, a akcja jest taka sama dla każdego z nich.In each case, both events occur, and the action is the same for each. Akcja może zostać zastosowana do bieżącej lub oryginalnej wersji każdego wiersza lub obu wierszy, w zależności od bieżącego stanu wiersza.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

W poniższej tabeli przedstawiono zachowanie Load metody.The following table displays behavior for the Load method. Ostatni wiersz (oznaczony etykietą "(nieobecny)") opisuje zachowanie przychodzące wierszy, które nie są zgodne z żadnym istniejącym wierszem.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Każda komórka w tej tabeli opisuje bieżącą i oryginalną wartość pola w wierszu, wraz z DataRowState wartością dla wartości po Load zakończeniu metody.Each cell in this table describes the current and original value for a field within a row, along with the DataRowState for the value after the Load method has completed. W takim przypadku metoda nie pozwala wskazać opcji ładowania i używa domyślnych, PreserveChanges .In this case, the method doesn't allow you to indicate the load option, and uses the default, PreserveChanges.

Istniejące DataRowStateExisting DataRowState Wartości po Load metodzie i akcji zdarzeniaValues after Load method, and event action
DodaneAdded Bieżący = <Existing>Current = <Existing>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Modified>State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
ZmodyfikowanoModified Bieżący = <Existing>Current = <Existing>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Modified>State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
UsunięteDeleted Bieżący = <Not available>Current = <Not available>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Deleted>State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
Bez zmianUnchanged Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
(Nieobecny)(Not present) Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

Wartości w a DataColumn mogą być ograniczone przez użycie właściwości, takich jak ReadOnly i AutoIncrement .Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. LoadMetoda obsługuje takie kolumny w sposób, który jest zgodny z zachowaniem zdefiniowanym przez właściwości kolumny.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Ograniczenie tylko do odczytu dla elementu DataColumn ma zastosowanie tylko do zmian występujących w pamięci.The read only constraint on a DataColumn is applicable only for changes that occur in memory. LoadMetoda zastępuje wartości kolumny tylko do odczytu, w razie konieczności.The Load method's overwrites the read-only column values, if needed.

Aby określić, która wersja pola klucza podstawowego ma być używana do porównywania bieżącego wiersza z przychodzącym wierszem, Load Metoda używa oryginalnej wersji wartości klucza podstawowego w wierszu, jeśli istnieje.To determine which version of the primary key field to use for comparing the current row with an incoming row, the Load method uses the original version of the primary key value within a row, if it exists. W przeciwnym razie Load Metoda używa bieżącej wersji pola klucza podstawowego.Otherwise, the Load method uses the current version of the primary key field.

Dotyczy

Load(IDataReader, LoadOption)

Wypełnia DataTable wartości wartościami ze źródła danych przy użyciu dostarczonego elementu IDataReader .Fills a DataTable with values from a data source using the supplied IDataReader. Jeśli DataTable zawiera już wiersze, dane przychodzące ze źródła danych zostaną scalone z istniejącymi wierszami zgodnie z wartością loadOption parametru.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows according to the value of the loadOption parameter.

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

IDataReaderZawiera co najmniej jeden zestaw wyników.An IDataReader that provides one or more result sets.

loadOption
LoadOption

Wartość z LoadOption wyliczenia, która wskazuje, jak wiersze znajdujące się już w DataTable są łączone z przychodzącymi wierszami, które mają ten sam klucz podstawowy.A value from the LoadOption enumeration that indicates how rows already in the DataTable are combined with incoming rows that share the same primary key.

Przykłady

Poniższy przykład ilustruje kilka problemów związanych z wywołaniem Load metody.The following example demonstrates several of the issues involved with calling the Load method. Pierwszy przykład koncentruje się na problemach ze schematami, w tym wnioskowanie schematu z załadowanego IDataReader , a następnie obsługę niezgodnych schematów i schematów z brakującymi lub dodatkowymi kolumnami.First, the example focuses on schema issues, including inferring a schema from the loaded IDataReader, and then handling incompatible schemas, and schemas with missing or additional columns. Przykład koncentruje się na problemach z danymi, w tym obsługi różnych opcji ładowania.The example then focuses on data issues, including handling the various loading options.

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

Uwagi

LoadMetoda korzysta z pierwszego zestawu wyników z załadowanego IDataReader i po pomyślnym zakończeniu, ustawia pozycję czytnika do następnego zestawu wyników (jeśli istnieje).The Load method consumes the first result set from the loaded IDataReader, and after successful completion, sets the reader's position to the next result set, if any. Podczas konwertowania danych Load Metoda używa tych samych reguł konwersji co Fill Metoda.When converting data, the Load method uses the same conversion rules as the Fill method.

LoadMetoda musi uwzględniać trzy określone problemy podczas ładowania danych z IDataReader wystąpienia: schemat, dane i operacje zdarzeń.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Podczas pracy ze schematem Load Metoda może napotkać warunki zgodnie z opisem w poniższej tabeli.When working with the schema, the Load method may encounter conditions as described in the following table. Operacje schematu są wykonywane dla wszystkich zaimportowanych zestawów wyników, nawet tych, które nie zawierają danych.The schema operations take place for all imported result sets, even those containing no data.

WarunekCondition ZachowanieBehavior
DataTableBrak schematu.The DataTable has no schema. LoadMetoda wnioskuje schemat na podstawie zestawu wyników zaimportowanego IDataReader .The Load method infers the schema based on the result set from the imported IDataReader.
DataTableZawiera schemat, ale jest niezgodny z załadowanym schematem.The DataTable has a schema, but it is incompatible with the loaded schema. LoadMetoda zgłasza wyjątek odpowiadający konkretnemu wystąpieniu błędu, który występuje podczas próby załadowania danych do niezgodnego schematu.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Schematy są zgodne, ale schemat zestawu wyników załadowanych zawiera kolumny, które nie znajdują się w DataTable .The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. LoadMetoda dodaje dodatkowe kolumny do DataTable schematu.The Load method adds the extra columns to DataTable's schema. Metoda zgłasza wyjątek, jeśli odpowiednie kolumny w DataTable i załadowany zestaw wyników nie są zgodne z wartością.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Metoda pobiera również informacje o ograniczeniach z zestawu wyników dla wszystkich dodanych kolumn.The method also retrieves constraint information from the result set for all added columns. Z wyjątkiem ograniczenia PRIMARY KEY, te informacje ograniczenia są używane tylko wtedy, gdy bieżąca DataTable nie zawiera żadnych kolumn na początku operacji ładowania.Except for the case of Primary Key constraint, this constraint information is used only if the current DataTable does not contain any columns at the start of the load operation.
Schematy są zgodne, ale schemat zestawu wyników załadowanych zawiera mniej kolumn niż DataTable .The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Jeśli brakująca kolumna ma zdefiniowaną wartość domyślną lub typem danych kolumny jest nullable, Load Metoda zezwala na dodawanie wierszy, zastępując domyślną lub null wartość dla brakującej kolumny.If a missing column has a default value defined or the column's data type is nullable, the Load method allows the rows to be added, substituting the default or null value for the missing column. Jeśli nie można użyć wartości domyślnej lub wartości null, Load Metoda zgłasza wyjątek.If no default value or null can be used, then the Load method throws an exception. Jeśli nie podano określonej wartości domyślnej, Load Metoda używa wartości null jako implikowanej wartości domyślnej.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Przed uwzględnieniem zachowania Load metody w zakresie operacji na danych, należy wziąć pod uwagę, że każdy wiersz w obrębie DataTable zachowuje zarówno bieżącą wartość, jak i oryginalną wartość dla każdej kolumny.Before considering the behavior of the Load method in terms of data operations, consider that each row within a DataTable maintains both the current value and the original value for each column. Te wartości mogą być równoważne lub mogą być różne, jeśli dane w wierszu zostały zmienione od wypełnienia DataTable .These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Aby uzyskać więcej informacji , zobacz Stany wierszy i wersje wierszy .See Row States and Row Versions for more information.

W przypadku tego wywołania metody określony LoadOption parametr ma wpływ na przetwarzanie danych przychodzących.In this method call, the specified LoadOption parameter influences the processing of the incoming data. Jak powinna być obsługiwana metoda obciążeniowa ładująca wiersze, które mają ten sam klucz podstawowy co istniejące wiersze?How should the Load method handle loading rows that have the same primary key as existing rows? Czy należy zmodyfikować bieżące wartości, oryginalne wartości czy oba?Should it modify current values, original values, or both? Te problemy i inne są kontrolowane przez loadOption parametr.These issues, and more, are controlled by the loadOption parameter.

Jeśli istniejący wiersz i przychodzący wiersz zawierają odpowiednie wartości klucza podstawowego, wiersz jest przetwarzany przy użyciu jego bieżącej wartości stanu wiersza, w przeciwnym razie jest traktowany jako nowy wiersz.If the existing row and the incoming row contain corresponding primary key values, the row is processed using its current row state value, otherwise it's treated as a new row.

W odniesieniu do operacji zdarzeń RowChanging zdarzenie występuje przed zmianą każdego wiersza, a RowChanged zdarzenie występuje po zmianie każdego wiersza.In terms of event operations, the RowChanging event occurs before each row is changed, and the RowChanged event occurs after each row has been changed. W każdym przypadku Action Właściwość DataRowChangeEventArgs wystąpienia przeniesiona do programu obsługi zdarzeń zawiera informacje o określonej akcji skojarzonej ze zdarzeniem.In each case, the Action property of the DataRowChangeEventArgs instance passed to the event handler contains information about the particular action associated with the event. Ta wartość akcji różni się w zależności od stanu wiersza przed operacją ładowania.This action value varies, depending on the state of the row before the load operation. W każdym przypadku występują oba zdarzenia, a akcja jest taka sama dla każdego z nich.In each case, both events occur, and the action is the same for each. Akcja może zostać zastosowana do bieżącej lub oryginalnej wersji każdego wiersza lub obu wierszy, w zależności od bieżącego stanu wiersza.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

W poniższej tabeli przedstawiono zachowanie metody ładowania, gdy jest wywoływana z każdą z LoadOption wartości, a także pokazuje, jak wartości są współdziałane z stanem wiersza dla ładowania wiersza.The following table displays behavior for the Load method when called with each of the LoadOption values, and also shows how the values interact with the row state for the row being loaded. Ostatni wiersz (oznaczony etykietą "(nieobecny)") opisuje zachowanie przychodzące wierszy, które nie są zgodne z żadnym istniejącym wierszem.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Każda komórka w tej tabeli opisuje bieżącą i oryginalną wartość pola w wierszu, wraz z DataRowState wartością dla wartości po Load zakończeniu metody.Each cell in this table describes the current and original value for a field within a row, along with the DataRowState for the value after the Load method has completed.

Istniejące DataRowStateExisting DataRowState UpsertUpsert OverwriteChangesOverwriteChanges PreserveChanges (zachowanie domyślne)PreserveChanges (Default behavior)
DodaneAdded Bieżący = <Incoming>Current = <Incoming>

Oryginalny =-<Not available>Original = -<Not available>

Stan = <Added>State = <Added>

RowAction = ZmieńRowAction = Change
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Existing>Current = <Existing>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Modified>State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
ZmodyfikowanoModified Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Existing>Original = <Existing>

Stan = <Modified>State = <Modified>

RowAction = ZmieńRowAction = Change
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Existing>Current = <Existing>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Modified>State = <Modified>

RowAction = ChangeOriginalRowAction =ChangeOriginal
UsunięteDeleted (Ładowanie nie ma wpływu na usunięte wiersze)(Load does not affect deleted rows)

Bieżąca =---Current = ---

Oryginalna = <Existing>Original = <Existing>

Stan = <Deleted>State = <Deleted>

(Nowy wiersz jest dodawany z następującą charakterystyką)(New row is added with the following characteristics)

Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Not available>Original = <Not available>

Stan = <Added>State = <Added>

RowAction = DodajRowAction = Add
Cofnij usuwanie iUndo delete and

Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Not available>Current = <Not available>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Deleted>State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
Bez zmianUnchanged Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Existing>Original = <Existing>

Jeśli nowa wartość jest taka sama jak istniejąca wartość, a następnieIf new value is the same as the existing value then

Stan = <Unchanged>State = <Unchanged>

RowAction = NothingRowAction = Nothing

PrzejmiElse

Stan = <Modified>State = <Modified>

RowAction = ZmieńRowAction = Change
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Nieobecny)Not present) Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Not available>Original = <Not available>

Stan = <Added>State = <Added>

RowAction = DodajRowAction = Add
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

Wartości w a DataColumn mogą być ograniczone przez użycie właściwości, takich jak ReadOnly i AutoIncrement .Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. LoadMetoda obsługuje takie kolumny w sposób, który jest zgodny z zachowaniem zdefiniowanym przez właściwości kolumny.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Ograniczenie tylko do odczytu dla elementu DataColumn ma zastosowanie tylko do zmian występujących w pamięci.The read only constraint on a DataColumn is applicable only for changes that occur in memory. LoadMetoda zastępuje wartości kolumny tylko do odczytu, w razie konieczności.The Load method's overwrites the read-only column values, if needed.

W przypadku określenia opcji OverwriteChanges lub PreserveChanges podczas wywoływania Load metody, zakłada się, że przychodzące dane pochodzą z DataTable podstawowego źródła danych, a element DataTable śledzi zmiany i mogą propagować zmiany z powrotem do źródła danych.If you specify the OverwriteChanges or PreserveChanges options when calling the Load method, then the assumption is made that the incoming data is coming from the DataTable's primary data source, and the DataTable tracks changes and can propagate the changes back to the data source. W przypadku wybrania opcji upsert zakłada się, że dane pochodzą z jednego z pomocniczego źródła danych, takiego jak dane dostarczone przez składnik warstwy środkowej, prawdopodobnie zmienione przez użytkownika.If you select the Upsert option, it is assumed that the data is coming from one of a secondary data source, such as data provided by a middle-tier component, perhaps altered by a user. W takim przypadku założeniem jest, że celem jest agregowanie danych z co najmniej jednego źródła danych w DataTable , a następnie prawdopodobnie propagowanie danych z powrotem do podstawowego źródła danych.In this case, the assumption is that the intent is to aggregate data from one or more data sources in the DataTable, and then perhaps propagate the data back to the primary data source. LoadOptionParametr jest używany do określania określonej wersji wiersza, który ma być używany do porównania klucza podstawowego.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. Poniższa tabela zawiera szczegółowe informacje.The table below provides the details.

Opcja ładowaniaLoad option Wersja elementu DataRow używana do porównania klucza podstawowegoDataRow version used for primary key comparison
OverwriteChanges Wersja oryginalna (jeśli istnieje), w przeciwnym razie bieżąca wersjaOriginal version, if it exists, otherwise Current version
PreserveChanges Wersja oryginalna (jeśli istnieje), w przeciwnym razie bieżąca wersjaOriginal version, if it exists, otherwise Current version
Upsert Bieżąca wersja (jeśli istnieje), w przeciwnym razie wersja oryginalnaCurrent version, if it exists, otherwise Original version

Dotyczy

Load(IDataReader, LoadOption, FillErrorEventHandler)

Wypełnia DataTable wartości wartościami ze źródła danych za pomocą podanego IDataReader delegata obsługi błędu.Fills a DataTable with values from a data source using the supplied IDataReader using an error-handling delegate.

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 , który zawiera zestaw wyników.A IDataReader that provides a result set.

loadOption
LoadOption

Wartość z LoadOption wyliczenia, która wskazuje, jak wiersze znajdujące się już w DataTable są łączone z przychodzącymi wierszami, które mają ten sam klucz podstawowy.A value from the LoadOption enumeration that indicates how rows already in the DataTable are combined with incoming rows that share the same primary key.

errorHandler
FillErrorEventHandler

FillErrorEventHandlerDelegat do wywołania, gdy wystąpi błąd podczas ładowania danych.A FillErrorEventHandler delegate to call when an error occurs while loading data.

Przykłady

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

Uwagi

LoadMetoda korzysta z pierwszego zestawu wyników z załadowanego IDataReader i po pomyślnym zakończeniu, ustawia pozycję czytnika do następnego zestawu wyników (jeśli istnieje).The Load method consumes the first result set from the loaded IDataReader, and after successful completion, sets the reader's position to the next result set, if any. Podczas konwertowania danych Load Metoda używa tych samych reguł konwersji co DbDataAdapter.Fill Metoda.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

LoadMetoda musi uwzględniać trzy określone problemy podczas ładowania danych z IDataReader wystąpienia: schemat, dane i operacje zdarzeń.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Podczas pracy ze schematem Load Metoda może napotkać warunki zgodnie z opisem w poniższej tabeli.When working with the schema, the Load method may encounter conditions as described in the following table. Operacje schematu są wykonywane dla wszystkich zaimportowanych zestawów wyników, nawet tych, które nie zawierają danych.The schema operations take place for all imported result sets, even those containing no data.

WarunekCondition ZachowanieBehavior
DataTableBrak schematu.The DataTable has no schema. LoadMetoda wnioskuje schemat na podstawie zestawu wyników zaimportowanego IDataReader .The Load method infers the schema based on the result set from the imported IDataReader.
DataTableZawiera schemat, ale jest niezgodny z załadowanym schematem.The DataTable has a schema, but it is incompatible with the loaded schema. LoadMetoda zgłasza wyjątek odpowiadający konkretnemu wystąpieniu błędu, który występuje podczas próby załadowania danych do niezgodnego schematu.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Schematy są zgodne, ale schemat zestawu wyników załadowanych zawiera kolumny, które nie znajdują się w DataTable .The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. LoadMetoda dodaje dodatkowe kolumny do DataTable schematu.The Load method adds the extra column(s) to DataTable's schema. Metoda zgłasza wyjątek, jeśli odpowiednie kolumny w DataTable i załadowany zestaw wyników nie są zgodne z wartością.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Metoda pobiera również informacje o ograniczeniach z zestawu wyników dla wszystkich dodanych kolumn.The method also retrieves constraint information from the result set for all added columns. Z wyjątkiem ograniczenia PRIMARY KEY, te informacje ograniczenia są używane tylko wtedy, gdy bieżąca DataTable nie zawiera żadnych kolumn na początku operacji ładowania.Except for the case of Primary Key constraint, this constraint information is used only if the current DataTable does not contain any columns at the start of the load operation.
Schematy są zgodne, ale schemat zestawu wyników załadowanych zawiera mniej kolumn niż DataTable .The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Jeśli brakująca kolumna ma zdefiniowaną wartość domyślną lub typem danych kolumny jest nullable, Load Metoda zezwala na dodawanie wierszy, zastępując domyślną lub null wartość dla brakującej kolumny.If a missing column has a default value defined or the column's data type is nullable, the Load method allows the rows to be added, substituting the default or null value for the missing column. Jeśli nie można użyć wartości domyślnej lub wartości null, Load Metoda zgłasza wyjątek.If no default value or null can be used, then the Load method throws an exception. Jeśli nie podano określonej wartości domyślnej, Load Metoda używa wartości null jako implikowanej wartości domyślnej.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Przed uwzględnieniem zachowania Load metody w zakresie operacji na danych, należy wziąć pod uwagę, że każdy wiersz w obrębie DataTable zachowuje zarówno bieżącą wartość, jak i oryginalną wartość dla każdej kolumny.Before considering the behavior of the Load method in terms of data operations, consider that each row within a DataTable maintains both the current value and the original value for each column. Te wartości mogą być równoważne lub mogą być różne, jeśli dane w wierszu zostały zmienione od wypełnienia DataTable .These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Aby uzyskać więcej informacji , zobacz Stany wierszy i wersje wierszy .See Row States and Row Versions for more information.

W przypadku tego wywołania metody określony LoadOption parametr ma wpływ na przetwarzanie danych przychodzących.In this method call, the specified LoadOption parameter influences the processing of the incoming data. Jak powinna być obsługiwana metoda obciążeniowa ładująca wiersze, które mają ten sam klucz podstawowy co istniejące wiersze?How should the Load method handle loading rows that have the same primary key as existing rows? Czy należy zmodyfikować bieżące wartości, oryginalne wartości czy oba?Should it modify current values, original values, or both? Te problemy i inne są kontrolowane przez loadOption parametr.These issues, and more, are controlled by the loadOption parameter.

Jeśli istniejący wiersz i przychodzący wiersz zawierają odpowiednie wartości klucza podstawowego, wiersz jest przetwarzany przy użyciu jego bieżącej wartości stanu wiersza, w przeciwnym razie jest traktowany jako nowy wiersz.If the existing row and the incoming row contain corresponding primary key values, the row is processed using its current row state value, otherwise it's treated as a new row.

W odniesieniu do operacji zdarzeń RowChanging zdarzenie występuje przed zmianą każdego wiersza, a RowChanged zdarzenie występuje po zmianie każdego wiersza.In terms of event operations, the RowChanging event occurs before each row is changed, and the RowChanged event occurs after each row has been changed. W każdym przypadku Action Właściwość DataRowChangeEventArgs wystąpienia przeniesiona do programu obsługi zdarzeń zawiera informacje o określonej akcji skojarzonej ze zdarzeniem.In each case, the Action property of the DataRowChangeEventArgs instance passed to the event handler contains information about the particular action associated with the event. Ta wartość akcji różni się w zależności od stanu wiersza przed operacją ładowania.This action value varies, depending on the state of the row before the load operation. W każdym przypadku występują oba zdarzenia, a akcja jest taka sama dla każdego z nich.In each case, both events occur, and the action is the same for each. Akcja może zostać zastosowana do bieżącej lub oryginalnej wersji każdego wiersza lub obu wierszy, w zależności od bieżącego stanu wiersza.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

W poniższej tabeli przedstawiono zachowanie metody ładowania, gdy jest wywoływana z każdą z LoadOption wartości, a także pokazuje, jak wartości są współdziałane z stanem wiersza dla ładowania wiersza.The following table displays behavior for the Load method when called with each of the LoadOption values, and also shows how the values interact with the row state for the row being loaded. Ostatni wiersz (oznaczony etykietą "(nieobecny)") opisuje zachowanie przychodzące wierszy, które nie są zgodne z żadnym istniejącym wierszem.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Każda komórka w tej tabeli opisuje bieżącą i oryginalną wartość pola w wierszu, wraz z DataRowState wartością dla wartości po Load zakończeniu metody.Each cell in this table describes the current and original value for a field within a row, along with the DataRowState for the value after the Load method has completed.

Istniejące DataRowStateExisting DataRowState UpsertUpsert OverwriteChangesOverwriteChanges PreserveChanges (zachowanie domyślne)PreserveChanges (Default behavior)
DodaneAdded Bieżący = <Incoming>Current = <Incoming>

Oryginalny =-<Not available>Original = -<Not available>

Stan = <Added>State = <Added>

RowAction = ZmieńRowAction = Change
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Existing>Current = <Existing>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Modified>State = <Modified>

RowAction = ChangeOriginalRowAction = ChangeOriginal
ZmodyfikowanoModified Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Existing>Original = <Existing>

Stan = <Modified>State = <Modified>

RowAction = ZmieńRowAction = Change
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Existing>Current = <Existing>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Modified>State = <Modified>

RowAction = ChangeOriginalRowAction =ChangeOriginal
eletedeleted (Ładowanie nie ma wpływu na usunięte wiersze)(Load does not affect deleted rows)

Bieżąca =---Current = ---

Oryginalna = <Existing>Original = <Existing>

Stan = <Deleted>State = <Deleted>

(Nowy wiersz jest dodawany z następującą charakterystyką)(New row is added with the following characteristics)

Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Not available>Original = <Not available>

Stan = <Added>State = <Added>

RowAction = DodajRowAction = Add
Cofnij usuwanie iUndo delete and

Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Not available>Current = <Not available>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Deleted>State = <Deleted>

RowAction = ChangeOriginalRowAction = ChangeOriginal
Bez zmianUnchanged Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Existing>Original = <Existing>

Jeśli nowa wartość jest taka sama jak istniejąca wartość, a następnieIf new value is the same as the existing value then

Stan = <Unchanged>State = <Unchanged>

RowAction = NothingRowAction = Nothing

PrzejmiElse

Stan = <Modified>State = <Modified>

RowAction = ZmieńRowAction = Change
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Nieobecny)Not present) Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Not available>Original = <Not available>

Stan = <Added>State = <Added>

RowAction = DodajRowAction = Add
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal
Bieżący = <Incoming>Current = <Incoming>

Oryginalna = <Incoming>Original = <Incoming>

Stan = <Unchanged>State = <Unchanged>

RowAction = ChangeCurrentAndOriginalRowAction = ChangeCurrentAndOriginal

Wartości w a DataColumn mogą być ograniczone przez użycie właściwości, takich jak ReadOnly i AutoIncrement .Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. LoadMetoda obsługuje takie kolumny w sposób, który jest zgodny z zachowaniem zdefiniowanym przez właściwości kolumny.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Ograniczenie tylko do odczytu dla elementu DataColumn ma zastosowanie tylko do zmian występujących w pamięci.The read only constraint on a DataColumn is applicable only for changes that occur in memory. LoadMetoda zastępuje wartości kolumny tylko do odczytu, w razie konieczności.The Load method's overwrites the read-only column values, if needed.

W przypadku określenia opcji OverwriteChanges lub PreserveChanges podczas wywoływania Load metody, zakłada się, że przychodzące dane pochodzą z DataTable podstawowego źródła danych, a element DataTable śledzi zmiany i mogą propagować zmiany z powrotem do źródła danych.If you specify the OverwriteChanges or PreserveChanges options when calling the Load method, then the assumption is made that the incoming data is coming from the DataTable's primary data source, and the DataTable tracks changes and can propagate the changes back to the data source. W przypadku wybrania opcji upsert zakłada się, że dane pochodzą z jednego z pomocniczego źródła danych, takiego jak dane dostarczone przez składnik warstwy środkowej, prawdopodobnie zmienione przez użytkownika.If you select the Upsert option, it is assumed that the data is coming from one of a secondary data source, such as data provided by a middle-tier component, perhaps altered by a user. W takim przypadku założeniem jest, że celem jest agregowanie danych z co najmniej jednego źródła danych w DataTable , a następnie prawdopodobnie propagowanie danych z powrotem do podstawowego źródła danych.In this case, the assumption is that the intent is to aggregate data from one or more data sources in the DataTable, and then perhaps propagate the data back to the primary data source. LoadOptionParametr jest używany do określania określonej wersji wiersza, który ma być używany do porównania klucza podstawowego.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. Poniższa tabela zawiera szczegółowe informacje.The table below provides the details.

Opcja ładowaniaLoad option Wersja elementu DataRow używana do porównania klucza podstawowegoDataRow version used for primary key comparison
OverwriteChanges Wersja oryginalna (jeśli istnieje), w przeciwnym razie bieżąca wersjaOriginal version, if it exists, otherwise Current version
PreserveChanges Wersja oryginalna (jeśli istnieje), w przeciwnym razie bieżąca wersjaOriginal version, if it exists, otherwise Current version
Upsert Bieżąca wersja (jeśli istnieje), w przeciwnym razie wersja oryginalnaCurrent version, if it exists, otherwise Original version

errorHandlerParametr jest FillErrorEventHandler delegatem, który odwołuje się do procedury, która jest wywoływana, gdy wystąpi błąd podczas ładowania danych.The errorHandler parameter is a FillErrorEventHandler delegate that refers to a procedure that is called when an error occurs while loading data. FillErrorEventArgsParametr przesłany do procedury zawiera właściwości, które umożliwiają pobranie informacji o błędzie, który wystąpił, bieżący wiersz danych i DataTable wypełnienie.The FillErrorEventArgs parameter passed to the procedure provides properties that allow you to retrieve information about the error that occurred, the current row of data, and the DataTable being filled. Dzięki temu mechanizmowi delegata, a nie prostszym blokiem try/catch, można określić błąd, obsłużyć sytuację i kontynuować przetwarzanie, jeśli chcesz.Using this delegate mechanism, rather than a simpler try/catch block, allows you to determine the error, handle the situation, and continue processing if you like. FillErrorEventArgsParametr dostarcza Continue Właściwość: Ustaw tę właściwość na, aby true wskazywała, że błąd został obsłużony i chcesz kontynuować przetwarzanie.The FillErrorEventArgs parameter supplies a Continue property: set this property to true to indicate that you have handled the error and wish to continue processing. Ustaw właściwość na false , aby wskazać, że chcesz zatrzymać przetwarzanie.Set the property to false to indicate that you wish to halt processing. Należy pamiętać, że ustawienie właściwości powoduje, że false kod, który wyzwolił problem, zgłosić wyjątek.Be aware that setting the property to false causes the code that triggered the problem to throw an exception.

Dotyczy