DataTable.Load Methode

Referenz

Definition

Namespace:: System.Data

Assembly:: System.Data.Common.dll

Assembly:: System.Data.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.

Überlädt

Load(IDataReader)	Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.
Load(IDataReader, LoadOption)	Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet. 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.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Füllt eine DataTable mit Werten aus einer Datenquelle mit dem bereitgestellten IDataReader und unter Verwendung eines Fehlerbehandlungsdelegaten.

Beispiele

Im folgenden Beispiel werden mehrere der Probleme veranschaulicht, die mit dem Aufrufen der Load -Methode verbunden sind. Zunächst konzentriert sich das Beispiel auf Schemaprobleme, z. B. das Ableiten eines Schemas aus dem geladenen IDataReaderund dann die Behandlung inkompatibler Schemas und Schemas mit fehlenden oder zusätzlichen Spalten. Das Beispiel konzentriert sich dann auf Datenprobleme, einschließlich der Behandlung der verschiedenen Ladeoptionen.

Hinweis

In diesem Beispiel wird gezeigt, wie Sie eine der überladenen Versionen von Loadverwenden. Weitere Beispiele, die möglicherweise verfügbar sind, finden Sie in den einzelnen Überladungsthemen.

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 mehreren gängigen Szenarien verwendet werden, die alle um das Abrufen von Daten aus einer angegebenen Datenquelle und das Hinzufügen sie zum aktuellen Datencontainer (in diesem Fall ein DataTable) zentriert werden. In diesen Szenarien wird die Standardverwendung für eine DataTablebeschrieben, die das Update- und Mergeverhalten beschreibt.

Ein DataTable synchronisiert oder aktualisiert mit einer einzelnen primären Datenquelle. Die DataTable Änderungen werden nachverfolgt, sodass die Synchronisierung mit der primären Datenquelle möglich ist. Darüber hinaus kann ein DataTable inkrementelle Daten aus einer oder mehreren sekundären Datenquellen akzeptieren. Der DataTable ist nicht für die Nachverfolgung von Änderungen verantwortlich, um die Synchronisierung mit der sekundären Datenquelle zuzulassen.

Angesichts dieser beiden hypothetischen Datenquellen benötigt ein Benutzer wahrscheinlich eines der folgenden Verhaltensweisen:

Initialisieren Sie aus DataTable einer primären Datenquelle. In diesem Szenario möchte der Benutzer eine leere DataTable mit Werten aus der primären Datenquelle initialisieren. Später möchte der Benutzer Änderungen zurück an die primäre Datenquelle weitergeben.
Behalten Sie Änderungen bei, und synchronisieren Sie sie erneut aus der primären Datenquelle. In diesem Szenario möchte der Benutzer die DataTable im vorherigen Szenario ausgefüllte übernehmen und eine inkrementelle Synchronisierung mit der primären Datenquelle durchführen, wobei änderungen beibehalten werden, die in der DataTablevorgenommen wurden.
Inkrementeller Datenfeed aus sekundären Datenquellen. In diesem Szenario möchte der Benutzer Änderungen aus einer oder mehreren sekundären Datenquellen zusammenführen und diese Änderungen zurück an die primäre Datenquelle weitergeben.

Die Load Methode ermöglicht all diese Szenarien. Mit Allen Überladungen für diese Methode können Sie einen Ladeoptionsparameter angeben, der angibt, wie Zeilen, die bereits in einer DataTable Methode enthalten sind, mit geladenen Zeilen kombiniert werden. (Die Überladung, bei der Sie das Verhalten nicht angeben können, verwendet die Standardladeoption.) In der folgenden Tabelle werden die drei Ladeoptionen beschrieben, die von der LoadOption Enumeration bereitgestellt werden. 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.

Option "Laden"	Beschreibung
`PreserveChanges` (Standardwert)	Updates die ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile.
`OverwriteChanges`	Updates die aktuelle und ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile.
`Upsert`	Updates die aktuelle Version der Zeile mit dem Wert der eingehenden Zeile.

Im Allgemeinen sind die PreserveChanges Optionen und OverwriteChanges für Szenarien vorgesehen, in denen der Benutzer die DataSet Änderungen und ihre Änderungen mit der primären Datenquelle synchronisieren muss. Die Upsert Option erleichtert das Aggregieren von Änderungen aus einer oder mehreren sekundären Datenquellen.

Load(IDataReader)

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet. Wenn die DataTable bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.

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.

Beispiele

Im folgenden Beispiel werden mehrere der Probleme veranschaulicht, die mit dem Aufrufen der Load -Methode verbunden sind. Zunächst konzentriert sich das Beispiel auf Schemaprobleme, z. B. das Ableiten eines Schemas aus dem geladenen IDataReaderund dann die Behandlung inkompatibler Schemas und Schemas mit fehlenden oder zusätzlichen Spalten. Das Beispiel ruft dann die Load -Methode auf und zeigt die Daten sowohl vor als auch nach dem Ladevorgang an.

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 dem geladenen IDataReaderund legt nach erfolgreichem Abschluss die Position des Lesers auf das nächste Resultset fest, falls vorhanden. Beim Konvertieren von Daten verwendet die Load -Methode die gleichen Konvertierungsregeln wie die DbDataAdapter.Fill -Methode.

Die Load -Methode muss beim Laden der Daten aus einem IDataReader instance drei spezifische Probleme berücksichtigen: Schema-, Daten- und Ereignisvorgänge. Bei der Arbeit mit dem Schema kann die Load -Methode bedingungen treffen, wie in der folgenden Tabelle beschrieben. Die Schemavorgänge finden für alle importierten Resultsets statt, auch für solche, die keine Daten enthalten.

Bedingung	Verhalten
Hat DataTable kein Schema.	Die Load -Methode leitet das Schema basierend auf dem Resultset aus dem importierten IDataReaderab.
verfügt DataTable über ein Schema, ist aber mit dem geladenen Schema nicht kompatibel.	Die Load -Methode löst eine Ausnahme aus, die dem bestimmten Fehler entspricht, der beim Laden von Daten in das inkompatible Schema auftritt.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält Spalten, die DataTablein nicht vorhanden sind.	Die Load -Methode fügt dem Schema des -Schemas die zusätzlichen Spalten hinzu `DataTable`. Die -Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten in und DataTable im geladenen Resultset nicht wertkompatibel sind. Die -Methode ruft auch Einschränkungsinformationen aus dem Resultset für alle hinzugefügten Spalten ab. Mit Ausnahme der Primärschlüsseleinschränkung werden diese Einschränkungsinformationen nur verwendet, wenn die aktuelle DataTable am Anfang des Ladevorgangs keine Spalten enthält.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält weniger Spalten als das `DataTable`.	Wenn für eine fehlende Spalte ein Standardwert definiert ist oder der Datentyp der Spalte NULL-Werte zulässt, ermöglicht die Load -Methode das Hinzufügen der Zeilen, wobei der Standardwert oder `null` der Wert für die fehlende Spalte ersetzt wird. Wenn kein Standardwert verwendet werden kann oder `null` verwendet werden kann, löst die `Load` -Methode eine Ausnahme aus. Wenn kein bestimmter Standardwert angegeben wurde, verwendet die `Load` Methode den `null` Wert als implizierten Standardwert.

Bevor Sie das Verhalten der Load -Methode in Bezug auf Datenvorgänge berücksichtigen, sollten Sie berücksichtigen, dass jede Zeile in einem DataTable sowohl den aktuellen Wert als auch den ursprünglichen Wert für jede Spalte beibehält. Diese Werte können gleichwertig sein oder sich unterscheiden, wenn die Daten in der Zeile seit dem Füllen von DataTablegeändert wurden. Weitere Informationen finden Sie unter Zeilenstatus und Zeilenversionen.

Diese Version der Load Methode versucht, die aktuellen Werte in jeder Zeile beizubehalten, sodass der ursprüngliche Wert intakt bleibt. (Wenn Sie das Verhalten eingehender Daten genauer steuern möchten, lesen Sie DataTable.Load.) Wenn die vorhandene Zeile und die eingehende Zeile entsprechende Primärschlüsselwerte enthalten, wird die Zeile mit ihrem aktuellen Zeilenzustandswert verarbeitet, andernfalls wird sie als neue Zeile behandelt.

In Bezug auf Ereignisvorgänge tritt das RowChanging Ereignis auf, bevor jede Zeile geändert wird, und das RowChanged Ereignis tritt auf, nachdem jede Zeile geändert wurde. In jedem Fall enthält die Action -Eigenschaft des DataRowChangeEventArgs an den Ereignishandler übergebenen instance Informationen zu der bestimmten Aktion, die dem Ereignis zugeordnet ist. Dieser Aktionswert hängt vom Zustand der Zeile vor dem Ladevorgang ab. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jedes die gleiche. Die Aktion kann abhängig vom aktuellen Zeilenstatus entweder auf die aktuelle oder ursprüngliche Version jeder Zeile oder auf beides angewendet werden.

In der folgenden Tabelle wird das Verhalten für die Load -Methode angezeigt. Die letzte Zeile (mit der Bezeichnung "(Nicht vorhanden)") beschreibt das Verhalten für eingehende Zeilen, die keiner vorhandenen Zeile entsprechen. Jede Zelle in dieser Tabelle beschreibt den aktuellen und ursprünglichen Wert für ein Feld innerhalb einer Zeile sowie den für den DataRowState Wert, nachdem die Load Methode abgeschlossen wurde. In diesem Fall lässt die -Methode nicht zu, die Option zum Laden anzugeben, und verwendet den Standardwert PreserveChanges.

Vorhandenes DataRowState	Werte nach `Load` Methode und Ereignisaktion
hinzugefügt	Current = <Existing> Original = <Eingehender> Status = <Geändert> RowAction = ChangeOriginal
Geändert	Current = <Existing> Original = <Eingehender> Status = <Geändert> RowAction = ChangeOriginal
Deleted	Aktuell = <Nicht verfügbar> Original = <Eingehender> State = <Deleted> RowAction = ChangeOriginal
Unverändert	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal
(Nicht vorhanden)	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal

Werte in einem DataColumn können durch Verwendung von Eigenschaften wie ReadOnly und AutoIncrementeingeschränkt werden. Die Load -Methode behandelt solche Spalten auf eine Weise, die mit dem durch die Eigenschaften der Spalte definierten Verhalten konsistent ist. Die schreibgeschützte Einschränkung für ein DataColumn gilt nur für Änderungen, die im Arbeitsspeicher auftreten. Die Load -Methode überschreibt bei Bedarf die schreibgeschützten Spaltenwerte.

Um zu bestimmen, welche Version des Primärschlüsselfelds zum Vergleichen der aktuellen Zeile mit einer eingehenden Zeile verwendet werden soll, verwendet die Load Methode die ursprüngliche Version des Primärschlüsselwerts innerhalb einer Zeile, sofern vorhanden. Andernfalls verwendet die Load -Methode die aktuelle Version des Primärschlüsselfelds.

Weitere Informationen

Gilt für:

Load(IDataReader, LoadOption)

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Füllt eine DataTable mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet. 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.

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

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

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

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

Parameter

reader: IDataReader

Ein IDataReader, der ein oder mehrere Resultsets bereitstellt.

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.

Beispiele

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 dem geladenen IDataReaderund legt nach erfolgreicher Fertigstellung die Position des Lesers auf das nächste Resultset fest, falls vorhanden. Beim Konvertieren von Daten verwendet die Load Methode dieselben Konvertierungsregeln wie die Fill -Methode.

Die Load Methode muss drei spezifische Probleme beim Laden der Daten aus einem IDataReader instance berücksichtigen: Schema-, Daten- und Ereignisvorgänge. Wenn Sie mit dem Schema arbeiten, kann die Load -Methode auf Bedingungen stoßen, die in der folgenden Tabelle beschrieben sind. Die Schemavorgänge finden für alle importierten Resultsets statt, auch für solche, die keine Daten enthalten.

Bedingung	Verhalten
Hat DataTable kein Schema.	Die `Load` -Methode leitet das Schema basierend auf dem Resultset aus dem importierten IDataReaderab.
Das DataTable hat ein Schema, ist aber mit dem geladenen Schema nicht kompatibel.	Die `Load` -Methode löst eine Ausnahme aus, die dem bestimmten Fehler entspricht, der beim Laden von Daten in das inkompatible Schema auftritt.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält Spalten, die `DataTable`in nicht vorhanden sind.	Die `Load` -Methode fügt dem Schema die zusätzlichen Spalten hinzu `DataTable`. Die -Methode löst eine Ausnahme aus, wenn entsprechende Spalten in und DataTable im geladenen Resultset nicht wertkompatibel sind. Die -Methode ruft auch Einschränkungsinformationen aus dem Resultset für alle hinzugefügten Spalten ab. Mit Ausnahme der Primärschlüsseleinschränkung werden diese Einschränkungsinformationen nur verwendet, wenn die aktuelle DataTable zu Beginn des Ladevorgangs keine Spalten enthält.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält weniger Spalten als das `DataTable`.	Wenn für eine fehlende Spalte ein Standardwert definiert ist oder der Datentyp der Spalte nullable ist, ermöglicht die `Load` -Methode das Hinzufügen der Zeilen, wobei der Standardwert oder null-Wert für die fehlende Spalte ersetzt wird. Wenn kein Standardwert oder NULL verwendet werden kann, löst die `Load` Methode eine Ausnahme aus. Wenn kein bestimmter Standardwert angegeben wurde, verwendet die `Load` Methode den NULL-Wert als impliziten Standardwert.

Bevor Sie das Verhalten der Load -Methode in Bezug auf Datenvorgänge berücksichtigen, sollten Sie berücksichtigen, dass jede Zeile in einem DataTable sowohl den aktuellen Wert als auch den ursprünglichen Wert für jede Spalte verwaltet. Diese Werte können gleichwertig sein oder sich unterscheiden, wenn die Daten in der Zeile seit dem Ausfüllen von DataTablegeändert wurden. Weitere Informationen finden Sie unter Zeilenzustände und Zeilenversionen .

In diesem Methodenaufruf beeinflusst der angegebene LoadOption Parameter die Verarbeitung der eingehenden Daten. Wie sollte die Load-Methode das Laden von Zeilen behandeln, die denselben Primärschlüssel wie vorhandene Zeilen haben? Sollten aktuelle Werte, ursprüngliche Werte oder beides geändert werden? Diese und weitere Probleme werden durch den loadOption -Parameter gesteuert.

Wenn die vorhandene Zeile und die eingehende Zeile entsprechende Primärschlüsselwerte enthalten, wird die Zeile mit ihrem aktuellen Zeilenstatuswert verarbeitet, andernfalls wird sie als neue Zeile behandelt.

In Bezug auf Ereignisvorgänge tritt das RowChanging Ereignis auf, bevor jede Zeile geändert wird, und das RowChanged Ereignis tritt auf, nachdem jede Zeile geändert wurde. In jedem Fall enthält die Action An den Ereignishandler übergebene Eigenschaft des DataRowChangeEventArgs instance Informationen zu der bestimmten Aktion, die dem Ereignis zugeordnet ist. Dieser Aktionswert variiert je nach Zustand der Zeile vor dem Ladevorgang. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jedes die gleiche. Die Aktion kann je nach aktuellem Zeilenstatus auf die aktuelle oder ursprüngliche Version jeder Zeile oder beides angewendet werden.

Die folgende Tabelle zeigt das Verhalten für die Load-Methode, wenn sie mit jedem der LoadOption Werte aufgerufen wird, und zeigt auch, wie die Werte mit dem Zeilenzustand für die geladene Zeile interagieren. Die letzte Zeile (mit der Bezeichnung "(Nicht vorhanden)") beschreibt das Verhalten für eingehende Zeilen, die keiner vorhandenen Zeile entsprechen. Jede Zelle in dieser Tabelle beschreibt den aktuellen und ursprünglichen Wert für ein Feld in einer Zeile zusammen mit dem DataRowState für den Wert, nachdem die Load Methode abgeschlossen wurde.

Vorhandener DataRowState	Upsert	ÜberschreibenÄnderungen	PreserveChanges (Standardverhalten)
hinzugefügt	Current = <Incoming> Original = -<Nicht verfügbar> Status = <Hinzugefügt> RowAction = Change	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> Status = <Geändert> RowAction = ChangeOriginal
Geändert	Current = <Incoming> Original = <Vorhandene> Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> Status = <Geändert> RowAction =ChangeOriginal
Deleted	(Das Laden wirkt sich nicht auf gelöschte Zeilen aus.) Current = --- Original = <Vorhandene> Zustand = <Gelöscht> (Neue Zeile wird mit den folgenden Merkmalen hinzugefügt)) Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Hinzufügen	Löschen und rückgängig Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Aktuell = <Nicht verfügbar> Original = <Incoming> Zustand = <Gelöscht> RowAction = ChangeOriginal
Unverändert	Current = <Incoming> Original = <Vorhandene> Wenn der neue Wert mit dem vorhandenen Wert identisch ist, dann Zustand = <Unverändert> RowAction = Nothing Else Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal
Nicht vorhanden)	Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Hinzufügen	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal

Werte in einem DataColumn können durch Die Verwendung von Eigenschaften wie ReadOnly und AutoIncrementeingeschränkt werden. Die Load -Methode verarbeitet solche Spalten in einer Weise, die mit dem durch die Eigenschaften der Spalte definierten Verhalten konsistent ist. Die schreibgeschützte Einschränkung für ein DataColumn gilt nur für Änderungen, die im Arbeitsspeicher auftreten. Die Load Methode überschreibt bei Bedarf die schreibgeschützten Spaltenwerte.

Wenn Sie beim Aufrufen der -Methode die Load Optionen OverwriteChanges oder PreserveChanges angeben, wird davon ausgegangen, dass die eingehenden Daten aus der primären Datenquelle stammen DataTable, und die DataTable verfolgt Änderungen nach und kann die Änderungen zurück an die Datenquelle weitergeben. Wenn Sie die Option Upsert auswählen, wird davon ausgegangen, dass die Daten aus einer sekundären Datenquelle stammen, z. B. Daten, die von einer Komponente der mittleren Ebene bereitgestellt werden und möglicherweise von einem Benutzer geändert werden. In diesem Fall wird davon ausgegangen, dass die Absicht darin besteht, Daten aus einer oder mehreren Datenquellen im DataTablezu aggregieren und die Daten dann möglicherweise wieder an die primäre Datenquelle weiterzuverbreiten. Der LoadOption Parameter wird verwendet, um die spezifische Version der Zeile zu bestimmen, die für den Primärschlüsselvergleich verwendet werden soll. Die folgende Tabelle enthält die Details.

Option "Laden"	DataRow-Version, die für den Primärschlüsselvergleich verwendet wird
`OverwriteChanges`	Originalversion, falls vorhanden, andernfalls Aktuelle Version
`PreserveChanges`	Originalversion, falls vorhanden, andernfalls Aktuelle Version
`Upsert`	Aktuelle Version, falls vorhanden, andernfalls Originalversion

Weitere Informationen

Gilt für:

Load(IDataReader, LoadOption, FillErrorEventHandler)

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Füllt eine DataTable mit Werten aus einer Datenquelle mit dem bereitgestellten IDataReader und unter Verwendung eines Fehlerbehandlungsdelegaten.

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

public virtual void Load (System.Data.IDataReader reader, System.Data.LoadOption loadOption, System.Data.FillErrorEventHandler? errorHandler);

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

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

Public Overridable Sub Load (reader As IDataReader, loadOption As LoadOption, errorHandler As FillErrorEventHandler)

Parameter

reader: IDataReader

Ein IDataReader, der ein Resultset bereitstellt.

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.

errorHandler: FillErrorEventHandler

Ein FillErrorEventHandler-Delegat, der aufgerufen wird, wenn beim Laden von Daten Fehler auftreten.

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

Bedingung	Verhalten
Hat DataTable kein Schema.	Die `Load` -Methode leitet das Schema basierend auf dem Resultset aus dem importierten IDataReaderab.
Das DataTable hat ein Schema, ist aber mit dem geladenen Schema nicht kompatibel.	Die `Load` -Methode löst eine Ausnahme aus, die dem bestimmten Fehler entspricht, der beim Laden von Daten in das inkompatible Schema auftritt.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält Spalten, die `DataTable`in nicht vorhanden sind.	Die `Load` -Methode fügt dem Schema die zusätzlichen Spalten hinzu `DataTable`. Die -Methode löst eine Ausnahme aus, wenn entsprechende Spalten in und DataTable im geladenen Resultset nicht wertkompatibel sind. Die -Methode ruft auch Einschränkungsinformationen aus dem Resultset für alle hinzugefügten Spalten ab. Mit Ausnahme der Primärschlüsseleinschränkung werden diese Einschränkungsinformationen nur verwendet, wenn die aktuelle DataTable zu Beginn des Ladevorgangs keine Spalten enthält.
Die Schemas sind kompatibel, aber das geladene Resultsetschema enthält weniger Spalten als das `DataTable`.	Wenn für eine fehlende Spalte ein Standardwert definiert ist oder der Datentyp der Spalte nullable ist, ermöglicht die `Load` -Methode das Hinzufügen der Zeilen, wobei der Standardwert oder null-Wert für die fehlende Spalte ersetzt wird. Wenn kein Standardwert oder NULL verwendet werden kann, löst die `Load` Methode eine Ausnahme aus. Wenn kein bestimmter Standardwert angegeben wurde, verwendet die `Load` Methode den NULL-Wert als impliziten Standardwert.

Bevor Sie das Verhalten der Load -Methode in Bezug auf Datenvorgänge berücksichtigen, sollten Sie berücksichtigen, dass jede Zeile in einem DataTable sowohl den aktuellen Wert als auch den ursprünglichen Wert für jede Spalte verwaltet. Diese Werte können gleichwertig sein oder sich unterscheiden, wenn die Daten in der Zeile seit dem Ausfüllen von DataTablegeändert wurden. Weitere Informationen finden Sie unter Zeilenzustände und Zeilenversionen .

In Bezug auf Ereignisvorgänge tritt das RowChanging Ereignis auf, bevor jede Zeile geändert wird, und das RowChanged Ereignis tritt auf, nachdem jede Zeile geändert wurde. In jedem Fall enthält die Action An den Ereignishandler übergebene Eigenschaft des DataRowChangeEventArgs instance Informationen zu der bestimmten Aktion, die dem Ereignis zugeordnet ist. Dieser Aktionswert variiert je nach Zustand der Zeile vor dem Ladevorgang. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jedes die gleiche. Die Aktion kann je nach aktuellem Zeilenstatus auf die aktuelle oder ursprüngliche Version jeder Zeile oder beides angewendet werden.

Vorhandener DataRowState	Upsert	ÜberschreibenÄnderungen	PreserveChanges (Standardverhalten)
hinzugefügt	Current = <Incoming> Original = -<Nicht verfügbar> Status = <Hinzugefügt> RowAction = Change	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> Status = <Geändert> RowAction = ChangeOriginal
Geändert	Current = <Incoming> Original = <Vorhandene> Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Incoming> Status = <Geändert> RowAction =ChangeOriginal
eleted	(Das Laden wirkt sich nicht auf gelöschte Zeilen aus.) Current = --- Original = <Vorhandene> Zustand = <Gelöscht> (Neue Zeile wird mit den folgenden Merkmalen hinzugefügt)) Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Hinzufügen	Löschen und rückgängig Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Aktuell = <Nicht verfügbar> Original = <Incoming> Zustand = <Gelöscht> RowAction = ChangeOriginal
Unverändert	Current = <Incoming> Original = <Vorhandene> Wenn der neue Wert mit dem vorhandenen Wert identisch ist, dann Zustand = <Unverändert> RowAction = Nothing Else Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal
Nicht vorhanden)	Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Hinzufügen	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Incoming> Zustand = <Unverändert> RowAction = ChangeCurrentAndOriginal

Option "Laden"	DataRow-Version, die für den Primärschlüsselvergleich verwendet wird
`OverwriteChanges`	Originalversion, falls vorhanden, andernfalls Aktuelle Version
`PreserveChanges`	Originalversion, falls vorhanden, andernfalls Aktuelle Version
`Upsert`	Aktuelle Version, falls vorhanden, andernfalls Originalversion

Der errorHandler Parameter ist ein FillErrorEventHandler Delegat, der auf eine Prozedur verweist, die aufgerufen wird, wenn beim Laden von Daten ein Fehler auftritt. Der FillErrorEventArgs an die Prozedur übergebene Parameter stellt Eigenschaften bereit, mit denen Sie Informationen über den aufgetretenen Fehler, die aktuelle Datenzeile und die DataTable gefüllte Datenzeile abrufen können. 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. Der FillErrorEventArgs Parameter stellt eine Continue Eigenschaft bereit: Legen Sie diese Eigenschaft auf fest true , um anzugeben, dass Sie den Fehler verarbeitet haben und die Verarbeitung fortsetzen möchten. Legen Sie die -Eigenschaft auf fest false , um anzugeben, dass Sie die Verarbeitung beenden möchten. Beachten Sie, dass das Festlegen der Eigenschaft auf false dazu führt, dass der Code, der das Problem ausgelöst hat, eine Ausnahme auslöst.

Weitere Informationen

Gilt für:

DataTable.Load Methode

Definition

Überlädt

Beispiele

Hinweise

Load(IDataReader)

Parameter

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Load(IDataReader, LoadOption)

Parameter

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Load(IDataReader, LoadOption, FillErrorEventHandler)

Parameter

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Feedback

Zusätzliche Ressourcen