DataTable.Load Metod

Definition

Namnområde:: System.Data

Sammansättningar:: netstandard.dll, System.Data.Common.dll

Sammansättning:: System.Data.Common.dll

Sammansättning:: System.Data.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Fyller en DataTable med värden från en datakälla med hjälp av den angivna IDataReader. Om de DataTable redan innehåller rader sammanfogas inkommande data från datakällan med de befintliga raderna.

Överlagringar

Name	Description
Load(IDataReader)	Fyller en DataTable med värden från en datakälla med hjälp av den angivna IDataReader. Om de DataTable redan innehåller rader sammanfogas inkommande data från datakällan med de befintliga raderna.
Load(IDataReader, LoadOption)	Fyller en DataTable med värden från en datakälla med hjälp av den angivna IDataReader. Om de `DataTable` redan innehåller rader sammanfogas inkommande data från datakällan med de befintliga raderna enligt parameterns `loadOption` värde.
Load(IDataReader, LoadOption, FillErrorEventHandler)	Fyller en DataTable med värden från en datakälla med hjälp av den angivna IDataReader med hjälp av ett ombud för felhantering.

Exempel

I följande exempel visas flera av problemen med att anropa Load metoden. Först fokuserar exemplet på schemaproblem, inklusive att härleda ett schema från det inlästa IDataReaderoch sedan hantera inkompatibla scheman och scheman med saknade eller ytterligare kolumner. Exemplet fokuserar sedan på dataproblem, inklusive hantering av olika inläsningsalternativ.

Note

Det här exemplet visar hur du använder en av de överlagrade versionerna av Load. Andra exempel som kan vara tillgängliga finns i de enskilda överlagringsämnena.

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

Kommentarer

Metoden Load kan användas i flera vanliga scenarier, allt centrerat kring att hämta data från en angiven datakälla och lägga till den i den aktuella datacontainern (i det här fallet en DataTable). Dessa scenarier beskriver standardanvändning för en DataTable, som beskriver dess uppdaterings- och sammanslagningsbeteende.

En DataTable synkroniserar eller uppdaterar med en enda primär datakälla. Spårar DataTable ändringar, vilket tillåter synkronisering med den primära datakällan. Dessutom kan en DataTable acceptera inkrementella data från en eller flera sekundära datakällor. DataTable Ansvarar inte för att spåra ändringar för att tillåta synkronisering med den sekundära datakällan.

Med tanke på dessa två hypotetiska datakällor kommer en användare sannolikt att kräva något av följande beteende:

DataTable Initiera från en primär datakälla. I det här scenariot vill användaren initiera en tom DataTable med värden från den primära datakällan. Senare har användaren för avsikt att sprida ändringarna tillbaka till den primära datakällan.
Bevara ändringar och synkronisera igen från den primära datakällan. I det här scenariot vill användaren ta DataTable ifyllt i föregående scenario och utföra en inkrementell synkronisering med den primära datakällan, vilket bevarar ändringar som gjorts i DataTable.
Inkrementell datafeed från sekundära datakällor. I det här scenariot vill användaren sammanfoga ändringar från en eller flera sekundära datakällor och sprida ändringarna tillbaka till den primära datakällan.

Metoden Load gör alla dessa scenarier möjliga. Med alla utom en av överlagringarna för den här metoden kan du ange en inläsningsalternativparameter som anger hur rader som redan finns i en DataTable kombination med rader som läses in. (Den överlagring som inte tillåter att du anger beteendet använder standardinläsningsalternativet.) I följande tabell beskrivs de tre inläsningsalternativen som tillhandahålls av LoadOption uppräkningen. I varje fall anger beskrivningen beteendet när den primära nyckeln för en rad i inkommande data matchar primärnyckeln för en befintlig rad.

Inläsningsalternativ	Description
`PreserveChanges` (standardinställning)	Uppdaterar den ursprungliga versionen av raden med värdet för den inkommande raden.
`OverwriteChanges`	Uppdaterar de aktuella och ursprungliga versionerna av raden med värdet för den inkommande raden.
`Upsert`	Uppdaterar den aktuella versionen av raden med värdet för den inkommande raden.

I allmänhet PreserveChanges är alternativen och OverwriteChanges avsedda för scenarier där användaren behöver synkronisera DataSet och dess ändringar med den primära datakällan. Alternativet Upsert underlättar aggregering av ändringar från en eller flera sekundära datakällor.

Load(IDataReader)

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Fyller en DataTable med värden från en datakälla med hjälp av den angivna IDataReader. Om de DataTable redan innehåller rader sammanfogas inkommande data från datakällan med de befintliga raderna.

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)

Parametrar

reader: IDataReader

En IDataReader som ger en resultatuppsättning.

Attribut: RequiresUnreferencedCodeAttribute

Exempel

I följande exempel visas flera av problemen med att anropa Load metoden. Först fokuserar exemplet på schemaproblem, inklusive att härleda ett schema från det inlästa IDataReaderoch sedan hantera inkompatibla scheman och scheman med saknade eller ytterligare kolumner. Exemplet anropar Load sedan metoden och visar data både före och efter inläsningsåtgärden.

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

Kommentarer

Metoden Load använder den första resultatuppsättningen från den inlästa IDataReader, och efter slutförande anger läsarens position till nästa resultatuppsättning, om någon. När du konverterar data Load använder metoden samma konverteringsregler som DbDataAdapter.Fill metoden.

Metoden Load måste ta hänsyn till tre specifika problem vid inläsning av data från en IDataReader instans: schema, data och händelseåtgärder. När du arbetar med schemat Load kan metoden stöta på villkor enligt beskrivningen i följande tabell. Schemaåtgärderna utförs för alla importerade resultatuppsättningar, även de som inte innehåller några data.

Tillstånd	Behavior
Har DataTable inget schema.	Metoden Load härleder schemat baserat på resultatuppsättningen från den importerade IDataReader.
Har DataTable ett schema, men det är inte kompatibelt med det inlästa schemat.	Metoden Load genererar ett undantag som motsvarar det specifika fel som uppstår när du försöker läsa in data i det inkompatibla schemat.
Schemana är kompatibla, men det inlästa resultatuppsättningsschemat innehåller kolumner som inte finns i DataTable.	Metoden Load lägger till de extra kolumnerna i `DataTable`schemat. Metoden genererar ett undantag om motsvarande kolumner i DataTable och den inlästa resultatuppsättningen inte är värdekompatibla. Metoden hämtar också villkorsinformation från resultatuppsättningen för alla tillagda kolumner. Förutom när det gäller begränsning av primärnyckel används den här villkorsinformationen endast om den aktuella DataTable inte innehåller några kolumner i början av inläsningsåtgärden.
Schemana är kompatibla, men det inlästa resultatuppsättningsschemat innehåller färre kolumner än `DataTable`.	Om en kolumn som saknas har ett definierat standardvärde eller om kolumnens datatyp är null, Load tillåter metoden att raderna läggs till, vilket ersätter standardvärdet eller `null` värdet för kolumnen som saknas. Om inget standardvärde eller `null` kan användas utlöser `Load` metoden ett undantag. Om inget specifikt standardvärde har angetts `Load` använder `null` metoden värdet som det underförstådda standardvärdet.

Innan du överväger metodens Load beteende när det gäller dataåtgärder bör du tänka på att varje rad i en DataTable upprätthåller både det aktuella värdet och det ursprungliga värdet för varje kolumn. Dessa värden kan vara likvärdiga eller vara annorlunda om data på raden har ändrats sedan du DataTablefyllde i . Mer information finns i Radtillstånd och Radversioner.

Den här versionen av Load metoden försöker bevara de aktuella värdena på varje rad, vilket lämnar det ursprungliga värdet intakt. (Om du vill ha bättre kontroll över beteendet för inkommande data kan du läsa DataTable.Load.) Om den befintliga raden och den inkommande raden innehåller motsvarande primärnyckelvärden bearbetas raden med dess aktuella radtillståndsvärde, annars behandlas den som en ny rad.

När det gäller händelseåtgärder RowChanging inträffar händelsen innan varje rad ändras och RowChanged händelsen inträffar efter att varje rad har ändrats. I varje fall Action innehåller egenskapen för den instans som DataRowChangeEventArgs skickas till händelsehanteraren information om den specifika åtgärd som är associerad med händelsen. Det här åtgärdsvärdet beror på status för raden före inläsningsåtgärden. I varje fall inträffar båda händelserna och åtgärden är densamma för var och en. Åtgärden kan tillämpas på antingen den aktuella eller ursprungliga versionen av varje rad, eller båda, beroende på aktuellt radtillstånd.

I följande tabell visas beteendet för Load metoden. Den sista raden (märkt "(Not present)") beskriver beteendet för inkommande rader som inte matchar någon befintlig rad. Varje cell i den här tabellen beskriver det aktuella och ursprungliga värdet för ett fält i en rad, tillsammans med DataRowState värdet för när Load metoden har slutförts. I det här fallet tillåter metoden inte att du anger inläsningsalternativet och använder standardinställningen . PreserveChanges

Befintliga DataRowState	Värden efter `Load` metod och händelseåtgärd
Lagd till	Current = <Existing> Original = <Inkommande> Tillstånd = <Ändrad> RowAction = ChangeOriginal
Modifierad	Current = <Existing> Original = <Inkommande> Tillstånd = <Ändrad> RowAction = ChangeOriginal
Borttagen	Aktuell = <Inte tillgänglig> Original = <Inkommande> Tillstånd = <Borttaget> RowAction = ChangeOriginal
Oförändrad	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal
(Finns inte)	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal

Värden i en DataColumn kan begränsas med hjälp av egenskaper som ReadOnly och AutoIncrement. Metoden Load hanterar sådana kolumner på ett sätt som överensstämmer med det beteende som definieras av kolumnens egenskaper. Den skrivskyddade begränsningen för en DataColumn gäller endast för ändringar som sker i minnet. Metoden Load skriver över skrivskyddade kolumnvärden om det behövs.

För att avgöra vilken version av primärnyckelfältet som ska användas för att jämföra den aktuella raden med en inkommande rad Load använder metoden den ursprungliga versionen av primärnyckelvärdet inom en rad, om den finns. I annat fall Load använder metoden den aktuella versionen av primärnyckelfältet.

Se även

Gäller för

Load(IDataReader, LoadOption)

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: 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)

Parametrar

reader: IDataReader

En IDataReader som ger en eller flera resultatuppsättningar.

loadOption: LoadOption

Ett värde från LoadOption uppräkningen som anger hur rader som redan finns i DataTable kombineras med inkommande rader som delar samma primärnyckel.

Attribut: RequiresUnreferencedCodeAttribute

Exempel

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

Kommentarer

Metoden Load använder den första resultatuppsättningen från den inlästa IDataReader, och efter slutförande anger läsarens position till nästa resultatuppsättning, om någon. När du konverterar data Load använder metoden samma konverteringsregler som Fill metoden.

Metoden Load måste ta hänsyn till tre specifika problem vid inläsning av data från en IDataReader instans: schema, data och händelseåtgärder. När du arbetar med schemat Load kan metoden stöta på villkor enligt beskrivningen i följande tabell. Schemaåtgärderna utförs för alla importerade resultatuppsättningar, även de som inte innehåller några data.

Tillstånd	Behavior
Har DataTable inget schema.	Metoden `Load` härleder schemat baserat på resultatuppsättningen från den importerade IDataReader.
Har DataTable ett schema, men det är inte kompatibelt med det inlästa schemat.	Metoden `Load` genererar ett undantag som motsvarar det specifika fel som uppstår när du försöker läsa in data i det inkompatibla schemat.
Schemana är kompatibla, men det inlästa resultatuppsättningsschemat innehåller kolumner som inte finns i `DataTable`.	Metoden `Load` lägger till de extra kolumnerna i `DataTable`schemat. Metoden genererar ett undantag om motsvarande kolumner i DataTable och den inlästa resultatuppsättningen inte är värdekompatibla. Metoden hämtar också villkorsinformation från resultatuppsättningen för alla tillagda kolumner. Förutom när det gäller begränsning av primärnyckel används den här villkorsinformationen endast om den aktuella DataTable inte innehåller några kolumner i början av inläsningsåtgärden.
Schemana är kompatibla, men det inlästa resultatuppsättningsschemat innehåller färre kolumner än `DataTable`.	Om en kolumn som saknas har ett definierat standardvärde eller om kolumnens datatyp är null, `Load` tillåter metoden att raderna läggs till, vilket ersätter standardvärdet eller nullvärdet för kolumnen som saknas. Om inget standardvärde eller null kan användas utlöser `Load` metoden ett undantag. Om inget specifikt standardvärde har angetts `Load` använder metoden null-värdet som det underförstådda standardvärdet.

I det här metodanropet påverkar den angivna LoadOption parametern bearbetningen av inkommande data. Hur ska metoden Load hantera inläsningsrader som har samma primära nyckel som befintliga rader? Ska den ändra aktuella värden, ursprungliga värden eller båda? Dessa problem styrs med mera av parametern loadOption .

Om den befintliga raden och den inkommande raden innehåller motsvarande primärnyckelvärden bearbetas raden med dess aktuella radtillståndsvärde, annars behandlas den som en ny rad.

När det gäller händelseåtgärder RowChanging inträffar händelsen innan varje rad ändras och RowChanged händelsen inträffar efter att varje rad har ändrats. I varje fall Action innehåller egenskapen för den instans som DataRowChangeEventArgs skickas till händelsehanteraren information om den specifika åtgärd som är associerad med händelsen. Det här åtgärdsvärdet varierar beroende på status för raden före belastningsåtgärden. I varje fall inträffar båda händelserna och åtgärden är densamma för var och en. Åtgärden kan tillämpas på antingen den aktuella eller ursprungliga versionen av varje rad, eller båda, beroende på aktuellt radtillstånd.

Följande tabell visar beteendet för metoden Load när den anropas med vart och ett av LoadOption värdena och visar även hur värdena interagerar med radtillståndet för raden som läses in. Den sista raden (märkt "(Not present)") beskriver beteendet för inkommande rader som inte matchar någon befintlig rad. Varje cell i den här tabellen beskriver det aktuella och ursprungliga värdet för ett fält i en rad, tillsammans med DataRowState värdet för när Load metoden har slutförts.

Befintliga DataRowState	Uppdatera/Infoga	OverwriteChanges	PreserveChanges (standardbeteende)
Lagd till	Aktuell = <Inkommande> Original = -<Not available> Tillstånd = <har lagts till> RowAction = Ändra	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Inkommande> Tillstånd = <Ändrad> RowAction = ChangeOriginal
Modifierad	Aktuell = <Inkommande> Original = <Befintlig> Tillstånd = <Ändrad> RowAction = Ändra	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Inkommande> Tillstånd = <Ändrad> RowAction =ChangeOriginal
Borttagen	(Inläsning påverkar inte borttagna rader) Aktuell = --- Original = <Befintlig> Tillstånd = <Borttaget> (Ny rad läggs till med följande egenskaper) Aktuell = <Inkommande> Original = <Inte tillgängligt> Tillstånd = <har lagts till> RowAction = Lägg till	Ångra borttagning och Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Aktuell = <Inte tillgänglig> Original = <Inkommande> Tillstånd = <Borttaget> RowAction = ChangeOriginal
Oförändrad	Aktuell = <Inkommande> Original = <Befintlig> Om det nya värdet är detsamma som det befintliga värdet Tillstånd = <Oförändrat> RowAction = Ingenting Annat Tillstånd = <Ändrad> RowAction = Ändra	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal
Inte närvarande)	Aktuell = <Inkommande> Original = <Inte tillgängligt> Tillstånd = <har lagts till> RowAction = Lägg till	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal

Om du anger alternativen OverwriteChanges eller PreserveChanges när du anropar Load metoden görs antagandet att inkommande data kommer från den DataTableprimära datakällan och DataTable spårar ändringar och kan sprida ändringarna tillbaka till datakällan. Om du väljer alternativet Upsert antas det att data kommer från en sekundär datakälla, till exempel data som tillhandahålls av en komponent på mellannivå, kanske ändras av en användare. I det här fallet är antagandet att avsikten är att aggregera data från en eller flera datakällor i DataTable, och sedan kanske sprida data tillbaka till den primära datakällan. Parametern LoadOption används för att fastställa den specifika versionen av raden som ska användas för jämförelse av primärnyckel. Tabellen nedan innehåller information.

Alternativet Läs in	DataRow-version som används för jämförelse av primärnyckel
`OverwriteChanges`	Ursprunglig version, om den finns, annars Aktuell version
`PreserveChanges`	Ursprunglig version, om den finns, annars Aktuell version
`Upsert`	Aktuell version, om den finns, annars ursprunglig version

Se även

Gäller för

Load(IDataReader, LoadOption, FillErrorEventHandler)

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Källa:: DataTable.cs

Fyller en DataTable med värden från en datakälla med hjälp av den angivna IDataReader med hjälp av ett ombud för felhantering.

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)

Parametrar

reader: IDataReader

En IDataReader som ger en resultatuppsättning.

loadOption: LoadOption

Ett värde från LoadOption uppräkningen som anger hur rader som redan finns i DataTable kombineras med inkommande rader som delar samma primärnyckel.

errorHandler: FillErrorEventHandler

Ett FillErrorEventHandler ombud att anropa när ett fel inträffar när data läses in.

Attribut: RequiresUnreferencedCodeAttribute

Exempel

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

Kommentarer

Tillstånd	Behavior
Har DataTable inget schema.	Metoden `Load` härleder schemat baserat på resultatuppsättningen från den importerade IDataReader.
Har DataTable ett schema, men det är inte kompatibelt med det inlästa schemat.	Metoden `Load` genererar ett undantag som motsvarar det specifika fel som uppstår när du försöker läsa in data i det inkompatibla schemat.
Schemana är kompatibla, men det inlästa resultatuppsättningsschemat innehåller kolumner som inte finns i `DataTable`.	Metoden `Load` lägger till de extra kolumnerna i `DataTable`schemat. Metoden genererar ett undantag om motsvarande kolumner i DataTable och den inlästa resultatuppsättningen inte är värdekompatibla. Metoden hämtar också villkorsinformation från resultatuppsättningen för alla tillagda kolumner. Förutom när det gäller begränsning av primärnyckel används den här villkorsinformationen endast om den aktuella DataTable inte innehåller några kolumner i början av inläsningsåtgärden.
Schemana är kompatibla, men det inlästa resultatuppsättningsschemat innehåller färre kolumner än `DataTable`.	Om en kolumn som saknas har ett definierat standardvärde eller om kolumnens datatyp är null, `Load` tillåter metoden att raderna läggs till, vilket ersätter standardvärdet eller nullvärdet för kolumnen som saknas. Om inget standardvärde eller null kan användas utlöser `Load` metoden ett undantag. Om inget specifikt standardvärde har angetts `Load` använder metoden null-värdet som det underförstådda standardvärdet.

Om den befintliga raden och den inkommande raden innehåller motsvarande primärnyckelvärden bearbetas raden med dess aktuella radtillståndsvärde, annars behandlas den som en ny rad.

När det gäller händelseåtgärder RowChanging inträffar händelsen innan varje rad ändras och RowChanged händelsen inträffar efter att varje rad har ändrats. I varje fall Action innehåller egenskapen för den instans som DataRowChangeEventArgs skickas till händelsehanteraren information om den specifika åtgärd som är associerad med händelsen. Det här åtgärdsvärdet varierar beroende på status för raden före belastningsåtgärden. I varje fall inträffar båda händelserna och åtgärden är densamma för var och en. Åtgärden kan tillämpas på antingen den aktuella eller ursprungliga versionen av varje rad, eller båda, beroende på aktuellt radtillstånd.

Befintliga DataRowState	Uppdatera/Infoga	OverwriteChanges	PreserveChanges (standardbeteende)
Lagd till	Aktuell = <Inkommande> Original = -<Not available> Tillstånd = <har lagts till> RowAction = Ändra	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Inkommande> Tillstånd = <Ändrad> RowAction = ChangeOriginal
Modifierad	Aktuell = <Inkommande> Original = <Befintlig> Tillstånd = <Ändrad> RowAction = Ändra	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Current = <Existing> Original = <Inkommande> Tillstånd = <Ändrad> RowAction =ChangeOriginal
eleted	(Inläsning påverkar inte borttagna rader) Aktuell = --- Original = <Befintlig> Tillstånd = <Borttaget> (Ny rad läggs till med följande egenskaper) Aktuell = <Inkommande> Original = <Inte tillgängligt> Tillstånd = <har lagts till> RowAction = Lägg till	Ångra borttagning och Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Aktuell = <Inte tillgänglig> Original = <Inkommande> Tillstånd = <Borttaget> RowAction = ChangeOriginal
Oförändrad	Aktuell = <Inkommande> Original = <Befintlig> Om det nya värdet är detsamma som det befintliga värdet Tillstånd = <Oförändrat> RowAction = Ingenting Annat Tillstånd = <Ändrad> RowAction = Ändra	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal
Inte närvarande)	Aktuell = <Inkommande> Original = <Inte tillgängligt> Tillstånd = <har lagts till> RowAction = Lägg till	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal	Aktuell = <Inkommande> Original = <Inkommande> Tillstånd = <Oförändrat> RowAction = ChangeCurrentAndOriginal

Alternativet Läs in	DataRow-version som används för jämförelse av primärnyckel
`OverwriteChanges`	Ursprunglig version, om den finns, annars Aktuell version
`PreserveChanges`	Ursprunglig version, om den finns, annars Aktuell version
`Upsert`	Aktuell version, om den finns, annars ursprunglig version

Parametern errorHandler är ett FillErrorEventHandler ombud som refererar till en procedur som anropas när ett fel inträffar när data läses in. Parametern FillErrorEventArgs som skickas till proceduren innehåller egenskaper som gör att du kan hämta information om felet som inträffade, den aktuella dataraden och den DataTable som fylls i. Med den här ombudsmekanismen, i stället för ett enklare try/catch-block, kan du fastställa felet, hantera situationen och fortsätta bearbetningen om du vill. Parametern FillErrorEventArgs tillhandahåller en Continue egenskap: ange den här egenskapen så true att den anger att du har hanterat felet och vill fortsätta bearbetningen. Ange egenskapen till false för att ange att du vill stoppa bearbetningen. Tänk på att om du ställer in egenskapen på false får koden som utlöste problemet att utlösa ett undantag.

Se även

Gäller för

Feedback

Var den här sidan till hjälp?