DataTable.Load Methode

Definition

Namespace:: System.Data

Assemblys:: netstandard.dll, System.Data.Common.dll

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 einen DataTable Wert mit Werten aus einer Datenquelle mithilfe der angegebenen IDataReader. Wenn die DataTable bereits Vorhandenen Zeilen enthalten, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.

Überlädt

Name	Beschreibung
Load(IDataReader)	Füllt einen DataTable Wert mit Werten aus einer Datenquelle mithilfe der angegebenen IDataReader. Wenn die DataTable bereits Vorhandenen Zeilen enthalten, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.
Load(IDataReader, LoadOption)	Füllt einen DataTable Wert mit Werten aus einer Datenquelle mithilfe der angegebenen IDataReader. Wenn die `DataTable` bereits Vorhandenen Zeilen enthalten, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen gemäß dem Wert des `loadOption` Parameters zusammengeführt.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Füllt einen DataTable Wert mit Werten aus einer Datenquelle mithilfe des bereitgestellten IDataReader Fehlerbehandlungsdelegats aus.

Beispiele

Im folgenden Beispiel werden einige der Probleme veranschaulicht, die mit dem Aufrufen der Load Methode verbunden sind. Zunächst konzentriert sich das Beispiel auf Schemaprobleme, einschließlich des Ableitens eines Schemas aus dem geladenen IDataReaderSchema und anschließender 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 Load. Weitere Beispiele, die verfügbar sein können, 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, wobei sich alles um das Abrufen von Daten aus einer angegebenen Datenquelle zentriert und dem aktuellen Datencontainer hinzugefügt werden kann (in diesem Fall a DataTable). In diesen Szenarien wird die Standardverwendung für ein DataTableUpdate- und Zusammenführungsverhalten beschrieben.

Eine DataTable Synchronisierung oder Aktualisierung 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 eine DataTable inkrementelle Daten aus einer oder mehreren sekundären Datenquellen akzeptiert werden. Dies DataTable ist nicht für das Nachverfolgen von Änderungen verantwortlich, um die Synchronisierung mit der sekundären Datenquelle zu ermöglichen.

Angesichts dieser beiden hypothetischen Datenquellen erfordert ein Benutzer wahrscheinlich eins der folgenden Verhaltensweisen:

Initialisieren DataTable sie aus einer primären Datenquelle. In diesem Szenario möchte der Benutzer ein leeres DataTable Objekt mit Werten aus der primären Datenquelle initialisieren. Später beabsichtigt der Benutzer, Änderungen an die primäre Datenquelle zurückzuverbreiten.
Änderungen beibehalten und aus der primären Datenquelle erneut synchronisieren. In diesem Szenario möchte der Benutzer das DataTable ausgefüllte Szenario übernehmen und eine inkrementelle Synchronisierung mit der primären Datenquelle durchführen, wobei änderungen beibehalten werden, die in der DataTable.
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 an die primäre Datenquelle weitergeben.

Die Load Methode ermöglicht all diese Szenarien. Mit einer der Überladungen für diese Methode können Sie einen Parameter für die Ladeoption angeben, der angibt, wie Zeilen bereits in einer DataTable Kombination mit geladenen Zeilen vorhanden sind. (Die Überladung, die es Ihnen nicht erlaubt, das Verhalten anzugeben, 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)	Aktualisiert die ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile.
`OverwriteChanges`	Aktualisiert die aktuellen und ursprünglichen Versionen der Zeile mit dem Wert der eingehenden Zeile.
`Upsert`	Aktualisiert die aktuelle Version der Zeile mit dem Wert der eingehenden Zeile.

Im Allgemeinen sind die PreserveChanges Optionen OverwriteChanges für Szenarien vorgesehen, in denen der Benutzer die DataSet Ä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

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Füllt einen DataTable Wert mit Werten aus einer Datenquelle mithilfe der angegebenen IDataReader. Wenn die DataTable bereits Vorhandenen Zeilen enthalten, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.

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

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

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

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

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

Public Sub Load (reader As IDataReader)

Parameter

reader: IDataReader

Ein IDataReader Ergebnissatz, der ein Resultset bereitstellt.

Attribute: RequiresUnreferencedCodeAttribute

Beispiele

Im folgenden Beispiel werden einige der Probleme veranschaulicht, die mit dem Aufrufen der Load Methode verbunden sind. Zunächst konzentriert sich das Beispiel auf Schemaprobleme, einschließlich des Ableitens eines Schemas aus dem geladenen IDataReaderSchema und anschließender Behandlung inkompatibler Schemas und Schemas mit fehlenden oder zusätzlichen Spalten. Anschließend ruft das Beispiel die Load Methode auf und zeigt die Daten vor und 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 IDataReaderErgebnissatz und 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 DbDataAdapter.Fill Methode.

Die Load Methode muss drei spezifische Probleme beim Laden der Daten aus einer IDataReader Instanz berücksichtigen: Schema-, Daten- und Ereignisvorgänge. Beim Arbeiten mit dem Schema kann die Load Methode Bedingungen wie in der folgenden Tabelle beschrieben auftreten. Die Schemavorgänge werden für alle importierten Resultsets ausgeführt, auch wenn sie keine Daten enthalten.

Zustand	Verhalten
Das DataTable Schema ist nicht vorhanden.	Die Load Methode leitet das Schema basierend auf dem Resultset aus dem importierten ab IDataReader.
Das DataTable Schema weist ein Schema auf, ist jedoch nicht mit dem geladenen Schema 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, das geladene Resultsetschema enthält jedoch Spalten, die in der DataTableDatei nicht vorhanden sind.	Die Load Methode fügt die zusätzlichen Spalten zum Schema hinzu `DataTable`. Die Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten im DataTable Und das geladene 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 der aktuelle DataTable Wert keine Spalten am Anfang des Ladevorgangs enthält.
Die Schemas sind kompatibel, das geladene Resultsetschema enthält jedoch weniger Spalten als die `DataTable`.	Wenn eine fehlende Spalte einen Standardwert definiert hat oder der Datentyp der Spalte NULL-Werte aufweist, kann die Load Methode die Zeilen hinzufügen und den Standardwert `null` für die fehlende Spalte ersetzen. 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 im Hinblick auf Datenvorgänge berücksichtigen, sollten Sie berücksichtigen, dass jede Zeile innerhalb eines DataTable Werts sowohl den aktuellen Wert als auch den ursprünglichen Wert für jede Spalte verwaltet. Diese Werte können gleichwertig sein oder anders sein, wenn die Daten in der Zeile seit dem Ausfüllen DataTablegeändert wurden. Weitere Informationen finden Sie unter Zeilenzustände 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 dem aktuellen Zeilenstatuswert verarbeitet, andernfalls wird sie als neue Zeile behandelt.

Im Hinblick 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 der DataRowChangeEventArgs Instanz, die an den Ereignishandler übergeben wird, Informationen zu der bestimmten Aktion, die dem Ereignis zugeordnet ist. Dieser Aktionswert hängt vom Status der Zeile vor dem Ladevorgang ab. In jedem Fall treten beide Ereignisse auf, und die Aktion ist für jedes Ereignis identisch. Die Aktion kann abhängig vom aktuellen Zeilenzustand auf die aktuelle oder die ursprüngliche Version jeder Zeile oder 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 DataRowState Wert für den Wert, nachdem die Load Methode abgeschlossen wurde. In diesem Fall lässt die Methode nicht zu, dass Sie die Ladeoption angeben und die Standardeinstellung verwendet. PreserveChanges

Vorhandene 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
Gelöscht	Current = <Nicht verfügbar> Original = <Eingehender> Status = <Gelöscht> 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 Die Verwendung von Eigenschaften wie ReadOnly und AutoIncrement. Die Load Methode behandelt solche Spalten auf eine Weise, die mit dem verhalten konsistent ist, das durch die Eigenschaften der Spalte definiert wird. Die Schreibschutzeinschränkung für eine DataColumn gilt nur für Änderungen, die im Arbeitsspeicher auftreten. Bei Bedarf überschreibt die Load Methode die schreibgeschützten Spaltenwerte.

Um zu ermitteln, 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

Quelle:: DataTable.cs

Quelle:: DataTable.cs

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

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

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

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

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

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

Parameter

reader: IDataReader

Ein IDataReader Ergebnissatz, der mindestens ein Resultsets bereitstellt.

loadOption: LoadOption

Ein Wert aus der Aufzählung, der LoadOption angibt, wie Zeilen bereits in der DataTable Auflistung mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.

Attribute: RequiresUnreferencedCodeAttribute

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 IDataReaderErgebnissatz und 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 einer IDataReader Instanz berücksichtigen: Schema-, Daten- und Ereignisvorgänge. Beim Arbeiten mit dem Schema kann die Load Methode Bedingungen wie in der folgenden Tabelle beschrieben auftreten. Die Schemavorgänge werden für alle importierten Resultsets ausgeführt, auch wenn sie keine Daten enthalten.

Zustand	Verhalten
Das DataTable Schema ist nicht vorhanden.	Die `Load` Methode leitet das Schema basierend auf dem Resultset aus dem importierten ab IDataReader.
Das DataTable Schema weist ein Schema auf, ist jedoch nicht mit dem geladenen Schema 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, das geladene Resultsetschema enthält jedoch Spalten, die in der `DataTable`Datei nicht vorhanden sind.	Die `Load` Methode fügt die zusätzlichen Spalten zum Schema hinzu `DataTable`. Die Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten im DataTable Und das geladene 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 der aktuelle DataTable Wert keine Spalten am Anfang des Ladevorgangs enthält.
Die Schemas sind kompatibel, das geladene Resultsetschema enthält jedoch weniger Spalten als die `DataTable`.	Wenn eine fehlende Spalte einen Standardwert definiert hat oder der Datentyp der Spalte NULL-Werte aufweist, kann die `Load` Methode die Zeilen hinzufügen und den Standard- oder Nullwert für die fehlende Spalte ersetzen. 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.

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 aufweisen? Sollen aktuelle Werte, ursprüngliche Werte oder beides geändert werden? Diese Probleme und vieles mehr werden vom loadOption Parameter gesteuert.

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

Im Hinblick 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 der DataRowChangeEventArgs Instanz, die an den Ereignishandler übergeben wird, 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 Ereignis identisch. Die Aktion kann abhängig vom aktuellen Zeilenzustand auf die aktuelle oder die ursprüngliche Version jeder Zeile oder beides angewendet werden.

In der folgenden Tabelle wird das Verhalten für die Load-Methode angezeigt, wenn sie mit jedem der LoadOption Werte aufgerufen wird, und zeigt außerdem, wie die Werte mit dem Zeilenstatus 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 innerhalb einer Zeile sowie den DataRowState Wert für den Wert, nachdem die Load Methode abgeschlossen wurde.

Vorhandene DataRowState	Upsert	OverwriteChanges	PreserveChanges (Standardverhalten)
Hinzugefügt	Current = <Incoming> Original = -<Nicht verfügbar> Status = <Hinzugefügt> RowAction = Change	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Eingehender> Status = <Geändert> RowAction = ChangeOriginal
Geändert	Current = <Incoming> Original = <Vorhanden> Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Eingehender> Status = <Geändert> RowAction =ChangeOriginal
Gelöscht	(Laden wirkt sich nicht auf gelöschte Zeilen aus) Current = --- Original = <Vorhanden> Status = <Gelöscht> (Neue Zeile wird mit den folgenden Merkmalen hinzugefügt) Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Add	Löschen rückgängigmachen und Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Nicht verfügbar> Original = <Eingehender> Status = <Gelöscht> RowAction = ChangeOriginal
Unverändert	Current = <Incoming> Original = <Vorhanden> Wenn der neue Wert mit dem vorhandenen Wert identisch ist, dann Status = <Unverändert> RowAction = Nothing Oder Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal
Nicht vorhanden)	Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Add	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal

Wenn Sie beim Aufrufen der Load Methode die Optionen "OverwriteChanges" oder "PreserveChanges" angeben, wird davon ausgegangen, dass die eingehenden Daten aus der DataTableprimären Datenquelle stammen, und die DataTable verfolgt Änderungen 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 auf mittlerer Ebene bereitgestellt werden, z. B. von einem Benutzer geändert werden. In diesem Fall wird davon ausgegangen, dass die Absicht besteht, Daten aus einer oder mehreren Datenquellen in der DataTableDatenquelle zu aggregieren und dann möglicherweise die Daten an die primäre Datenquelle zurückzuverbreiten. 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, sofern vorhanden, andernfalls aktuelle Version
`PreserveChanges`	Originalversion, sofern vorhanden, andernfalls aktuelle Version
`Upsert`	Aktuelle Version, sofern vorhanden, andernfalls Originalversion

Weitere Informationen

Gilt für:

Load(IDataReader, LoadOption, FillErrorEventHandler)

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Quelle:: DataTable.cs

Füllt einen DataTable Wert mit Werten aus einer Datenquelle mithilfe des bereitgestellten IDataReader Fehlerbehandlungsdelegats aus.

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

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

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

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

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

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

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

Parameter

reader: IDataReader

Ein IDataReader Ergebnissatz, der ein Resultset bereitstellt.

loadOption: LoadOption

Ein Wert aus der Aufzählung, der LoadOption angibt, wie Zeilen bereits in der DataTable Auflistung mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.

errorHandler: FillErrorEventHandler

Ein FillErrorEventHandler Delegat, der aufgerufen werden soll, wenn beim Laden von Daten ein Fehler auftritt.

Attribute: RequiresUnreferencedCodeAttribute

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

Zustand	Verhalten
Das DataTable Schema ist nicht vorhanden.	Die `Load` Methode leitet das Schema basierend auf dem Resultset aus dem importierten ab IDataReader.
Das DataTable Schema weist ein Schema auf, ist jedoch nicht mit dem geladenen Schema 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, das geladene Resultsetschema enthält jedoch Spalten, die in der `DataTable`Datei nicht vorhanden sind.	Die `Load` Methode fügt die zusätzlichen Spalten zum `DataTable`Schema hinzu. Die Methode löst eine Ausnahme aus, wenn die entsprechenden Spalten im DataTable Und das geladene 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 der aktuelle DataTable Wert keine Spalten am Anfang des Ladevorgangs enthält.
Die Schemas sind kompatibel, das geladene Resultsetschema enthält jedoch weniger Spalten als die `DataTable`.	Wenn eine fehlende Spalte einen Standardwert definiert hat oder der Datentyp der Spalte NULL-Werte aufweist, kann die `Load` Methode die Zeilen hinzufügen und den Standard- oder Nullwert für die fehlende Spalte ersetzen. 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.

Im Hinblick 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 der DataRowChangeEventArgs Instanz, die an den Ereignishandler übergeben wird, 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 Ereignis identisch. Die Aktion kann abhängig vom aktuellen Zeilenzustand auf die aktuelle oder die ursprüngliche Version jeder Zeile oder beides angewendet werden.

Vorhandene DataRowState	Upsert	OverwriteChanges	PreserveChanges (Standardverhalten)
Hinzugefügt	Current = <Incoming> Original = -<Nicht verfügbar> Status = <Hinzugefügt> RowAction = Change	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Eingehender> Status = <Geändert> RowAction = ChangeOriginal
Geändert	Current = <Incoming> Original = <Vorhanden> Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Eingehender> Status = <Geändert> RowAction =ChangeOriginal
eleted	(Laden wirkt sich nicht auf gelöschte Zeilen aus) Current = --- Original = <Vorhanden> Status = <Gelöscht> (Neue Zeile wird mit den folgenden Merkmalen hinzugefügt) Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Add	Löschen rückgängigmachen und Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Nicht verfügbar> Original = <Eingehender> Status = <Gelöscht> RowAction = ChangeOriginal
Unverändert	Current = <Incoming> Original = <Vorhanden> Wenn der neue Wert mit dem vorhandenen Wert identisch ist, dann Status = <Unverändert> RowAction = Nothing Oder Status = <Geändert> RowAction = Change	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal
Nicht vorhanden)	Current = <Incoming> Original = <Nicht verfügbar> Status = <Hinzugefügt> RowAction = Add	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal	Current = <Incoming> Original = <Eingehender> Status = <Unverändert> RowAction = ChangeCurrentAndOriginal

Option "Laden"	DataRow-Version, die für den Primärschlüsselvergleich verwendet wird
`OverwriteChanges`	Originalversion, sofern vorhanden, andernfalls aktuelle Version
`PreserveChanges`	Originalversion, sofern vorhanden, andernfalls aktuelle Version
`Upsert`	Aktuelle Version, sofern 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 zu dem aufgetretenen Fehler, der aktuellen Datenzeile und dem Gefüllten DataTable 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 fest, um true anzugeben, dass Sie den Fehler behandelt haben und die Verarbeitung fortsetzen möchten. Legen Sie die Eigenschaft so fest false , dass die Verarbeitung angehalten werden soll. Beachten Sie, dass das Festlegen der Eigenschaft false dazu führt, dass der Code, der das Problem ausgelöst hat, eine Ausnahme auslöste.

Weitere Informationen

Gilt für:

Feedback

War diese Seite hilfreich?

Freigeben über

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