DataTable.Load Methode

Definition

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet.Fills a DataTable with values from a data source using the supplied IDataReader. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

Überlädt

Load(IDataReader)

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet.Fills a DataTable with values from a data source using the supplied IDataReader. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.If the DataTable already contains rows, the incoming data from the data source is merged with the existing rows.

Load(IDataReader, LoadOption)

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet.Fills a DataTable with values from a data source using the supplied IDataReader. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten gemäß dem Wert des loadOption-Parameters aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.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)

Füllt eine DataTable mit Werten aus einer Datenquelle mit dem bereitgestellten IDataReader und unter Verwendung eines Fehlerbehandlungsdelegaten.Fills a DataTable with values from a data source using the supplied IDataReader using an error-handling delegate.

Beispiele

Im folgenden Beispiel werden einige der Probleme beim Aufrufen der Load -Methode veranschaulicht.The following example demonstrates several of the issues involved with calling the Load method. Zuerst konzentriert sich das Beispiel auf Schema Probleme, z. b. das Ableiten eines Schemas aus dem geladenen IDataReader, das anschließende behandeln inkompatibler Schemas und Schemas mit fehlenden oder zusätzlichen Spalten.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. Das Beispiel konzentriert sich dann auf Daten Probleme, einschließlich der Behandlung der verschiedenen Lade Optionen.The example then focuses on data issues, including handling the various loading options.

Hinweis

Dieses Beispiel zeigt, wie Sie eine der überladenen Versionen Loadvon verwenden können.This example shows how to use one of the overloaded versions of Load. Weitere Beispiele, die möglicherweise verfügbar sind, finden Sie in den Themen zu den einzelnen Überladungen.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

Hinweise

Die Load -Methode kann in verschiedenen gängigen Szenarien verwendet werden, wobei alle Daten aus einer angegebenen Datenquelle bezogen und dem aktuellen Datencontainer (in diesem Fall a DataTable) hinzugefügt werden.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). In diesen Szenarien wird die Standardverwendung DataTablefür eine beschrieben und deren Update-und Zusammenschluss Verhalten beschrieben.These scenarios describe standard usage for a DataTable, describing its update and merge behavior.

Eine DataTable Synchronisierung oder Aktualisierung mit einer einzelnen primären Datenquelle.A DataTable synchronizes or updates with a single primary data source. Der DataTable verfolgt Änderungen, sodass die Synchronisierung mit der primären Datenquelle möglich ist.The DataTable tracks changes, allowing synchronization with the primary data source. Außerdem kann eine DataTable inkrementelle Daten aus einer oder mehreren sekundären Datenquellen akzeptieren.In addition, a DataTable can accept incremental data from one or more secondary data sources. Der DataTable ist nicht verantwortlich für das Nachverfolgen von Änderungen, um die Synchronisierung mit der sekundären Datenquelle zuzulassen.The DataTable isn't responsible for tracking changes in order to allow synchronization with the secondary data source.

Bei diesen beiden hypothetischen Datenquellen erfordert ein Benutzer wahrscheinlich eines der folgenden Verhaltensweisen:Given these two hypothetical data sources, a user is likely to require one of the following behaviors:

  • Initialisieren DataTable von einer primären Datenquelle aus.Initialize DataTable from a primary data source. In diesem Szenario möchte der Benutzer eine leere DataTable mit Werten aus der primären Datenquelle initialisieren.In this scenario, the user wants to initialize an empty DataTable with values from the primary data source. Später beabsichtigt der Benutzer, Änderungen an die primäre Datenquelle zurückzugeben.Later the user intends to propagate changes back to the primary data source.

  • Behalten Sie Änderungen bei, und synchronisieren Sie Sie von der primären Datenquelle erneut.Preserve changes and re-synchronize from the primary data source. In diesem Szenario möchte der Benutzer das DataTable vorherige Szenario durchführen und eine inkrementelle Synchronisierung mit der primären Datenquelle durchführen, wobei die DataTablein vorgenommenen Änderungen beibehalten werden.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.

  • Inkrementeller Datenfeed aus sekundären Datenquellen.Incremental data feed from secondary data sources. In diesem Szenario möchte der Benutzer Änderungen aus einer oder mehreren sekundären Datenquellen zusammenführen und diese Änderungen an die primäre Datenquelle zurückgeben.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.

Die Load -Methode macht alle diese Szenarien möglich.The Load method makes all these scenarios possible. Alle außer einer der-über Ladungen für diese Methode ermöglichen es Ihnen, einen Parameter für die Lade Option anzugeben, der angibt, DataTable wie bereits in einem-Element mit den Zeilen geladene Zeilen kombiniert werden.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. (Bei der Überladung, bei der das Verhalten nicht festgelegt werden kann, wird die Option Standard Last verwendet.) In der folgenden Tabelle werden die drei von der LoadOption -Enumeration bereitgestellten Lade Optionen beschrieben.(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. In jedem Fall gibt die Beschreibung das Verhalten an, wenn der Primärschlüssel einer Zeile in den eingehenden Daten mit dem Primärschlüssel einer vorhandenen Zeile übereinstimmt.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.

Option LadenLoad Option BeschreibungDescription
PreserveChanges (Standard)PreserveChanges (default) Aktualisiert die ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile.Updates the original version of the row with the value of the incoming row.
OverwriteChanges Aktualisiert die aktuelle und die ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile.Updates the current and original versions of the row with the value of the incoming row.
Upsert Aktualisiert die aktuelle Version der Zeile mit dem Wert der eingehenden Zeile.Updates the current version of the row with the value of the incoming row.

Im Allgemeinen sind die PreserveChanges Optionen OverwriteChanges und für Szenarien gedacht, in denen der DataSet Benutzer und seine Änderungen mit der primären Datenquelle synchronisieren muss.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. Die Upsert -Option vereinfacht das aggregierten ändern von einer oder mehreren sekundären Datenquellen.The Upsert option facilitates aggregating changes from one or more secondary data sources.

Load(IDataReader)

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet.Fills a DataTable with values from a data source using the supplied IDataReader. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.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)

Parameter

reader
IDataReader

Ein IDataReader, der ein Resultset bereitstellt.An IDataReader that provides a result set.

Beispiele

Im folgenden Beispiel werden einige der Probleme beim Aufrufen der Load -Methode veranschaulicht.The following example demonstrates several of the issues involved with calling the Load method. Zuerst konzentriert sich das Beispiel auf Schema Probleme, z. b. das Ableiten eines Schemas aus dem geladenen IDataReader, das anschließende behandeln inkompatibler Schemas und Schemas mit fehlenden oder zusätzlichen Spalten.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. Das Beispiel ruft dann die Load -Methode auf und zeigt die Daten sowohl vor als auch nach dem Ladevorgang an.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

Hinweise

Die Load -Methode verwendet das erste Resultset aus IDataReaderdem geladenen und nach erfolgreichem Abschluss die Position des Readers auf das nächste Resultset, sofern vorhanden.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. Beim Konvertieren von Daten verwendet Load die-Methode dieselben Konvertierungsregeln wie DbDataAdapter.Fill die-Methode.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

Die Load -Methode muss beim Laden der Daten aus einer IDataReader -Instanz drei spezifische Probleme berücksichtigen: Schema-, Daten-und Ereignis Vorgänge.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Beim Arbeiten mit dem Schema kann die Load -Methode Bedingungen wie in der folgenden Tabelle beschrieben haben.When working with the schema, the Load method may encounter conditions as described in the following table. Die Schema Vorgänge erfolgen für alle importierten Resultsets, auch für solche, die keine Daten enthalten.The schema operations take place for all imported result sets, even those containing no data.

BedingungCondition VerhaltenBehavior
DataTable Hat kein Schema.The DataTable has no schema. Die Load Methode leitet das Schema basierend auf dem Resultset aus dem importierten IDataReaderab.The Load method infers the schema based on the result set from the imported IDataReader.
Der DataTable verfügt über ein Schema, aber es ist nicht mit dem geladenen Schema kompatibel.The DataTable has a schema, but it is incompatible with the loaded schema. Die Load -Methode löst eine Ausnahme aus, die dem jeweiligen Fehler entspricht, der auftritt, wenn versucht wird, Daten in das nicht kompatible Schema zu laden.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält Spalten, die in DataTablenicht vorhanden sind.The schemas are compatible, but the loaded result set schema contains columns that do not exist in the DataTable. Die Load DataTable-Methode fügt dem Schema die zusätzlichen Spalten hinzu.The Load method adds the extra columns to DataTable's schema. Die DataTable -Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten in und dem geladenen Resultset nicht Wert kompatibel sind.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Die-Methode ruft auch Einschränkungs Informationen aus dem Resultset für alle hinzugefügten Spalten ab.The method also retrieves constraint information from the result set for all added columns. Außer bei der PRIMARY KEY-Einschränkung werden diese Einschränkungs Informationen nur verwendet, wenn der aktuelle DataTable keine Spalten am Anfang des Ladevorgangs enthält.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.
Die Schemas sind kompatibel, das geladene Resultsetschema enthält jedoch weniger Spalten, als DataTabledas-Schema enthält.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Wenn für eine fehlende Spalte ein Standardwert definiert ist oder der Datentyp der Spalte NULL-Werte zulässt Load , kann die-Methode die Zeilen hinzugefügt werden, wobei die null fehlende Spalte durch den Standardwert oder den Wert ersetzt wird.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. Wenn kein Standardwert oder null verwendet werden kann, löst die Load Methode eine Ausnahme aus.If no default value or null can be used, then the Load method throws an exception. Wenn kein spezifischer Standardwert angegeben wurde, Load null verwendet die Methode den Wert als impliziten Standardwert.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Bevor Sie das Verhalten Load der-Methode in Bezug auf Daten Vorgänge in Erwägung ziehen, sollten Sie Bedenken, dass jede Zeile in einer DataTable sowohl den aktuellen als auch den ursprünglichen Wert für jede Spalte beibehält.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. Diese Werte können gleichwertig sein oder abweichen, wenn die Daten in der Zeile seit dem Ausfüllen des DataTablegeändert wurden.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Weitere Informationen finden Sie unter Zeilen Status und Zeilen Versionen.For more information, see Row States and Row Versions.

Diese Version der Load -Methode versucht, die aktuellen Werte in jeder Zeile beizubehalten, wobei der ursprüngliche Wert unverändert bleibt.This version of the Load method attempts to preserve the current values in each row, leaving the original value intact. (Wenn Sie eine präzisere Steuerung des Verhaltens eingehender Daten wünschen, finden DataTable.LoadSie weitere Informationen unter.) Wenn die vorhandene Zeile und die eingehende Zeile die entsprechenden Primärschlüssel Werte enthalten, wird die Zeile mit dem aktuellen Zeilen Zustandswert verarbeitet; andernfalls wird Sie als neue Zeile behandelt.(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.

Im Hinblick auf Ereignis Vorgänge tritt das RowChanging -Ereignis auf, bevor jede Zeile geändert wird, RowChanged und das-Ereignis tritt auf, nachdem jede Zeile geändert wurde.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. In jedem Fall enthält die Action -Eigenschaft DataRowChangeEventArgs der-Instanz, die an den-Ereignishandler übermittelt wird, Informationen zu der jeweiligen Aktion, die dem Ereignis zugeordnet ist.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. Dieser Aktionswert hängt vom Zustand der Zeile vor dem Ladevorgang ab.This action value depends on the state of the row before the load operation. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jede der beiden Ereignisse identisch.In each case, both events occur, and the action is the same for each. Die Aktion kann je nach dem aktuellen Zeilen Status entweder auf die aktuelle oder die ursprüngliche Version der einzelnen Zeilen oder beides angewendet werden.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

In der folgenden Tabelle wird das Verhalten Load für die-Methode angezeigt.The following table displays behavior for the Load method. Die letzte Zeile (mit der Bezeichnung "(nicht vorhanden)") beschreibt das Verhalten für eingehende Zeilen, die keiner vorhandenen Zeile entsprechen.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Jede Zelle in dieser Tabelle beschreibt den aktuellen und den ursprünglichen Wert für ein Feld innerhalb einer Zeile zusammen mit dem DataRowState für den Wert, nachdem Load die-Methode abgeschlossen wurde.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. In diesem Fall können Sie mit der-Methode nicht die Option Laden angeben und die Standardeinstellung PreserveChangesverwenden.In this case, the method doesn't allow you to indicate the load option, and uses the default, PreserveChanges.

Vorhandener DataRowStateExisting DataRowState Werte nach Load Methode und Ereignis AktionValues after Load method, and event action
HinzugefügtAdded Current = <vorhandener >Current = <Existing>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <geänderte >State = <Modified>

Rowaction = changeoriginalRowAction = ChangeOriginal
ModifiedModified Current = <vorhandener >Current = <Existing>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <geänderte >State = <Modified>

Rowaction = changeoriginalRowAction = ChangeOriginal
DeletedDeleted Aktuell = <nicht verfügbar >Current = <Not available>

Ursprünglicher <= eingehender >Original = <Incoming>

Status = <gelöschte >State = <Deleted>

Rowaction = changeoriginalRowAction = ChangeOriginal
UnchangedUnchanged Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
(Nicht vorhanden)(Not present) Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal

Werte in einer DataColumn können durch die Verwendung von Eigenschaften ReadOnly wie und AutoIncrementeingeschränkt werden.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. Die Load -Methode behandelt solche Spalten so, dass Sie mit dem Verhalten konsistent ist, das in den Eigenschaften der Spalte definiert ist.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Die schreibgeschützte Einschränkung für einen DataColumn gilt nur für Änderungen, die im Arbeitsspeicher auftreten.The read only constraint on a DataColumn is applicable only for changes that occur in memory. Die Load -Methode überschreibt bei Bedarf die schreibgeschützten Spaltenwerte.The Load method's overwrites the read-only column values, if needed.

Um zu ermitteln, welche Version des Primärschlüssel Felds zum Vergleichen der aktuellen Zeile mit einer eingehenden Zeile verwendet werden Load soll, verwendet die-Methode die ursprüngliche Version des Primärschlüssel Werts in einer Zeile, sofern vorhanden.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. Andernfalls verwendet die Load -Methode die aktuelle Version des Primärschlüssel Felds.Otherwise, the Load method uses the current version of the primary key field.

Siehe auch

Load(IDataReader, LoadOption)

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet.Fills a DataTable with values from a data source using the supplied IDataReader. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten gemäß dem Wert des loadOption-Parameters aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.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

Parameter

reader
IDataReader

Ein IDataReader, der ein oder mehrere Resultsets bereitstellt.An IDataReader that provides one or more result sets.

loadOption
LoadOption

Ein Wert aus der LoadOption-Enumeration, der angibt, wie bereits in der DataTable vorhandene Zeilen mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.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.

Beispiele

Im folgenden Beispiel werden einige der Probleme beim Aufrufen der Load -Methode veranschaulicht.The following example demonstrates several of the issues involved with calling the Load method. Zuerst konzentriert sich das Beispiel auf Schema Probleme, z. b. das Ableiten eines Schemas aus dem geladenen IDataReader, das anschließende behandeln inkompatibler Schemas und Schemas mit fehlenden oder zusätzlichen Spalten.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. Das Beispiel konzentriert sich dann auf Daten Probleme, einschließlich der Behandlung der verschiedenen Lade Optionen.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

Hinweise

Die Load -Methode verwendet das erste Resultset aus IDataReaderdem geladenen und nach erfolgreichem Abschluss die Position des Readers auf das nächste Resultset, sofern vorhanden.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. Beim Konvertieren von Daten verwendet Load die-Methode dieselben Konvertierungsregeln wie Fill die-Methode.When converting data, the Load method uses the same conversion rules as the Fill method.

Die Load -Methode muss beim Laden der Daten aus einer IDataReader -Instanz drei spezifische Probleme berücksichtigen: Schema-, Daten-und Ereignis Vorgänge.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Beim Arbeiten mit dem Schema kann die Load -Methode Bedingungen wie in der folgenden Tabelle beschrieben haben.When working with the schema, the Load method may encounter conditions as described in the following table. Die Schema Vorgänge erfolgen für alle importierten Resultsets, auch für solche, die keine Daten enthalten.The schema operations take place for all imported result sets, even those containing no data.

BedingungCondition VerhaltenBehavior
DataTable Hat kein Schema.The DataTable has no schema. Die Load Methode leitet das Schema basierend auf dem Resultset aus dem importierten IDataReaderab.The Load method infers the schema based on the result set from the imported IDataReader.
Der DataTable verfügt über ein Schema, aber es ist nicht mit dem geladenen Schema kompatibel.The DataTable has a schema, but it is incompatible with the loaded schema. Die Load -Methode löst eine Ausnahme aus, die dem jeweiligen Fehler entspricht, der auftritt, wenn versucht wird, Daten in das nicht kompatible Schema zu laden.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält Spalten, die in DataTablenicht vorhanden sind.The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. Die Load DataTable-Methode fügt dem Schema die zusätzlichen Spalten hinzu.The Load method adds the extra columns to DataTable's schema. Die DataTable -Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten in und dem geladenen Resultset nicht Wert kompatibel sind.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Die-Methode ruft auch Einschränkungs Informationen aus dem Resultset für alle hinzugefügten Spalten ab.The method also retrieves constraint information from the result set for all added columns. Außer bei der PRIMARY KEY-Einschränkung werden diese Einschränkungs Informationen nur verwendet, wenn der aktuelle DataTable keine Spalten am Anfang des Ladevorgangs enthält.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.
Die Schemas sind kompatibel, das geladene Resultsetschema enthält jedoch weniger Spalten, als DataTabledas-Schema enthält.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Wenn für eine fehlende Spalte ein Standardwert definiert ist, oder wenn der Datentyp der Spalte NULL- Load Werte zulässt, kann die-Methode die Zeilen hinzufügen und ersetzt die fehlende Spalte durch den Standardwert oder den Nullwert.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. Wenn kein Standardwert oder NULL verwendet werden kann, löst die Load Methode eine Ausnahme aus.If no default value or null can be used, then the Load method throws an exception. Wenn kein spezifischer Standardwert angegeben wurde, verwendet die Load Methode den NULL-Wert als impliziten Standardwert.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Bevor Sie das Verhalten Load der-Methode in Bezug auf Daten Vorgänge in Erwägung ziehen, sollten Sie Bedenken, dass jede Zeile in einer DataTable sowohl den aktuellen als auch den ursprünglichen Wert für jede Spalte beibehält.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. Diese Werte können gleichwertig sein oder abweichen, wenn die Daten in der Zeile seit dem Ausfüllen des DataTablegeändert wurden.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Weitere Informationen finden Sie unter Zeilen Status und Zeilen Versionen .See Row States and Row Versions for more information.

In diesem Methoden Aufrufwert beeinflusst LoadOption der angegebene Parameter die Verarbeitung der eingehenden Daten.In this method call, the specified LoadOption parameter influences the processing of the incoming data. Wie soll die Load-Methode das Laden von Zeilen verarbeiten, die denselben Primärschlüssel wie vorhandene Zeilen aufweisen?How should the Load method handle loading rows that have the same primary key as existing rows? Sollten aktuelle Werte, ursprüngliche Werte oder beides geändert werden?Should it modify current values, original values, or both? Diese Probleme und mehr werden durch den loadOption -Parameter gesteuert.These issues, and more, are controlled by the loadOption parameter.

Wenn die vorhandene Zeile und die eingehende Zeile die entsprechenden Primärschlüssel Werte enthalten, wird die Zeile mit dem aktuellen Zeilen Zustandswert verarbeitet; andernfalls wird Sie als neue Zeile behandelt.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.

Im Hinblick auf Ereignis Vorgänge tritt das RowChanging -Ereignis auf, bevor jede Zeile geändert wird, RowChanged und das-Ereignis tritt auf, nachdem jede Zeile geändert wurde.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. In jedem Fall enthält die Action -Eigenschaft DataRowChangeEventArgs der-Instanz, die an den-Ereignishandler übermittelt wird, Informationen zu der jeweiligen Aktion, die dem Ereignis zugeordnet ist.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. Dieser Aktionswert variiert je nach Zustand der Zeile vor dem Ladevorgang.This action value varies, depending on the state of the row before the load operation. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jede der beiden Ereignisse identisch.In each case, both events occur, and the action is the same for each. Die Aktion kann je nach dem aktuellen Zeilen Status entweder auf die aktuelle oder die ursprüngliche Version der einzelnen Zeilen oder beides angewendet werden.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

In der folgenden Tabelle wird das Verhalten für die Load-Methode angezeigt, wenn LoadOption Sie mit jedem der-Werte aufgerufen wird. Außerdem wird gezeigt, wie die-Werte mit dem Zeilen Status der zu ladenden Zeile interagieren.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. Die letzte Zeile (mit der Bezeichnung "(nicht vorhanden)") beschreibt das Verhalten für eingehende Zeilen, die keiner vorhandenen Zeile entsprechen.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Jede Zelle in dieser Tabelle beschreibt den aktuellen und den ursprünglichen Wert für ein Feld innerhalb einer Zeile zusammen mit dem DataRowState für den Wert, nachdem Load die-Methode abgeschlossen wurde.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.

Vorhandener DataRowStateExisting DataRowState UpsertUpsert OverschreitechangesOverwriteChanges PreserveChanges (Standardverhalten)PreserveChanges (Default behavior)
HinzugefügtAdded Aktuell = <eingehender >Current = <Incoming>

Original =-<nicht verfügbar >Original = -<Not available>

Status = <hinzugefügter >State = <Added>

Rowaction = ändernRowAction = Change
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Current = <vorhandener >Current = <Existing>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <geänderte >State = <Modified>

Rowaction = changeoriginalRowAction = ChangeOriginal
ModifiedModified Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= vorhandener >Original = <Existing>

State = <geänderte >State = <Modified>

Rowaction = ändernRowAction = Change
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Current = <vorhandener >Current = <Existing>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <geänderte >State = <Modified>

Rowaction = changeoriginalRowAction =ChangeOriginal
DeletedDeleted (Laden hat keine Auswirkungen auf gelöschte Zeilen)(Load does not affect deleted rows)

Aktuell =---Current = ---

Ursprünglicher <= vorhandener >Original = <Existing>

Status = <gelöschte >State = <Deleted>

(Neue Zeile mit den folgenden Eigenschaften hinzugefügt)(New row is added with the following characteristics)

Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= nicht verfügbar >Original = <Not available>

Status = <hinzugefügter >State = <Added>

Rowaction = hinzufügenRowAction = Add
Löschvorgang rückgängig machenUndo delete and

Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Aktuell = <nicht verfügbar >Current = <Not available>

Ursprünglicher <= eingehender >Original = <Incoming>

Status = <gelöschte >State = <Deleted>

Rowaction = changeoriginalRowAction = ChangeOriginal
UnchangedUnchanged Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= vorhandener >Original = <Existing>

Wenn der neue Wert mit dem vorhandenen Wert identisch ist, dannIf new value is the same as the existing value then

State = <unverändert >State = <Unchanged>

Rowaction = NothingRowAction = Nothing

ElseElse

State = <geänderte >State = <Modified>

Rowaction = ändernRowAction = Change
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Nicht vorhanden)Not present) Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= nicht verfügbar >Original = <Not available>

Status = <hinzugefügter >State = <Added>

Rowaction = hinzufügenRowAction = Add
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal

Werte in einer DataColumn können durch die Verwendung von Eigenschaften ReadOnly wie und AutoIncrementeingeschränkt werden.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. Die Load -Methode behandelt solche Spalten so, dass Sie mit dem Verhalten konsistent ist, das in den Eigenschaften der Spalte definiert ist.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Die schreibgeschützte Einschränkung für einen DataColumn gilt nur für Änderungen, die im Arbeitsspeicher auftreten.The read only constraint on a DataColumn is applicable only for changes that occur in memory. Die Load -Methode überschreibt bei Bedarf die schreibgeschützten Spaltenwerte.The Load method's overwrites the read-only column values, if needed.

Wenn Sie beim Aufrufen der Load -Methode die overwrite-oder PreserveChanges-Option angeben, wird davon ausgegangen, dass die eingehenden Daten aus der DataTableprimären Datenquelle des-Objekts stammen und die Datentabelle Änderungen nachverfolgt und weitergegeben werden kann. der wechselt zurück in die Datenquelle.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. Wenn Sie die Upsert-Option auswählen, wird davon ausgegangen, dass die Daten von einer sekundären Datenquelle stammen, z. b. von Daten, die von einer Komponente der mittleren Ebene bereitgestellt werden, die möglicherweise von einem Benutzer geändert wurde.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. In diesem Fall wird davon ausgegangen, dass die Absicht ist, Daten aus einer oder mehreren Datenquellen in DataTablezu aggregieren und die Daten dann an die primäre Datenquelle zurückzugeben.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. Der LoadOption -Parameter wird verwendet, um die spezifische Version der Zeile zu bestimmen, die für den Primärschlüssel Vergleich verwendet werden soll.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. In der folgenden Tabelle finden Sie Details.The table below provides the details.

Option LadenLoad option Für den Primärschlüssel Vergleich verwendete DataRow-VersionDataRow version used for primary key comparison
OverwriteChanges Ursprüngliche Version, falls vorhanden, andernfalls aktuelle VersionOriginal version, if it exists, otherwise Current version
PreserveChanges Ursprüngliche Version, falls vorhanden, andernfalls aktuelle VersionOriginal version, if it exists, otherwise Current version
Upsert Aktuelle Version, falls vorhanden, andernfalls Original VersionCurrent version, if it exists, otherwise Original version

Siehe auch

Load(IDataReader, LoadOption, FillErrorEventHandler)

Füllt eine DataTable mit Werten aus einer Datenquelle mit dem bereitgestellten IDataReader und unter Verwendung eines Fehlerbehandlungsdelegaten.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);
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

Parameter

reader
IDataReader

Ein IDataReader, der ein Resultset bereitstellt.A IDataReader that provides a result set.

loadOption
LoadOption

Ein Wert aus der LoadOption-Enumeration, der angibt, wie bereits in der DataTable vorhandene Zeilen mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.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

Ein FillErrorEventHandler-Delegat, der aufgerufen wird, wenn beim Laden von Daten Fehler auftreten.A FillErrorEventHandler delegate to call when an error occurs while loading data.

Beispiele

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

Hinweise

Die Load -Methode verwendet das erste Resultset aus IDataReaderdem geladenen und nach erfolgreichem Abschluss die Position des Readers auf das nächste Resultset, sofern vorhanden.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. Beim Konvertieren von Daten verwendet Load die-Methode dieselben Konvertierungsregeln wie DbDataAdapter.Fill die-Methode.When converting data, the Load method uses the same conversion rules as the DbDataAdapter.Fill method.

Die Load -Methode muss beim Laden der Daten aus einer IDataReader -Instanz drei spezifische Probleme berücksichtigen: Schema-, Daten-und Ereignis Vorgänge.The Load method must take into account three specific issues when loading the data from an IDataReader instance: schema, data, and event operations. Beim Arbeiten mit dem Schema kann die Load -Methode Bedingungen wie in der folgenden Tabelle beschrieben haben.When working with the schema, the Load method may encounter conditions as described in the following table. Die Schema Vorgänge erfolgen für alle importierten Resultsets, auch für solche, die keine Daten enthalten.The schema operations take place for all imported result sets, even those containing no data.

BedingungCondition VerhaltenBehavior
DataTable Hat kein Schema.The DataTable has no schema. Die Load Methode leitet das Schema basierend auf dem Resultset aus dem importierten IDataReaderab.The Load method infers the schema based on the result set from the imported IDataReader.
Der DataTable verfügt über ein Schema, aber es ist nicht mit dem geladenen Schema kompatibel.The DataTable has a schema, but it is incompatible with the loaded schema. Die Load -Methode löst eine Ausnahme aus, die dem jeweiligen Fehler entspricht, der auftritt, wenn versucht wird, Daten in das nicht kompatible Schema zu laden.The Load method throws an exception corresponding to the particular error that occurs when attempting to load data into the incompatible schema.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält Spalten, die in DataTablenicht vorhanden sind.The schemas are compatible, but the loaded result set schema contains columns that don't exist in the DataTable. Die Load DataTable-Methode fügt das Schema der zusätzlichen Spalte (n) hinzu.The Load method adds the extra column(s) to DataTable's schema. Die DataTable -Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten in und dem geladenen Resultset nicht Wert kompatibel sind.The method throws an exception if corresponding columns in the DataTable and the loaded result set are not value compatible. Die-Methode ruft auch Einschränkungs Informationen aus dem Resultset für alle hinzugefügten Spalten ab.The method also retrieves constraint information from the result set for all added columns. Außer bei der PRIMARY KEY-Einschränkung werden diese Einschränkungs Informationen nur verwendet, wenn der aktuelle DataTable keine Spalten am Anfang des Ladevorgangs enthält.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.
Die Schemas sind kompatibel, das geladene Resultsetschema enthält jedoch weniger Spalten, als DataTabledas-Schema enthält.The schemas are compatible, but the loaded result set schema contains fewer columns than does the DataTable. Wenn für eine fehlende Spalte ein Standardwert definiert ist, oder wenn der Datentyp der Spalte NULL- Load Werte zulässt, kann die-Methode die Zeilen hinzufügen und ersetzt die fehlende Spalte durch den Standardwert oder den Nullwert.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. Wenn kein Standardwert oder NULL verwendet werden kann, löst die Load Methode eine Ausnahme aus.If no default value or null can be used, then the Load method throws an exception. Wenn kein spezifischer Standardwert angegeben wurde, verwendet die Load Methode den NULL-Wert als impliziten Standardwert.If no specific default value has been supplied, the Load method uses the null value as the implied default value.

Bevor Sie das Verhalten Load der-Methode in Bezug auf Daten Vorgänge in Erwägung ziehen, sollten Sie Bedenken, dass jede Zeile in einer DataTable sowohl den aktuellen als auch den ursprünglichen Wert für jede Spalte beibehält.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. Diese Werte können gleichwertig sein oder abweichen, wenn die Daten in der Zeile seit dem Ausfüllen des DataTablegeändert wurden.These values may be equivalent, or may be different if the data in the row has been changed since filling the DataTable. Weitere Informationen finden Sie unter Zeilen Status und Zeilen Versionen .See Row States and Row Versions for more information.

In diesem Methoden Aufrufwert beeinflusst LoadOption der angegebene Parameter die Verarbeitung der eingehenden Daten.In this method call, the specified LoadOption parameter influences the processing of the incoming data. Wie soll die Load-Methode das Laden von Zeilen verarbeiten, die denselben Primärschlüssel wie vorhandene Zeilen aufweisen?How should the Load method handle loading rows that have the same primary key as existing rows? Sollten aktuelle Werte, ursprüngliche Werte oder beides geändert werden?Should it modify current values, original values, or both? Diese Probleme und mehr werden durch den loadOption -Parameter gesteuert.These issues, and more, are controlled by the loadOption parameter.

Wenn die vorhandene Zeile und die eingehende Zeile die entsprechenden Primärschlüssel Werte enthalten, wird die Zeile mit dem aktuellen Zeilen Zustandswert verarbeitet; andernfalls wird Sie als neue Zeile behandelt.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.

Im Hinblick auf Ereignis Vorgänge tritt das RowChanging -Ereignis auf, bevor jede Zeile geändert wird, RowChanged und das-Ereignis tritt auf, nachdem jede Zeile geändert wurde.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. In jedem Fall enthält die Action -Eigenschaft DataRowChangeEventArgs der-Instanz, die an den-Ereignishandler übermittelt wird, Informationen zu der jeweiligen Aktion, die dem Ereignis zugeordnet ist.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. Dieser Aktionswert variiert je nach Zustand der Zeile vor dem Ladevorgang.This action value varies, depending on the state of the row before the load operation. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jede der beiden Ereignisse identisch.In each case, both events occur, and the action is the same for each. Die Aktion kann je nach dem aktuellen Zeilen Status entweder auf die aktuelle oder die ursprüngliche Version der einzelnen Zeilen oder beides angewendet werden.The action may be applied to either the current or original version of each row, or both, depending on the current row state.

In der folgenden Tabelle wird das Verhalten für die Load-Methode angezeigt, wenn LoadOption Sie mit jedem der-Werte aufgerufen wird. Außerdem wird gezeigt, wie die-Werte mit dem Zeilen Status der zu ladenden Zeile interagieren.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. Die letzte Zeile (mit der Bezeichnung "(nicht vorhanden)") beschreibt das Verhalten für eingehende Zeilen, die keiner vorhandenen Zeile entsprechen.The final row (labeled "(Not present)") describes the behavior for incoming rows that don't match any existing row. Jede Zelle in dieser Tabelle beschreibt den aktuellen und den ursprünglichen Wert für ein Feld innerhalb einer Zeile zusammen mit dem DataRowState für den Wert, nachdem Load die-Methode abgeschlossen wurde.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.

Vorhandener DataRowStateExisting DataRowState UpsertUpsert OverschreitechangesOverwriteChanges PreserveChanges (Standardverhalten)PreserveChanges (Default behavior)
HinzugefügtAdded Aktuell = <eingehender >Current = <Incoming>

Original =-<nicht verfügbar >Original = -<Not available>

Status = <hinzugefügter >State = <Added>

Rowaction = ändernRowAction = Change
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Current = <vorhandener >Current = <Existing>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <geänderte >State = <Modified>

Rowaction = changeoriginalRowAction = ChangeOriginal
ModifiedModified Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= vorhandener >Original = <Existing>

State = <geänderte >State = <Modified>

Rowaction = ändernRowAction = Change
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Current = <vorhandener >Current = <Existing>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <geänderte >State = <Modified>

Rowaction = changeoriginalRowAction =ChangeOriginal
nicht verschlüsselteleted (Laden hat keine Auswirkungen auf gelöschte Zeilen)(Load does not affect deleted rows)

Aktuell =---Current = ---

Ursprünglicher <= vorhandener >Original = <Existing>

Status = <gelöschte >State = <Deleted>

(Neue Zeile mit den folgenden Eigenschaften hinzugefügt)(New row is added with the following characteristics)

Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= nicht verfügbar >Original = <Not available>

Status = <hinzugefügter >State = <Added>

Rowaction = hinzufügenRowAction = Add
Löschvorgang rückgängig machenUndo delete and

Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Aktuell = <nicht verfügbar >Current = <Not available>

Ursprünglicher <= eingehender >Original = <Incoming>

Status = <gelöschte >State = <Deleted>

Rowaction = changeoriginalRowAction = ChangeOriginal
UnchangedUnchanged Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= vorhandener >Original = <Existing>

Wenn der neue Wert mit dem vorhandenen Wert identisch ist, dannIf new value is the same as the existing value then

State = <unverändert >State = <Unchanged>

Rowaction = NothingRowAction = Nothing

ElseElse

State = <geänderte >State = <Modified>

Rowaction = ändernRowAction = Change
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Nicht vorhanden)Not present) Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= nicht verfügbar >Original = <Not available>

Status = <hinzugefügter >State = <Added>

Rowaction = hinzufügenRowAction = Add
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal
Aktuell = <eingehender >Current = <Incoming>

Ursprünglicher <= eingehender >Original = <Incoming>

State = <unverändert >State = <Unchanged>

Rowaction = changecurrentandoriginalRowAction = ChangeCurrentAndOriginal

Werte in einer DataColumn können durch die Verwendung von Eigenschaften ReadOnly wie und AutoIncrementeingeschränkt werden.Values in a DataColumn can be constrained through use of properties such as ReadOnly and AutoIncrement. Die Load -Methode behandelt solche Spalten so, dass Sie mit dem Verhalten konsistent ist, das in den Eigenschaften der Spalte definiert ist.The Load method handles such columns in a manner that is consistent with the behavior defined by the column's properties. Die schreibgeschützte Einschränkung für einen DataColumn gilt nur für Änderungen, die im Arbeitsspeicher auftreten.The read only constraint on a DataColumn is applicable only for changes that occur in memory. Die Load -Methode überschreibt bei Bedarf die schreibgeschützten Spaltenwerte.The Load method's overwrites the read-only column values, if needed.

Wenn Sie beim Aufrufen der Load -Methode die overwrite-oder PreserveChanges-Option angeben, wird davon ausgegangen, dass die eingehenden Daten aus der DataTableprimären Datenquelle des-Objekts stammen und die Datentabelle Änderungen nachverfolgt und weitergegeben werden kann. der wechselt zurück in die Datenquelle.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. Wenn Sie die Upsert-Option auswählen, wird davon ausgegangen, dass die Daten von einer sekundären Datenquelle stammen, z. b. von Daten, die von einer Komponente der mittleren Ebene bereitgestellt werden, die möglicherweise von einem Benutzer geändert wurde.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. In diesem Fall wird davon ausgegangen, dass die Absicht ist, Daten aus einer oder mehreren Datenquellen in DataTablezu aggregieren und die Daten dann an die primäre Datenquelle zurückzugeben.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. Der LoadOption -Parameter wird verwendet, um die spezifische Version der Zeile zu bestimmen, die für den Primärschlüssel Vergleich verwendet werden soll.The LoadOption parameter is used for determining the specific version of the row that is to be used for primary key comparison. In der folgenden Tabelle finden Sie Details.The table below provides the details.

Option LadenLoad option Für den Primärschlüssel Vergleich verwendete DataRow-VersionDataRow version used for primary key comparison
OverwriteChanges Ursprüngliche Version, falls vorhanden, andernfalls aktuelle VersionOriginal version, if it exists, otherwise Current version
PreserveChanges Ursprüngliche Version, falls vorhanden, andernfalls aktuelle VersionOriginal version, if it exists, otherwise Current version
Upsert Aktuelle Version, falls vorhanden, andernfalls Original VersionCurrent version, if it exists, otherwise Original version

Der errorHandler -Parameter ist FillErrorEventHandler ein Delegat, der auf eine Prozedur verweist, die aufgerufen wird, wenn beim Laden von Daten ein Fehler auftritt.The errorHandler parameter is a FillErrorEventHandler delegate that refers to a procedure that is called when an error occurs while loading data. Der FillErrorEventArgs -Parameter, der an die Prozedur übergeben wird, bietet Eigenschaften, mit denen Sie Informationen zu dem aufgetretenen Fehler, der aktuellen Daten Zeile DataTable und dem ausgefüllten abrufen können.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. Wenn Sie diesen Delegatmechanismus anstelle eines einfacheren try/catch-Blocks verwenden, können Sie den Fehler ermitteln, die Situation behandeln und die Verarbeitung fortsetzen, wenn Sie möchten.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. Der FillErrorEventArgs -Parameter stellt Continue eine Eigenschaft bereit: Legen Sie true diese Eigenschaft auf fest, um anzugeben, dass Sie den Fehler behandelt haben und die Verarbeitung fortsetzen möchten.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. Legen Sie die- false Eigenschaft auf fest, um anzugeben, dass die Verarbeitung angehalten werden soll.Set the property to false to indicate that you wish to halt processing. Beachten Sie, dass das Festlegen der false -Eigenschaft auf bewirkt, dass der Code, der das Problem ausgelöst hat, eine Ausnahme auslöst.Be aware that setting the property to false causes the code that triggered the problem to throw an exception.

Siehe auch

Gilt für: