Condividi tramite

DataSet.Load Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.Data
Assembly:
System.Data.Common.dll
Assembly:
System.Data.dll
Assembly:
netstandard.dll

Riempie una classe DataSet con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.

Overload

Load(IDataReader, LoadOption, DataTable[])

Riempie una classe DataSet con valori da un'origine dati, utilizzando l'interfaccia IDataReader fornita, tramite una matrice di istanze della classe DataTable, per fornire informazioni relative allo schema e allo spazio dei nomi.
Load(IDataReader, LoadOption, String[])

Riempie una classe DataSet con valori da un'origine dati, utilizzando l'interfaccia IDataReader fornita e una matrice di stringhe, per rendere disponibili i nomi delle tabelle all'interno della classe DataSet.
Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])

Riempie una classe DataSet con valori da un'origine dati, utilizzando l'interfaccia IDataReader fornita, tramite una matrice di istanze della classe DataTable, per fornire informazioni relative allo schema e allo spazio dei nomi.

Commenti

Il Load metodo fornisce una tecnica per riempire un singolo DataTable oggetto con i dati recuperati da un'istanza IDataReader di . Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all'interno di un oggetto DataSet.

Se DataSet contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti.

Il Load metodo può essere usato in diversi scenari comuni, tutti incentrati sull'acquisizione di dati da un'origine dati specificata e l'aggiunta al contenitore di dati corrente (in questo caso, un oggetto DataSet). Questi scenari descrivono l'utilizzo standard per un DataSetoggetto , descrivendone il comportamento di aggiornamento e unione.

Un DataSet oggetto sincronizza o aggiorna con una singola origine dati primaria. Tiene traccia delle DataSet modifiche, consentendo la sincronizzazione con l'origine dati primaria. Inoltre, un DataSet oggetto può accettare dati incrementali da una o più origini dati secondarie. Non DataSet è responsabile del rilevamento delle modifiche per consentire la sincronizzazione con l'origine dati secondaria.

Data queste due origini dati ipotetiche, è probabile che un utente richieda uno dei comportamenti seguenti:

  • Inizializzare DataSet da un'origine dati primaria. In questo scenario, l'utente vuole inizializzare un oggetto vuoto DataSet con i valori dell'origine dati primaria. Vengono modificati uno o più contenuti di DataTable. Successivamente l'utente intende propagare le modifiche all'origine dati primaria.

  • Mantenere le modifiche e sincronizzare nuovamente dall'origine dati primaria. In questo scenario, l'utente vuole compilare lo DataSet scenario precedente ed eseguire una sincronizzazione incrementale con l'origine dati primaria, mantenendo le modifiche apportate in DataSet.

  • Feed di dati incrementale da origini dati secondarie. In questo scenario, l'utente vuole unire le modifiche da una o più origini dati secondarie e propagare tali modifiche all'origine dati primaria.

Il Load metodo rende possibili tutti questi scenari. Questo metodo consente di specificare un parametro di opzione di caricamento, che indica come le righe già presenti in una DataTable combinazione con le righe caricate. Nella tabella seguente vengono descritte le tre opzioni di caricamento fornite dall'enumerazione LoadOption . In ogni caso, la descrizione indica il comportamento quando la chiave primaria di una riga nei dati in ingresso corrisponde alla chiave primaria di una riga esistente.

Opzione di caricamento Descrizione
PreserveChanges (impostazione predefinita) Aggiornamenti la versione originale della riga con il valore della riga in ingresso.
OverwriteChanges Aggiornamenti le versioni correnti e originali della riga con il valore della riga in ingresso.
Upsert Aggiornamenti la versione corrente della riga con il valore della riga in ingresso.

In generale, le PreserveChanges opzioni e OverwriteChanges sono destinate agli scenari in cui l'utente deve sincronizzare e DataSet le relative modifiche con l'origine dati primaria. L'opzione facilita l'aggregazione Upsert delle modifiche da una o più origini dati secondarie.

Load(IDataReader, LoadOption, DataTable[])

Source:
DataSet.cs
Source:
DataSet.cs
Source:
DataSet.cs

Riempie una classe DataSet con valori da un'origine dati, utilizzando l'interfaccia IDataReader fornita, tramite una matrice di istanze della classe DataTable, per fornire informazioni relative allo schema e allo spazio dei nomi.

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())

Parametri

reader
IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.

loadOption
LoadOption

Valore dall'enumerazione LoadOption, che indica come vengono combinate le righe già presenti nelle istanze della classe DataTable, all'interno della classe DataSet, con le righe in entrata che condividono la stessa chiave primaria.

tables
DataTable[]

Matrice di istanze della classe DataTable da cui il metodo Load(IDataReader, LoadOption, DataTable[]) recupera informazioni relative al nome e allo spazio dei nomi. Ognuna di queste tabelle deve essere un membro della classe DataTableCollection contenuta da questa classe DataSet.

Esempio

Nell'esempio seguente viene creato un nuovo DataSetoggetto , vengono aggiunte due DataTable istanze a DataSete quindi viene riempito DataSet usando il Load metodo , recuperando i dati da un DataTableReader oggetto contenente due set di risultati. Infine, nell'esempio viene visualizzato il contenuto delle tabelle nella finestra della console.

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

Commenti

Il Load metodo fornisce una tecnica per riempire un singolo DataTable oggetto con i dati recuperati da un'istanza IDataReader di . Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all'interno di un oggetto DataSet.

Nota

L'operazione di caricamento avrà esito negativo se InvalidOperationException una delle colonne di dati di origine nelle colonne in ingresso reader viene calcolata.

Il loadOption parametro consente di specificare la modalità di interazione dei dati importati con i dati esistenti e può essere uno dei valori dell'enumerazione LoadOption . Per altre informazioni sull'uso di questo parametro, vedere la documentazione relativa al DataTableLoad metodo .

Il tables parametro consente di specificare una matrice di istanze, che indica l'ordine delle tabelle corrispondenti a ogni set di DataTable risultati caricato dal lettore. Il Load metodo riempie ogni istanza fornita DataTable con i dati di un singolo set di risultati dal lettore dati di origine. Dopo ogni set di risultati, il Load metodo passa al set di risultati successivo all'interno del lettore, fino a quando non sono presenti altri set di risultati.

Lo schema di risoluzione dei nomi per questo metodo è uguale a quello seguito dal Fill metodo della DbDataAdapter classe .

Vedi anche

Si applica a

Load(IDataReader, LoadOption, String[])

Source:
DataSet.cs
Source:
DataSet.cs
Source:
DataSet.cs

Riempie una classe DataSet con valori da un'origine dati, utilizzando l'interfaccia IDataReader fornita e una matrice di stringhe, per rendere disponibili i nomi delle tabelle all'interno della classe DataSet.

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())

Parametri

reader
IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.

loadOption
LoadOption

Valore dall'enumerazione LoadOption, che indica come vengono combinate le righe già presenti nelle istanze della classe DataTable, all'interno della classe DataSet, con le righe in entrata che condividono la stessa chiave primaria.

tables
String[]

Matrice di stringhe da cui il metodo Load recupera le informazioni relative ai nomi delle tabelle.

Esempio

Nell'esempio di applicazione console seguente vengono prima create tabelle e vengono caricati dati da un lettore in un oggetto DataSet, usando il Load metodo . Nell'esempio vengono quindi aggiunte tabelle a un oggetto DataSet e si tenta di riempire le tabelle con i dati di un oggetto DataTableReader. In questo esempio, poiché i parametri passati al Load metodo indicano un nome di tabella che non esiste, il Load metodo crea una nuova tabella in modo che corrisponda al nome passato come parametro. Dopo aver caricato i dati, nell'esempio viene visualizzato il contenuto di tutte le relative tabelle nella finestra Console.

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

Commenti

Il Load metodo fornisce una tecnica per riempire un singolo DataTable oggetto con i dati recuperati da un'istanza IDataReader di . Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all'interno di un oggetto DataSet.

Nota

L'operazione di caricamento avrà esito negativo se InvalidOperationException una delle colonne di dati di origine nelle colonne in ingresso reader viene calcolata.

Il loadOption parametro consente di specificare la modalità di interazione dei dati importati con i dati esistenti e può essere uno dei valori dell'enumerazione LoadOption . Per altre informazioni sull'uso di questo parametro, vedere la documentazione relativa al Load metodo .

Il tables parametro consente di specificare una matrice di nomi di tabella, che indica l'ordine delle tabelle corrispondenti a ogni set di risultati caricato dal lettore. Il Load metodo tenta di trovare una tabella all'interno del DataSet nome corrispondente trovato nella matrice di nomi di tabella, in ordine. Se viene trovata una tabella corrispondente, tale tabella viene caricata con il contenuto del set di risultati corrente. Se non viene trovata alcuna tabella corrispondente, viene creata una tabella usando il nome specificato nella matrice di nomi di tabella e lo schema della nuova tabella viene dedotto dal set di risultati. Dopo ogni set di risultati, il Load metodo passa al set di risultati successivo all'interno del lettore, fino a quando non sono presenti altri set di risultati.

Lo spazio dei nomi predefinito associato a DataSet, se presente, è associato a ogni nuovo oggetto creato DataTable. Lo schema di risoluzione dei nomi per questo metodo è uguale a quello seguito dal Fill metodo della DbDataAdapter classe .

Vedi anche

Si applica a

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

Source:
DataSet.cs
Source:
DataSet.cs
Source:
DataSet.cs

Riempie una classe DataSet con valori da un'origine dati, utilizzando l'interfaccia IDataReader fornita, tramite una matrice di istanze della classe DataTable, per fornire informazioni relative allo schema e allo spazio dei nomi.

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);
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())

Parametri

reader
IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.

loadOption
LoadOption

Valore dall'enumerazione LoadOption, che indica come vengono combinate le righe già presenti nelle istanze della classe DataTable, all'interno della classe DataSet, con le righe in entrata che condividono la stessa chiave primaria.

errorHandler
FillErrorEventHandler

Delegato FillErrorEventHandler da chiamare quando si verifica un errore durante il caricamento dei dati.

tables
DataTable[]

Matrice di istanze della classe DataTable da cui il metodo Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) recupera informazioni relative al nome e allo spazio dei nomi.

Esempio

Nell'esempio seguente viene aggiunta una tabella a un oggetto DataSete quindi si tenta di usare il Load metodo per caricare dati da un DataTableReader oggetto contenente uno schema incompatibile. Invece di intercettare l'errore, in questo esempio viene usato un FillErrorEventHandler delegato per analizzare e gestire l'errore. L'output viene visualizzato nella finestra della console.

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

Commenti

Il Load metodo fornisce una tecnica per riempire un singolo DataTable oggetto con i dati recuperati da un'istanza IDataReader di . Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all'interno di un oggetto DataSet.

Nota

L'operazione di caricamento avrà esito negativo se InvalidOperationException una delle colonne di dati di origine nelle colonne in ingresso reader viene calcolata.

Il loadOption parametro consente di specificare la modalità di interazione dei dati importati con i dati esistenti e può essere uno dei valori dell'enumerazione LoadOption . Per altre informazioni sull'uso di questo parametro, vedere la documentazione relativa al DataTableLoad metodo .

Il errorHandler parametro è un FillErrorEventHandler delegato che fa riferimento a una routine chiamata quando si verifica un errore durante il caricamento dei dati. Il FillErrorEventArgs parametro passato alla routine fornisce proprietà che consentono di recuperare informazioni sull'errore che si è verificato, sulla riga di dati corrente e sull'oggetto DataTable compilato. L'uso di questo meccanismo delegato, anziché un blocco try/catch più semplice, consente di determinare l'errore, gestire la situazione e continuare l'elaborazione se si preferisce. Il FillErrorEventArgs parametro fornisce una Continue proprietà: impostare questa proprietà su true per indicare che l'errore è stato gestito e si desidera continuare l'elaborazione. Impostare la proprietà su false per indicare che si desidera interrompere l'elaborazione. Tenere presente che l'impostazione della proprietà su false fa sì che il codice che ha attivato il problema generi un'eccezione.

Il tables parametro consente di specificare una matrice di istanze, che indica l'ordine delle tabelle corrispondenti a ogni set di DataTable risultati caricato dal lettore. Il Load metodo riempie ogni istanza fornita DataTable con i dati di un singolo set di risultati dal lettore dati di origine. Dopo ogni set di risultati, il Load metodo passa al set di risultati successivo all'interno del lettore, fino a quando non sono presenti altri set di risultati.

Lo schema di risoluzione dei nomi per questo metodo è uguale a quello seguito dal Fill metodo della DbDataAdapter classe .

Vedi anche

Si applica a