DataSet.Load Metod

Definition

Namnområde:: System.Data

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 DataSet med värden från en datakälla med hjälp av den angivna IDataReader.

Överlagringar

Name	Description
Load(IDataReader, LoadOption, DataTable[])	Fyller en DataSet med värden från en datakälla med hjälp av den angivna IDataReader, med hjälp av en matris med DataTable instanser för att ange schema- och namnområdesinformationen.
Load(IDataReader, LoadOption, String[])	Fyller en DataSet med värden från en datakälla med hjälp av den angivna IDataReader, med hjälp av en matris med strängar för att ange namnen för tabellerna `DataSet`i .
Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])	Fyller en DataSet med värden från en datakälla med hjälp av den angivna IDataReader, med hjälp av en matris med DataTable instanser för att ange schema- och namnområdesinformationen.

Kommentarer

Metoden Load ger en teknik för att fylla en enda DataTable med data som hämtats från en IDataReader instans. Den här metoden har samma funktioner, men gör att du kan läsa in flera resultatuppsättningar från en IDataReader till flera tabeller i en DataSet.

Om de DataSet redan innehåller rader sammanfogas inkommande data från datakällan med de befintliga raderna.

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 DataSet). Dessa scenarier beskriver standardanvändning för en DataSet, som beskriver dess uppdaterings- och sammanslagningsbeteende.

En DataSet synkroniserar eller uppdaterar med en enda primär datakälla. Spårar DataSet ändringar, vilket tillåter synkronisering med den primära datakällan. Dessutom kan en DataSet acceptera inkrementella data från en eller flera sekundära datakällor. DataSet 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:

DataSet Initiera från en primär datakälla. I det här scenariot vill användaren initiera en tom DataSet med värden från den primära datakällan. Ett eller flera DataTable-innehåll ändras. 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 DataSet ifyllt i föregående scenario och utföra en inkrementell synkronisering med den primära datakällan, vilket bevarar ändringar som gjorts i DataSet.
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 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. 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	Beskrivning
`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, LoadOption, DataTable[])

Fyller en DataSet med värden från en datakälla med hjälp av den angivna IDataReader, med hjälp av en matris med DataTable instanser för att ange schema- och namnområdesinformationen.

public:
 void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, ... cli::array <System::Data::DataTable ^> ^ tables);

public void Load(System.Data.IDataReader reader, System.Data.LoadOption loadOption, params System.Data.DataTable[] tables);

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

Public Sub Load (reader As IDataReader, loadOption As LoadOption, ParamArray tables As DataTable())

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 instanserna i DataTable DataSet kommer att kombineras med inkommande rader som delar samma primärnyckel.

tables: DataTable[]

En matris med DataTable instanser som Load(IDataReader, LoadOption, DataTable[]) metoden hämtar namn- och namnområdesinformation från. Var och en av dessa tabeller måste vara medlem i innehållet i DataTableCollection den här DataSet.

Exempel

I följande exempel skapas en ny DataSet, lägger till två DataTable instanser i DataSetoch fyller DataSet sedan med metoden Load och hämtar data från en DataTableReader som innehåller två resultatuppsättningar. Slutligen visar exemplet innehållet i tabellerna i konsolfönstret.

static void Main()
{
    DataSet dataSet = new DataSet();

    DataTable customerTable = new DataTable();
    DataTable productTable = new DataTable();

    // This information is cosmetic, only.
    customerTable.TableName = "Customers";
    productTable.TableName = "Products";

    // Add the tables to the DataSet:
    dataSet.Tables.Add(customerTable);
    dataSet.Tables.Add(productTable);

    // Load the data into the existing DataSet.
    DataTableReader reader = GetReader();
    dataSet.Load(reader, LoadOption.OverwriteChanges,
        customerTable, productTable);

    // Print out the contents of each table:
    foreach (DataTable table in dataSet.Tables)
    {
        PrintColumns(table);
    }

    Console.WriteLine("Press any key to continue.");
    Console.ReadKey();
}

private static DataTable GetCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();
    table.TableName = "Customers";

    // 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 GetProducts()
{
    // Create sample Products table.
    DataTable table = new DataTable();
    table.TableName = "Products";

    // 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, "Wireless Network Card" });
    table.Rows.Add(new object[] { 1, "Hard Drive" });
    table.Rows.Add(new object[] { 2, "Monitor" });
    table.Rows.Add(new object[] { 3, "CPU" });
    table.AcceptChanges();
    return table;
}

private static void PrintColumns(DataTable table)
{
    Console.WriteLine();
    Console.WriteLine(table.TableName);
    Console.WriteLine("=========================");
    // Loop through all the rows in the table:
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0; i < table.Columns.Count; i++)
        {
            Console.Write(row[i] + " ");
        }
        Console.WriteLine();
    }
}

private static DataTableReader GetReader()
{
    // Return a DataTableReader containing multiple
    // result sets, just for the sake of this demo.
    DataSet dataSet = new DataSet();
    dataSet.Tables.Add(GetCustomers());
    dataSet.Tables.Add(GetProducts());
    return dataSet.CreateDataReader();
}

Sub Main()
    Dim dataSet As New DataSet

    Dim customerTable As New DataTable
    Dim productTable As New DataTable

    ' This information is cosmetic, only.
    customerTable.TableName = "Customers"
    productTable.TableName = "Products"

    ' Add the tables to the DataSet:
    dataSet.Tables.Add(customerTable)
    dataSet.Tables.Add(productTable)

    ' Load the data into the existing DataSet. 
    Dim reader As DataTableReader = GetReader()
    dataSet.Load(reader, LoadOption.OverwriteChanges, _
        customerTable, productTable)

    ' Print out the contents of each table:
    For Each table As DataTable In dataSet.Tables
        PrintColumns(table)
    Next

    Console.WriteLine("Press any key to continue.")
    Console.ReadKey()
End Sub

Private Function GetCustomers() As DataTable
    ' Create sample Customers table.
    Dim table As New DataTable
    table.TableName = "Customers"

    ' 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 GetProducts() As DataTable
    ' Create sample Products table, in order
    ' to demonstrate the behavior of the DataTableReader.
    Dim table As New DataTable
    table.TableName = "Products"

    ' 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, "Wireless Network Card"})
    table.Rows.Add(New Object() {1, "Hard Drive"})
    table.Rows.Add(New Object() {2, "Monitor"})
    table.Rows.Add(New Object() {3, "CPU"})
    Return table
End Function

Private Function GetReader() As DataTableReader
    ' Return a DataTableReader containing multiple
    ' result sets, just for the sake of this demo.
    Dim dataSet As New DataSet
    dataSet.Tables.Add(GetCustomers())
    dataSet.Tables.Add(GetProducts())
    Return dataSet.CreateDataReader()
End Function

Private Sub PrintColumns( _
   ByVal table As DataTable)

    Console.WriteLine()
    Console.WriteLine(table.TableName)
    Console.WriteLine("=========================")
    ' Loop through all the rows in the table.
    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

Note

Inläsningsåtgärden misslyckas med en InvalidOperationException om någon av källdatakolumnerna i de inkommande reader är beräknade kolumner.

Med loadOption parametern kan du ange hur du vill att importerade data ska interagera med befintliga data och kan vara något av värdena från LoadOption uppräkningen. Mer information om hur du använder den här parametern finns i dokumentationen DataTable Load för metoden.

Med tables parametern kan du ange en matris med DataTable instanser som anger ordningen på de tabeller som motsvarar varje resultatuppsättning som läses in från läsaren. Metoden Load fyller varje angiven DataTable instans med data från en enda resultatuppsättning från källdataläsaren. Efter varje resultatuppsättning Load går metoden vidare till nästa resultatuppsättning i läsaren tills det inte finns några fler resultatuppsättningar.

Namnmatchningsschemat för den här metoden är detsamma som följt av klassens Fill DbDataAdapter metod.

Se även

Använda datauppsättningar i ADO.NET

Gäller för

Load(IDataReader, LoadOption, String[])

Fyller en DataSet med värden från en datakälla med hjälp av den angivna IDataReader, med hjälp av en matris med strängar för att ange namnen för tabellerna DataSeti .

public:
 void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, ... cli::array <System::String ^> ^ tables);

public void Load(System.Data.IDataReader reader, System.Data.LoadOption loadOption, params string[] tables);

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

Public Sub Load (reader As IDataReader, loadOption As LoadOption, ParamArray tables As String())

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 instanserna i DataTableDataSet kommer att kombineras med inkommande rader som delar samma primärnyckel.

tables: String[]

En matris med strängar som Load metoden hämtar tabellnamnsinformation från.

Exempel

I följande konsolprogramexempel skapas först tabeller och data läses in från en läsare till en DataSet, med hjälp av Load metoden . Exemplet lägger sedan till tabeller i en DataSet och försöker fylla tabellerna med data från en DataTableReader. I det här exemplet, eftersom parametrarna som skickas till Load metoden anger ett tabellnamn som inte finns, Load skapar metoden en ny tabell som matchar namnet som skickas som en parameter. När data har lästs in visar exemplet innehållet i alla dess tabeller i konsolfönstret.

static void Main()
{
    DataSet dataSet = new DataSet();

    DataTableReader reader = GetReader();

    // The tables listed as parameters for the Load method
    // should be in the same order as the tables within the IDataReader.
    dataSet.Load(reader, LoadOption.Upsert, "Customers", "Products");
    foreach (DataTable table in dataSet.Tables)
    {
        PrintColumns(table);
    }

    // Now try the example with the DataSet
    // already filled with data:
    dataSet = new DataSet();
    dataSet.Tables.Add(GetCustomers());
    dataSet.Tables.Add(GetProducts());

    // Retrieve a data reader containing changed data:
    reader = GetReader();

    // Load the data into the existing DataSet. Retrieve the order of the
    // the data in the reader from the
    // list of table names in the parameters. If you specify
    // a new table name here, the Load method will create
    // a corresponding new table.
    dataSet.Load(reader, LoadOption.Upsert,
        "NewCustomers", "Products");
    foreach (DataTable table in dataSet.Tables)
    {
        PrintColumns(table);
    }

    Console.WriteLine("Press any key to continue.");
    Console.ReadKey();
}

private static DataTable GetCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();
    table.TableName = "Customers";

    // 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 GetProducts()
{
    // Create sample Products table.
    DataTable table = new DataTable();
    table.TableName = "Products";

    // 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, "Wireless Network Card" });
    table.Rows.Add(new object[] { 1, "Hard Drive" });
    table.Rows.Add(new object[] { 2, "Monitor" });
    table.Rows.Add(new object[] { 3, "CPU" });
    table.AcceptChanges();
    return table;
}

private static void PrintColumns(DataTable table)
{
    Console.WriteLine();
    Console.WriteLine(table.TableName);
    Console.WriteLine("=========================");
    // Loop through all the rows in the table:
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0; i < table.Columns.Count; i++)
        {
            Console.Write(row[i] + " ");
        }
        Console.WriteLine();
    }
}

private static DataTableReader GetReader()
{
    // Return a DataTableReader containing multiple
    // result sets, just for the sake of this demo.
    DataSet dataSet = new DataSet();
    dataSet.Tables.Add(GetCustomers());
    dataSet.Tables.Add(GetProducts());
    return dataSet.CreateDataReader();
}

Sub Main()
  Dim dataSet As New DataSet
  Dim table As DataTable

  Dim reader As DataTableReader = GetReader()

  ' The tables listed as parameters for the Load method 
  ' should be in the same order as the tables within the IDataReader.
  dataSet.Load(reader, LoadOption.Upsert, "Customers", "Products")
  For Each table In dataSet.Tables
    PrintColumns(table)
  Next

  ' Now try the example with the DataSet
  ' already filled with data:
  dataSet = New DataSet
  dataSet.Tables.Add(GetCustomers())
  dataSet.Tables.Add(GetProducts())

  ' Retrieve a data reader containing changed data:
  reader = GetReader()

  ' Load the data into the existing DataSet. Retrieve the order of the
  ' the data in the reader from the
  ' list of table names in the parameters. If you specify
  ' a new table name here, the Load method will create
  ' a corresponding new table.
  dataSet.Load(reader, LoadOption.Upsert, "NewCustomers", "Products")
  For Each table In dataSet.Tables
    PrintColumns(table)
  Next

  Console.WriteLine("Press any key to continue.")
  Console.ReadKey()
End Sub

Private Function GetCustomers() As DataTable
  ' Create sample Customers table.
  Dim table As New DataTable
  table.TableName = "Customers"

  ' 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 GetProducts() As DataTable
  ' Create sample Products table, in order
  ' to demonstrate the behavior of the DataTableReader.
  Dim table As New DataTable
  table.TableName = "Products"

  ' 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, "Wireless Network Card"})
  table.Rows.Add(New Object() {1, "Hard Drive"})
  table.Rows.Add(New Object() {2, "Monitor"})
  table.Rows.Add(New Object() {3, "CPU"})
  Return table
End Function

Private Function GetReader() As DataTableReader
  ' Return a DataTableReader containing multiple
  ' result sets, just for the sake of this demo.
  Dim dataSet As New DataSet
  dataSet.Tables.Add(GetCustomers())
  dataSet.Tables.Add(GetProducts())
  Return dataSet.CreateDataReader()
End Function

Private Sub PrintColumns( _
   ByVal table As DataTable)

  Console.WriteLine()
  Console.WriteLine(table.TableName)
  Console.WriteLine("=========================")
  ' Loop through all the rows in the table.
  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

Note

Inläsningsåtgärden misslyckas med en InvalidOperationException om någon av källdatakolumnerna i de inkommande reader är beräknade kolumner.

Med tables parametern kan du ange en matris med tabellnamn som anger ordningen på de tabeller som motsvarar varje resultatuppsättning som läses in från läsaren. Metoden Load försöker hitta en tabell i den DataSet matchande namnet som finns i matrisen med tabellnamn i ordning. Om en matchande tabell hittas läses tabellen in med innehållet i den aktuella resultatuppsättningen. Om ingen matchande tabell hittas skapas en tabell med det namn som anges i matrisen med tabellnamn, och den nya tabellens schema härleds från resultatuppsättningen. Efter varje resultatuppsättning Load går metoden vidare till nästa resultatuppsättning i läsaren tills det inte finns några fler resultatuppsättningar.

Standardnamnområdet som är associerat med DataSet, om det finns, är associerat med varje nyskapade DataTable. Namnmatchningsschemat för den här metoden är detsamma som följt av klassens Fill DbDataAdapter metod.

Se även

Använda datauppsättningar i ADO.NET

Gäller för

Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])

Fyller en DataSet med värden från en datakälla med hjälp av den angivna IDataReader, med hjälp av en matris med DataTable instanser för att ange schema- och namnområdesinformationen.

public:
 virtual void Load(System::Data::IDataReader ^ reader, System::Data::LoadOption loadOption, System::Data::FillErrorEventHandler ^ errorHandler, ... cli::array <System::Data::DataTable ^> ^ tables);

public virtual void Load(System.Data.IDataReader reader, System.Data.LoadOption loadOption, System.Data.FillErrorEventHandler errorHandler, params System.Data.DataTable[] tables);

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

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

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 instanserna i DataTable DataSet kommer att 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.

tables: DataTable[]

En matris med DataTable instanser som Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) metoden hämtar namn- och namnområdesinformation från.

Exempel

I följande exempel läggs en tabell till i och DataSetförsöker sedan använda Load metoden för att läsa in data från ett DataTableReader som innehåller ett inkompatibelt schema. I stället för att fånga felet använder det här exemplet ett FillErrorEventHandler ombud för att undersöka och hantera felet. Utdata visas i konsolfönstret.

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.:
    DataSet dataSet = new DataSet();
    DataTable table = GetIntegerTable();
    dataSet.Tables.Add(table);
    DataTableReader reader = new DataTableReader(GetStringTable());
    dataSet.Load(reader, LoadOption.OverwriteChanges,
        FillErrorHandler, table);

    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 dataSet As New DataSet
  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.:
  dataSet = New DataSet()
  table = GetIntegerTable()
  dataSet.Tables.Add(table)
  Dim reader As New DataTableReader(GetStringTable())
  dataSet.Load(reader, LoadOption.OverwriteChanges, _
      AddressOf FillErrorHandler, table)

  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

Note

Inläsningsåtgärden misslyckas med en InvalidOperationException om någon av källdatakolumnerna i de inkommande reader är beräknade kolumner.

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 så false att den anger 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.

Namnmatchningsschemat för den här metoden är detsamma som följt av klassens Fill DbDataAdapter metod.

Se även

Använda datauppsättningar i ADO.NET

Gäller för

Feedback

Var den här sidan till hjälp?