DataTable.Load Metódus

Definíció

Névtér:: System.Data

Szerelvények:: netstandard.dll, System.Data.Common.dll

Szerelvény:: System.Data.Common.dll

Szerelvény:: System.Data.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy adatforrás értékeit DataTable tölti ki a megadott IDataReaderparanccsal. Ha a DataTable már tartalmaz sorokat, az adatforrásból érkező bejövő adatok egyesülnek a meglévő sorokkal.

Túlterhelések

Name	Description
Load(IDataReader)	Egy adatforrás értékeit DataTable tölti ki a megadott IDataReaderparanccsal. Ha a DataTable már tartalmaz sorokat, az adatforrásból érkező bejövő adatok egyesülnek a meglévő sorokkal.
Load(IDataReader, LoadOption)	Egy adatforrás értékeit DataTable tölti ki a megadott IDataReaderparanccsal. Ha a `DataTable` már tartalmaz sorokat, az adatforrásból érkező bejövő adatok a paraméter értékének megfelelően egyesülnek a `loadOption` meglévő sorokkal.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Egy adatforrás értékeit DataTable tölti ki a megadott IDataReader hibakezelési meghatalmazott használatával.

Példák

Az alábbi példa a metódus meghívásával Load kapcsolatos számos problémát mutat be. A példa először a sémaproblémákra összpontosít, például a betöltött IDataReadersémákból való következtetésre, majd a nem kompatibilis sémák, valamint a hiányzó vagy további oszlopokkal rendelkező sémák kezelésére. A példa ezután az adatproblémákra összpontosít, beleértve a különböző betöltési lehetőségek kezelését is.

Note

Ez a példa bemutatja, hogyan használhatja a rendszer túlterhelt verzióinak egyikét Load. További elérhető példákért tekintse meg az egyes túlterhelési témaköröket.

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

Megjegyzések

A Load módszer több gyakori forgatókönyvben is használható, ezek középpontjában egy adott adatforrás adatainak lekérése és az aktuális adattárolóhoz való hozzáadása (ebben az esetben a DataTable). Ezek a forgatókönyvek a frissítési és egyesítési viselkedést leíró szabványos használatot DataTableírják le.

Egyetlen DataTable elsődleges adatforrással szinkronizál vagy frissít. A DataTable változások nyomon követhetők, lehetővé téve az elsődleges adatforrással való szinkronizálást. Emellett egy DataTable vagy több másodlagos adatforrás növekményes adatait is elfogadhatja. A DataTable módosítások nyomon követéséért nem a felelős, hogy lehetővé tegye a másodlagos adatforrással való szinkronizálást.

A két hipotetikus adatforrás alapján a felhasználó valószínűleg az alábbi viselkedések egyikét igényli:

Inicializálás DataTable elsődleges adatforrásból. Ebben a forgatókönyvben a felhasználó inicializálni szeretne egy üres DataTable értéket az elsődleges adatforrásból származó értékekkel. Később a felhasználó vissza kívánja propagálja a módosításokat az elsődleges adatforrásba.
A módosítások megőrzése és az elsődleges adatforrásból való újraszinkronizálás. Ebben a forgatókönyvben a felhasználó szeretné elvégezni az DataTable előző forgatókönyvben kitöltött adatokat, és növekményes szinkronizálást végezni az elsődleges adatforrással, megőrizve a módosításokat a DataTable.
Növekményes adatcsatorna másodlagos adatforrásokból. Ebben a forgatókönyvben a felhasználó egyesíteni szeretné egy vagy több másodlagos adatforrás módosításait, és propagálja ezeket a módosításokat az elsődleges adatforrásba.

A Load módszer lehetővé teszi ezeket a forgatókönyveket. A metódus túlterhelései közül mindegyik lehetővé teszi a terhelési beállítás paraméterének megadását, amely azt jelzi, hogy a sorok hogyan kombinálhatók a DataTable betöltött sorokkal. (A túlterhelés, amely nem teszi lehetővé a viselkedés megadását, az alapértelmezett terhelési beállítást használja.) Az alábbi táblázat az enumerálás által biztosított három terhelési LoadOption lehetőséget ismerteti. A leírás minden esetben azt a viselkedést jelzi, amikor a bejövő adatok egy sorának elsődleges kulcsa megegyezik egy meglévő sor elsődleges kulcsával.

Betöltési beállítás	Leírás
`PreserveChanges` (alapértelmezett)	Frissíti a sor eredeti verzióját a bejövő sor értékével.
`OverwriteChanges`	Frissíti a sor aktuális és eredeti verzióit a bejövő sor értékével.
`Upsert`	Frissíti a sor aktuális verzióját a bejövő sor értékével.

Általánosságban elmondható, hogy a PreserveChanges beállítások olyan OverwriteChanges helyzetekre szolgálnak, amikor a felhasználónak szinkronizálnia kell a DataSet módosításokat az elsődleges adatforrással. Ez a Upsert beállítás megkönnyíti egy vagy több másodlagos adatforrás módosításainak összesítését.

Load(IDataReader)

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Egy adatforrás értékeit DataTable tölti ki a megadott IDataReaderparanccsal. Ha a DataTable már tartalmaz sorokat, az adatforrásból érkező bejövő adatok egyesülnek a meglévő sorokkal.

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)

Paraméterek

reader: IDataReader

Egy IDataReader eredményhalmazt biztosító.

Attribútumok: RequiresUnreferencedCodeAttribute

Példák

Az alábbi példa a metódus meghívásával Load kapcsolatos számos problémát mutat be. A példa először a sémaproblémákra összpontosít, például a betöltött IDataReadersémákból való következtetésre, majd a nem kompatibilis sémák, valamint a hiányzó vagy további oszlopokkal rendelkező sémák kezelésére. A példa ezután meghívja a Load metódust, és megjeleníti az adatokat a terhelési művelet előtt és után is.

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

Megjegyzések

A Load metódus felhasználja a betöltött IDataReaderelső eredményhalmazt, és a sikeres befejezés után az olvasó pozícióját a következő eredményhalmazra állítja, ha van ilyen. Az adatok konvertálása során a Load metódus ugyanazokat a konverziós szabályokat használja, mint a DbDataAdapter.Fill metódus.

A Load metódusnak három konkrét problémát kell figyelembe vennie egy példány adatainak IDataReader betöltésekor: séma, adatok és eseményműveletek. A séma használatakor a Load metódus az alábbi táblázatban ismertetett feltételekkel találkozhat. A sémaműveletek az összes importált eredményhalmaz esetében történnek, még az adatok nélküliek esetében is.

Condition	Magatartás
Nincs DataTable sémája.	A Load metódus az importált eredményhalmaz alapján következtet a sémára IDataReader.
A DataTable séma rendelkezik sémával, de nem kompatibilis a betöltött sémával.	A Load metódus kivételt ad az adatok inkompatibilis sémába való betöltésekor előforduló konkrét hibának megfelelő kivételnek.
A sémák kompatibilisek, de a betöltött eredményhalmaz séma olyan oszlopokat tartalmaz, amelyek nem léteznek a DataTable.	A Load metódus hozzáadja a további oszlopokat a sémához `DataTable`. A metódus kivételt okoz, ha a megfelelő oszlopok a DataTable betöltött eredményhalmazban nem kompatibilisek értékekkel. A metódus az összes hozzáadott oszlop eredménykészletéből is lekéri a kényszeradatokat. Az elsődleges kulcs kényszerének kivételével a rendszer csak akkor használja ezt a kényszerinformációt, ha az aktuális DataTable nem tartalmaz oszlopokat a terhelési művelet elején.
A sémák kompatibilisek, de a betöltött eredményhalmaz sémája kevesebb oszlopot tartalmaz, mint a `DataTable`.	Ha egy hiányzó oszlophoz alapértelmezett érték van definiálva, vagy az oszlop adattípusa null értékű, a Load metódus lehetővé teszi a sorok hozzáadását, a hiányzó oszlop alapértelmezett értékének vagy `null` értékének helyettesítésével. Ha nincs alapértelmezett érték, vagy `null` nem használható, akkor a `Load` metódus kivételt jelez. Ha nem adott meg konkrét alapértelmezett értéket, a metódus az `Loadnull` értéket használja a vélelmezett alapértelmezett értékként.

Mielőtt figyelembe venné a Load metódus adatműveletek szempontjából való viselkedését, vegye figyelembe, hogy az egyes DataTable oszlopok minden egyes sorában az aktuális és az eredeti érték is megmarad. Ezek az értékek egyenértékűek lehetnek, vagy eltérhetnek, ha a sor adatai módosultak a DataTablekitöltés óta. További információ: Sorállapotok és sorverziók.

A metódus ezen verziója Load minden sorban megkísérli megőrizni az aktuális értékeket, így az eredeti érték érintetlen marad. (Ha finomabb szabályozást szeretne a bejövő adatok viselkedése felett, tekintse meg DataTable.Loada .) Ha a meglévő és a bejövő sor megfelelő elsődleges kulcsértékeket tartalmaz, a sor feldolgozása az aktuális sorállapotértékével történik, ellenkező esetben új sorként lesz kezelve.

Az eseményműveletek tekintetében az esemény az RowChanging egyes sorok módosítása előtt következik be, és az esemény az RowChanged egyes sorok módosítása után következik be. Az eseménykezelőnek átadott példány tulajdonsága Action minden esetben DataRowChangeEventArgs információkat tartalmaz az eseményhez társított konkrét műveletről. Ez a műveleti érték a sor terhelési művelet előtti állapotától függ. Minden esetben mindkét esemény bekövetkezik, és a művelet mindegyiknél ugyanaz. A művelet alkalmazható az egyes sorok aktuális vagy eredeti verziójára, vagy mindkettőre az aktuális sorállapottól függően.

Az alábbi táblázat a metódus viselkedését Load jeleníti meg. Az utolsó sor ("(Nincs jelen)") a meglévő sornak nem megfelelő bejövő sorok viselkedését írja le. A táblázat minden cellájában egy soron belüli mező aktuális és eredeti értéke, valamint a DataRowState metódus befejezése utáni Load érték szerepel. Ebben az esetben a metódus nem teszi lehetővé a terhelési beállítás jelzését, és az alapértelmezett értéket használja. PreserveChanges

Meglévő DataRowState	Metódus utáni `Load` értékek és eseményművelet
Hozzáadva	Current = <Existing> Eredeti = <Bejövő> State = <Modified> RowAction = ChangeOriginal
Módosítva	Current = <Existing> Eredeti = <Bejövő> State = <Modified> RowAction = ChangeOriginal
Törölve	Current = <Nem érhető el> Eredeti = <Bejövő> State = <Deleted> RowAction = ChangeOriginal
Változatlan	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal
(Nincs jelen)	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal

Egy adott tulajdonság értékei DataColumn az olyan tulajdonságok használatával korlátozhatók, mint például ReadOnly az és AutoIncrementa . A Load metódus úgy kezeli az ilyen oszlopokat, hogy azok összhangban legyenek az oszlop tulajdonságai által meghatározott viselkedéssel. Az írásvédettségi DataColumn korlátozás csak a memóriában bekövetkező változásokra vonatkozik. A Load metódus szükség esetén felülírja az írásvédett oszlop értékeit.

Annak megállapításához, hogy az elsődleges kulcs mező melyik verzióját kell használni az aktuális sor és egy bejövő sor összehasonlításához, a Load metódus az elsődleges kulcs értékének eredeti verzióját használja egy sorban belül, ha létezik. Ellenkező esetben a metódus az Load elsődleges kulcsmező aktuális verzióját használja.

Lásd még

A következőre érvényes:

Load(IDataReader, LoadOption)

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Egy adatforrás értékeit DataTable tölti ki a megadott IDataReaderparanccsal. Ha a DataTable már tartalmaz sorokat, az adatforrásból érkező bejövő adatok a paraméter értékének megfelelően egyesülnek a loadOption meglévő sorokkal.

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)

Paraméterek

reader: IDataReader

Egy IDataReader vagy több eredményhalmazt tartalmazó.

loadOption: LoadOption

Az enumerálásból származó LoadOption érték, amely azt jelzi, hogy a DataTable már benne lévő sorok hogyan vannak kombinálva az azonos elsődleges kulccsal rendelkező bejövő sorokkal.

Attribútumok: RequiresUnreferencedCodeAttribute

Példák

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

Megjegyzések

A Load metódus felhasználja a betöltött IDataReaderelső eredményhalmazt, és a sikeres befejezés után az olvasó pozícióját a következő eredményhalmazra állítja, ha van ilyen. Az adatok konvertálása során a Load metódus ugyanazokat a konverziós szabályokat használja, mint a Fill metódus.

A Load metódusnak három konkrét problémát kell figyelembe vennie egy példány adatainak IDataReader betöltésekor: séma, adatok és eseményműveletek. A séma használatakor a Load metódus az alábbi táblázatban ismertetett feltételekkel találkozhat. A sémaműveletek az összes importált eredményhalmaz esetében történnek, még az adatok nélküliek esetében is.

Condition	Magatartás
Nincs DataTable sémája.	A `Load` metódus az importált eredményhalmaz alapján következtet a sémára IDataReader.
A DataTable séma rendelkezik sémával, de nem kompatibilis a betöltött sémával.	A `Load` metódus kivételt ad az adatok inkompatibilis sémába való betöltésekor előforduló konkrét hibának megfelelő kivételnek.
A sémák kompatibilisek, de a betöltött eredményhalmaz sémája olyan oszlopokat tartalmaz, amelyek nem léteznek a `DataTable`.	A `Load` metódus hozzáadja a további oszlopokat a sémához `DataTable`. A metódus kivételt okoz, ha a megfelelő oszlopok a DataTable betöltött eredményhalmazban nem kompatibilisek értékekkel. A metódus az összes hozzáadott oszlop eredménykészletéből is lekéri a kényszeradatokat. Az elsődleges kulcs kényszerének kivételével a rendszer csak akkor használja ezt a kényszerinformációt, ha az aktuális DataTable nem tartalmaz oszlopokat a terhelési művelet elején.
A sémák kompatibilisek, de a betöltött eredményhalmaz sémája kevesebb oszlopot tartalmaz, mint a `DataTable`.	Ha egy hiányzó oszlopban van meghatározva egy alapértelmezett érték, vagy az oszlop adattípusa null értékű, a `Load` metódus lehetővé teszi a sorok hozzáadását, a hiányzó oszlop alapértelmezett vagy null értékének helyettesítésével. Ha nem használható alapértelmezett érték vagy null érték, akkor a `Load` metódus kivételt jelez. Ha nem adott meg konkrét alapértelmezett értéket, a metódus a `Load` null értéket használja a vélelmezett alapértelmezett értékként.

Ebben a metódushívásban a megadott LoadOption paraméter befolyásolja a bejövő adatok feldolgozását. Hogyan kezelje a Load metódus azokat a sorokat, amelyek elsődleges kulcsa megegyezik a meglévő sorokkal? Módosítsa az aktuális értékeket, az eredeti értékeket vagy mindkettőt? Ezeket a problémákat és egyebeket a loadOption paraméter vezérli.

Ha a meglévő és a bejövő sor megfelelő elsődleges kulcsértékeket tartalmaz, a sor feldolgozása az aktuális sorállapotértékével történik, ellenkező esetben új sorként lesz kezelve.

Az eseményműveletek tekintetében az esemény az RowChanging egyes sorok módosítása előtt következik be, és az esemény az RowChanged egyes sorok módosítása után következik be. Az eseménykezelőnek átadott példány tulajdonsága Action minden esetben DataRowChangeEventArgs információkat tartalmaz az eseményhez társított konkrét műveletről. Ez a művelet értéke a terhelési művelet előtti sor állapotától függően változik. Minden esetben mindkét esemény bekövetkezik, és a művelet mindegyiknél ugyanaz. A művelet alkalmazható az egyes sorok aktuális vagy eredeti verziójára, vagy mindkettőre az aktuális sorállapottól függően.

Az alábbi táblázat a Betöltés metódus viselkedését jeleníti meg az egyes értékek meghívásakor LoadOption , valamint azt is, hogy az értékek hogyan működnek együtt a betöltött sor sorállapotával. Az utolsó sor ("(Nincs jelen)") a meglévő sornak nem megfelelő bejövő sorok viselkedését írja le. A táblázat minden cellájában egy soron belüli mező aktuális és eredeti értéke, valamint a DataRowState metódus befejezése utáni Load érték szerepel.

Meglévő DataRowState	Upsert	OverwriteChanges	PreserveChanges (Alapértelmezett viselkedés)
Hozzáadva	Current = <Bejövő> Eredeti = -<Nem érhető el> State = <Added> RowAction = Change	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Eredeti = <Bejövő> State = <Modified> RowAction = ChangeOriginal
Módosítva	Current = <Bejövő> Eredeti = <Meglévő> State = <Modified> RowAction = Change	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Eredeti = <Bejövő> State = <Modified> RowAction =ChangeOriginal
Törölve	(A betöltés nem befolyásolja a törölt sorokat) Current = --- Eredeti = <Meglévő> State = <Deleted> (Az új sor a következő jellemzőkkel van hozzáadva) Current = <Bejövő> Eredeti = <Nem érhető el> State = <Added> RowAction = Hozzáadás	Törlés visszavonása és Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Nem érhető el> Eredeti = <Bejövő> State = <Deleted> RowAction = ChangeOriginal
Változatlan	Current = <Bejövő> Eredeti = <Meglévő> Ha az új érték megegyezik a meglévő értékkel, akkor Állapot = <Változatlan> RowAction = Semmi Más State = <Modified> RowAction = Change	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal
Nincs jelen)	Current = <Bejövő> Eredeti = <Nem érhető el> State = <Added> RowAction = Hozzáadás	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal

Ha a metódus meghívásakor Load megadja az OverwriteChanges vagy a PreserveChanges beállításokat, akkor a rendszer feltételezi, hogy a bejövő adatok az DataTableelsődleges adatforrásból érkeznek, és a DataTable nyomon követi a módosításokat, és propagálja a módosításokat az adatforrásba. Ha az Upsert lehetőséget választja, a rendszer feltételezi, hogy az adatok egy másodlagos adatforrásból származnak, például egy középső rétegbeli összetevő által biztosított adatokból, amelyeket esetleg egy felhasználó módosított. Ebben az esetben a feltételezés az, hogy a szándék az adatok összesítése egy vagy több adatforrásból az DataTableelsődleges adatforrásba, majd az adatok visszaterjesztése az elsődleges adatforrásba. A LoadOption paraméter az elsődleges kulcs összehasonlításához használandó sor adott verziójának meghatározására szolgál. Az alábbi táblázat ismerteti a részleteket.

Betöltési beállítás	Az elsődleges kulcs összehasonlításához használt DataRow-verzió
`OverwriteChanges`	Eredeti verzió, ha létezik, egyébként aktuális verzió
`PreserveChanges`	Eredeti verzió, ha létezik, egyébként aktuális verzió
`Upsert`	Aktuális verzió, ha létezik, ellenkező esetben eredeti verzió

Lásd még

A következőre érvényes:

Load(IDataReader, LoadOption, FillErrorEventHandler)

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Forrás:: DataTable.cs

Egy adatforrás értékeit DataTable tölti ki a megadott IDataReader hibakezelési meghatalmazott használatával.

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)

Paraméterek

reader: IDataReader

A IDataReader , amely egy eredményhalmazt biztosít.

loadOption: LoadOption

Az enumerálásból származó LoadOption érték, amely azt jelzi, hogy a DataTable már benne lévő sorok hogyan vannak kombinálva az azonos elsődleges kulccsal rendelkező bejövő sorokkal.

errorHandler: FillErrorEventHandler

Egy FillErrorEventHandler meghatalmazott, aki meghívja, ha hiba történik az adatok betöltése során.

Attribútumok: RequiresUnreferencedCodeAttribute

Példák

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

Megjegyzések

Condition	Magatartás
Nincs DataTable sémája.	A `Load` metódus az importált eredményhalmaz alapján következtet a sémára IDataReader.
A DataTable séma rendelkezik sémával, de nem kompatibilis a betöltött sémával.	A `Load` metódus kivételt ad az adatok inkompatibilis sémába való betöltésekor előforduló konkrét hibának megfelelő kivételnek.
A sémák kompatibilisek, de a betöltött eredményhalmaz sémája olyan oszlopokat tartalmaz, amelyek nem léteznek a `DataTable`.	A `Load` metódus hozzáadja a további oszlopokat a sémához `DataTable`. A metódus kivételt okoz, ha a megfelelő oszlopok a DataTable betöltött eredményhalmazban nem kompatibilisek értékekkel. A metódus az összes hozzáadott oszlop eredménykészletéből is lekéri a kényszeradatokat. Az elsődleges kulcs kényszerének kivételével a rendszer csak akkor használja ezt a kényszerinformációt, ha az aktuális DataTable nem tartalmaz oszlopokat a terhelési művelet elején.
A sémák kompatibilisek, de a betöltött eredményhalmaz sémája kevesebb oszlopot tartalmaz, mint a `DataTable`.	Ha egy hiányzó oszlopban van meghatározva egy alapértelmezett érték, vagy az oszlop adattípusa null értékű, a `Load` metódus lehetővé teszi a sorok hozzáadását, a hiányzó oszlop alapértelmezett vagy null értékének helyettesítésével. Ha nem használható alapértelmezett érték vagy null érték, akkor a `Load` metódus kivételt jelez. Ha nem adott meg konkrét alapértelmezett értéket, a metódus a `Load` null értéket használja a vélelmezett alapértelmezett értékként.

Ha a meglévő és a bejövő sor megfelelő elsődleges kulcsértékeket tartalmaz, a sor feldolgozása az aktuális sorállapotértékével történik, ellenkező esetben új sorként lesz kezelve.

Az eseményműveletek tekintetében az esemény az RowChanging egyes sorok módosítása előtt következik be, és az esemény az RowChanged egyes sorok módosítása után következik be. Az eseménykezelőnek átadott példány tulajdonsága Action minden esetben DataRowChangeEventArgs információkat tartalmaz az eseményhez társított konkrét műveletről. Ez a művelet értéke a terhelési művelet előtti sor állapotától függően változik. Minden esetben mindkét esemény bekövetkezik, és a művelet mindegyiknél ugyanaz. A művelet alkalmazható az egyes sorok aktuális vagy eredeti verziójára, vagy mindkettőre az aktuális sorállapottól függően.

Meglévő DataRowState	Upsert	OverwriteChanges	PreserveChanges (Alapértelmezett viselkedés)
Hozzáadva	Current = <Bejövő> Eredeti = -<Nem érhető el> State = <Added> RowAction = Change	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Eredeti = <Bejövő> State = <Modified> RowAction = ChangeOriginal
Módosítva	Current = <Bejövő> Eredeti = <Meglévő> State = <Modified> RowAction = Change	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Eredeti = <Bejövő> State = <Modified> RowAction =ChangeOriginal
eleted	(A betöltés nem befolyásolja a törölt sorokat) Current = --- Eredeti = <Meglévő> State = <Deleted> (Az új sor a következő jellemzőkkel van hozzáadva) Current = <Bejövő> Eredeti = <Nem érhető el> State = <Added> RowAction = Hozzáadás	Törlés visszavonása és Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Nem érhető el> Eredeti = <Bejövő> State = <Deleted> RowAction = ChangeOriginal
Változatlan	Current = <Bejövő> Eredeti = <Meglévő> Ha az új érték megegyezik a meglévő értékkel, akkor Állapot = <Változatlan> RowAction = Semmi Más State = <Modified> RowAction = Change	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal
Nincs jelen)	Current = <Bejövő> Eredeti = <Nem érhető el> State = <Added> RowAction = Hozzáadás	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal	Current = <Bejövő> Eredeti = <Bejövő> Állapot = <Változatlan> RowAction = ChangeCurrentAndOriginal

Betöltési beállítás	Az elsődleges kulcs összehasonlításához használt DataRow-verzió
`OverwriteChanges`	Eredeti verzió, ha létezik, egyébként aktuális verzió
`PreserveChanges`	Eredeti verzió, ha létezik, egyébként aktuális verzió
`Upsert`	Aktuális verzió, ha létezik, ellenkező esetben eredeti verzió

A errorHandler paraméter egy FillErrorEventHandler delegált, amely egy olyan eljárásra hivatkozik, amelyet az adatok betöltésekor hiba esetén hívunk meg. Az FillErrorEventArgs eljárásnak átadott paraméter olyan tulajdonságokat biztosít, amelyek lehetővé teszik a hiba, az aktuális adatsor és a DataTable kitöltendő adatok információinak lekérését. Ezzel a delegálási mechanizmussal egyszerűbb kipróbálási/fogási blokkok helyett meghatározhatja a hibát, kezelheti a helyzetet, és tetszés szerint folytathatja a feldolgozást. A FillErrorEventArgs paraméter egy tulajdonságot Continue biztosít: állítsa be ezt a tulajdonságot true úgy, hogy jelezze, hogy ön kezelte a hibát, és folytatni szeretné a feldolgozást. Állítsa be a tulajdonságot úgy false , hogy jelezze, hogy le szeretné állítani a feldolgozást. Vegye figyelembe, hogy a tulajdonság false beállítása miatt a problémát kiváltó kód kivételt okoz.

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?