DataSet.Load DataSet.Load DataSet.Load Method

Definizione

Riempie una classe DataSet con valori di un'origine dati utilizzando l'interfaccia IDataReader fornita.Fills a DataSet with values from a data source using the supplied IDataReader.

Overload

Load(IDataReader, LoadOption, DataTable[]) Load(IDataReader, LoadOption, DataTable[]) 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.Fills a DataSet with values from a data source using the supplied IDataReader, using an array of DataTable instances to supply the schema and namespace information.

Load(IDataReader, LoadOption, String[]) Load(IDataReader, LoadOption, String[]) 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.Fills a DataSet with values from a data source using the supplied IDataReader, using an array of strings to supply the names for the tables within the DataSet.

Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) 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.Fills a DataSet with values from a data source using the supplied IDataReader, using an array of DataTable instances to supply the schema and namespace information.

Commenti

Il Load metodo fornisce una tecnica per compilare un singolo DataTable oggetto con i dati recuperati IDataReader da un'istanza di.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all' DataSetinterno di un oggetto.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Se DataSet contiene già righe, i dati in arrivo dall'origine dati vengono uniti alle righe esistenti.If the DataSet already contains rows, the incoming data from the data source is merged with the existing rows.

Il Load metodo può essere usato in diversi scenari comuni, tutti centrati intorno al recupero di dati da un'origine dati specificata e alla relativa aggiunta al contenitore di dati corrente (in questo DataSetcaso, a).The Load method can be used in several common scenarios, all centered around getting data from a specified data source and adding it to the current data container (in this case, a DataSet). Questi scenari descrivono l'utilizzo standard DataSetper un, descrivendo il comportamento di aggiornamento e Unione.These scenarios describe standard usage for a DataSet, describing its update and merge behavior.

Un DataSet oggetto viene sincronizzato o aggiornato con una singola origine dati primaria.A DataSet synchronizes or updates with a single primary data source. DataSet Rileva le modifiche, consentendo la sincronizzazione con l'origine dati primaria.The DataSet tracks changes, allowing synchronization with the primary data source. Un oggetto DataSet può inoltre accettare dati incrementali da una o più origini dati secondarie.In addition, a DataSet can accept incremental data from one or more secondary data sources. Non DataSet è responsabile del rilevamento delle modifiche per consentire la sincronizzazione con l'origine dati secondaria.The DataSet isn't responsible for tracking changes in order to allow synchronization with the secondary data source.

Date queste due ipotetiche origini dati, è probabile che un utente richieda uno dei comportamenti seguenti:Given these two hypothetical data sources, a user is likely to require one of the following behaviors:

  • Inizializzare DataSet da un'origine dati primaria.Initialize DataSet from a primary data source. In questo scenario, l'utente desidera inizializzare un oggetto DataSet vuoto con i valori dell'origine dati primaria.In this scenario, the user wants to initialize an empty DataSet with values from the primary data source. Uno o più contenuti di DataTable vengono modificati.One or more DataTable's contents are modified. Successivamente, l'utente intende propagare le modifiche all'origine dati primaria.Later the user intends to propagate changes back to the primary data source.

  • Mantenere le modifiche e ripetere la sincronizzazione dall'origine dati primaria.Preserve changes and re-synchronize from the primary data source. In questo scenario, l'utente desidera DataSet compilare lo scenario precedente ed eseguire una sincronizzazione incrementale con l'origine dati primaria, mantenendo le modifiche apportate DataSetin.In this scenario, the user wants to take the DataSet filled in the previous scenario and perform an incremental synchronization with the primary data source, preserving modifications made in the DataSet.

  • Feed di dati incrementali dalle origini dati secondarie.Incremental data feed from secondary data sources. In questo scenario, l'utente desidera unire le modifiche da una o più origini dati secondarie e propagare le modifiche nell'origine dati primaria.In this scenario, the user wants to merge changes from one or more secondary data sources, and propagate those changes back to the primary data source.

Il Load metodo rende possibili tutti questi scenari.The Load method makes all these scenarios possible. Questo metodo consente di specificare un parametro di opzione Load, che indica il modo in cui DataTable le righe sono già presenti in un oggetto combinato con le righe caricate.This method allows you to specify a load option parameter, indicating how rows already in a DataTable combine with rows being loaded. Nella tabella seguente vengono descritte le tre opzioni di caricamento fornite LoadOption dall'enumerazione.The following table describes the three load options provided by the LoadOption enumeration. In ogni caso, la descrizione indica il comportamento quando la chiave primaria di una riga nei dati in arrivo corrisponde alla chiave primaria di una riga esistente.In each case, the description indicates the behavior when the primary key of a row in the incoming data matches the primary key of an existing row.

Opzione LoadLoad Option DescriptionDescription
PreserveChanges (impostazione predefinita)PreserveChanges (default) Aggiorna la versione originale della riga con il valore della riga in arrivo.Updates the original version of the row with the value of the incoming row.
OverwriteChanges Aggiorna le versioni correnti e originali della riga con il valore della riga in arrivo.Updates the current and original versions of the row with the value of the incoming row.
Upsert Aggiorna la versione corrente della riga con il valore della riga in arrivo.Updates the current version of the row with the value of the incoming row.

In generale, le PreserveChanges opzioni OverwriteChanges e sono destinate agli scenari in cui l' DataSet utente deve sincronizzare e le relative modifiche con l'origine dati primaria.In general, the PreserveChanges and OverwriteChanges options are intended for scenarios in which the user needs to synchronize the DataSet and its changes with the primary data source. L' Upsert opzione semplifica l'aggregazione delle modifiche da una o più origini dati secondarie.The Upsert option facilitates aggregating changes from one or more secondary data sources.

Load(IDataReader, LoadOption, DataTable[]) Load(IDataReader, LoadOption, DataTable[]) 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.Fills a DataSet with values from a data source using the supplied IDataReader, using an array of DataTable instances to supply the schema and namespace information.

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

Parametri

reader
IDataReader IDataReader IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.An IDataReader that provides one or more result sets.

loadOption
LoadOption 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.A value from the LoadOption enumeration that indicates how rows already in the DataTable instances within the DataSet will be combined with incoming rows that share the same primary key.

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.An array of DataTable instances, from which the Load(IDataReader, LoadOption, DataTable[]) method retrieves name and namespace information. Ognuna di queste tabelle deve essere un membro della classe DataTableCollection contenuta da questa classe DataSet.Each of these tables must be a member of the DataTableCollection contained by this DataSet.

Esempi

Nell'esempio seguente viene creato un DataSetnuovo oggetto, DataTable vengono aggiunte due DataSetistanze a, quindi viene compilato DataSet utilizzando il Load metodo, recuperando i dati da DataTableReader un oggetto che contiene due set di risultati.The following example creates a new DataSet, adds two DataTable instances to the DataSet, and then fills the DataSet using the Load method, retrieving data from a DataTableReader that contains two result sets. Infine, nell'esempio viene visualizzato il contenuto delle tabelle nella finestra della console.Finally, the example displays the contents of the tables in the console window.

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 compilare un singolo DataTable oggetto con i dati recuperati IDataReader da un'istanza di.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all' DataSetinterno di un oggetto.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Nota

L'operazione di caricamento avrà esito InvalidOperationException negativo con un se una qualsiasi delle colonne di dati di reader origine in ingresso è costituita da colonne calcolate.The load operation will fail with an InvalidOperationException if any of the source data columns in the incoming reader are computed columns.

Il loadOption parametro consente di specificare la modalità di interazione dei dati importati con i dati esistenti e può essere uno qualsiasi dei valori LoadOption dell'enumerazione.The loadOption parameter allows you to specify how you want the imported data to interact with existing data, and can be any of the values from the LoadOption enumeration. Per ulteriori informazioni sull'utilizzo DataTable di questo parametro, vedere la documentazione relativa al Load metodo.See the documentation for the DataTableLoad method for more information on using this parameter.

Il tables parametro consente di specificare una matrice di istanze DataTable di, che indica l'ordine delle tabelle corrispondenti a ogni set di risultati caricato dal reader.The tables parameter allows you to specify an array of DataTable instances, indicating the order of the tables corresponding to each result set loaded from the reader. Il Load metodo compila ogni istanza fornita DataTable con i dati di un singolo set di risultati dal lettore dati di origine.The Load method fills each supplied DataTable instance with data from a single result set from the source data reader. Dopo ogni set di risultati, Load il metodo passa al set di risultati successivo all'interno del lettore, fino a quando non sono presenti altri set di risultati.After each result set, the Load method moves on to the next result set within the reader, until there are no more result sets.

Lo schema di risoluzione dei nomi per questo metodo è uguale a quello seguito dal Fill metodo DbDataAdapter della classe.The name resolution scheme for this method is the same as that followed by the Fill method of the DbDataAdapter class.

Vedi anche

Load(IDataReader, LoadOption, String[]) Load(IDataReader, LoadOption, String[]) 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.Fills a DataSet with values from a data source using the supplied IDataReader, using an array of strings to supply the names for the tables within the 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

Parametri

reader
IDataReader IDataReader IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.An IDataReader that provides one or more result sets.

loadOption
LoadOption 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.A value from the LoadOption enumeration that indicates how rows already in the DataTable instances within the DataSet will be combined with incoming rows that share the same primary key.

tables
String[]

Matrice di stringhe da cui il metodo Load recupera le informazioni relative ai nomi delle tabelle.An array of strings, from which the Load method retrieves table name information.

Esempi

Nell'esempio di applicazione console seguente vengono create le tabelle e vengono caricati i dati da DataSetun Reader in Load un oggetto, utilizzando il metodo.The following Console application example first creates tables and loads data from a reader into a DataSet, using the Load method. Nell'esempio vengono quindi aggiunte tabelle a DataSet un oggetto e viene effettuato un tentativo di riempire le DataTableReadertabelle con i dati di un oggetto.The example then adds tables to a DataSet and attempts to fill the tables with data from a DataTableReader. In questo esempio, poiché i parametri passati al Load metodo indicano un nome di tabella non esistente, il Load metodo crea una nuova tabella in modo che corrisponda al nome passato come parametro.In this example, because the parameters passed to the Load method indicate a table name that does not exist, the Load method creates a new table to match the name passed as a parameter. Una volta caricati i dati, nell'esempio viene visualizzato il contenuto di tutte le tabelle nella finestra della console.Once the data has been loaded, the example displays the contents of all its tables in the Console window.

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 compilare un singolo DataTable oggetto con i dati recuperati IDataReader da un'istanza di.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all' DataSetinterno di un oggetto.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Nota

L'operazione di caricamento avrà esito InvalidOperationException negativo con un se una qualsiasi delle colonne di dati di reader origine in ingresso è costituita da colonne calcolate.The load operation will fail with an InvalidOperationException if any of the source data columns in the incoming reader are computed columns.

Il loadOption parametro consente di specificare la modalità di interazione dei dati importati con i dati esistenti e può essere uno qualsiasi dei valori LoadOption dell'enumerazione.The loadOption parameter allows you to specify how you want the imported data to interact with existing data, and can be any of the values from the LoadOption enumeration. Per ulteriori informazioni sull'utilizzo Load di questo parametro, vedere la documentazione relativa al metodo.See the documentation for the Load method for more information on using this parameter.

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 reader.The tables parameter allows you to specify an array of table names, indicating the order of the tables corresponding to each result set loaded from the reader. Il Load metodo tenta di trovare una tabella DataSet all'interno di corrispondente al nome trovato nella matrice di nomi di tabella, in ordine.The Load method attempts to find a table within the DataSet matching the name found in the array of table names, in order. Se viene trovata una tabella corrispondente, tale tabella viene caricata con il contenuto del set di risultati corrente.If a matching table is found, that table is loaded with the content of the current result set. Se non viene trovata alcuna tabella corrispondente, viene creata una tabella utilizzando il nome fornito nella matrice di nomi di tabella e lo schema della nuova tabella viene dedotto dal set di risultati.If no matching table is found, a table is created using the name supplied in the array of table names, and the new table's schema is inferred from the result set. Dopo ogni set di risultati, Load il metodo passa al set di risultati successivo all'interno del lettore, fino a quando non sono presenti altri set di risultati.After each result set, the Load method moves on to the next result set within the reader, until there are no more result sets.

Lo spazio dei nomi predefinito DataSetassociato a, se presente, è associato a ogni DataTableoggetto appena creato.The default namespace associated with DataSet, if any, is associated with each newly created DataTable. Lo schema di risoluzione dei nomi per questo metodo è uguale a quello seguito dal Fill metodo DbDataAdapter della classe.The name resolution scheme for this method is the same as that followed by the Fill method of the DbDataAdapter class.

Vedi anche

Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) 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.Fills a DataSet with values from a data source using the supplied IDataReader, using an array of DataTable instances to supply the schema and namespace information.

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

Parametri

reader
IDataReader IDataReader IDataReader

Interfaccia IDataReader che fornisce uno o più gruppi di risultati.An IDataReader that provides one or more result sets.

loadOption
LoadOption 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.A value from the LoadOption enumeration that indicates how rows already in the DataTable instances within the DataSet will be combined with incoming rows that share the same primary key.

errorHandler
FillErrorEventHandler FillErrorEventHandler FillErrorEventHandler

Delegato FillErrorEventHandler da chiamare quando si verifica un errore durante il caricamento dei dati.A FillErrorEventHandler delegate to call when an error occurs while loading data.

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.An array of DataTable instances, from which the Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) method retrieves name and namespace information.

Esempi

Nell'esempio seguente viene aggiunta una tabella a DataSetun oggetto, quindi viene eseguito un Load tentativo di utilizzare il metodo per DataTableReader caricare dati da un oggetto che contiene uno schema incompatibile.The following example adds a table to a DataSet, and then attempts to use the Load method to load data from a DataTableReader that contains an incompatible schema. Anziché intercettare l'errore, in questo esempio viene usato FillErrorEventHandler un delegato per analizzare e gestire l'errore.Rather than trapping the error, this example uses a FillErrorEventHandler delegate to investigate and handle the error. L'output viene visualizzato nella finestra della console.The output is displayed in the console window.

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 compilare un singolo DataTable oggetto con i dati recuperati IDataReader da un'istanza di.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Questo metodo fornisce la stessa funzionalità, ma consente di caricare più set di risultati da un IDataReader oggetto in più tabelle all' DataSetinterno di un oggetto.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Nota

L'operazione di caricamento avrà esito InvalidOperationException negativo con un se una qualsiasi delle colonne di dati di reader origine in ingresso è costituita da colonne calcolate.The load operation will fail with an InvalidOperationException if any of the source data columns in the incoming reader are computed columns.

Il loadOption parametro consente di specificare la modalità di interazione dei dati importati con i dati esistenti e può essere uno qualsiasi dei valori LoadOption dell'enumerazione.The loadOption parameter allows you to specify how you want the imported data to interact with existing data, and can be any of the values from the LoadOption enumeration. Per ulteriori informazioni sull'utilizzo DataTable di questo parametro, vedere la documentazione relativa al Load metodo.See the documentation for the DataTableLoad method for more information on using this parameter.

Il errorHandler parametro è un FillErrorEventHandler delegato che fa riferimento a una routine chiamata quando si verifica un errore durante il caricamento dei dati.The errorHandler parameter is a FillErrorEventHandler delegate that refers to a procedure that is called when an error occurs while loading data. Il FillErrorEventArgs parametro passato alla stored procedure fornisce proprietà che consentono di recuperare informazioni sull'errore che si è verificato, sulla riga di dati corrente e sull' DataTable oggetto da riempire.The FillErrorEventArgs parameter passed to the procedure provides properties that allow you to retrieve information about the error that occurred, the current row of data, and the DataTable being filled. Utilizzando questo meccanismo di delega, anziché un blocco try/catch più semplice, è possibile determinare l'errore, gestire la situazione e continuare l'elaborazione, se lo si desidera.Using this delegate mechanism, rather than a simpler try/catch block, allows you to determine the error, handle the situation, and continue processing if you like. 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à false su per indicare che si desidera interrompere l'elaborazione.The FillErrorEventArgs parameter supplies a Continue property: set this property to true to indicate that you have handled the error and wish to continue processing; set the property to false to indicate that you wish to halt processing. Tenere presente che l'impostazione della proprietà false su determina la generazione di un'eccezione da parte del codice che ha generato il problema.Be aware that setting the property to false causes the code that triggered the problem to throw an exception.

Il tables parametro consente di specificare una matrice di istanze DataTable di, che indica l'ordine delle tabelle corrispondenti a ogni set di risultati caricato dal reader.The tables parameter allows you to specify an array of DataTable instances, indicating the order of the tables corresponding to each result set loaded from the reader. Il Load metodo compila ogni istanza fornita DataTable con i dati di un singolo set di risultati dal lettore dati di origine.The Load method fills each supplied DataTable instance with data from a single result set from the source data reader. Dopo ogni set di risultati, Load il metodo passa al set di risultati successivo all'interno del lettore, fino a quando non sono presenti altri set di risultati.After each result set, the Load method moves on to the next result set within the reader, until there are no more result sets.

Lo schema di risoluzione dei nomi per questo metodo è uguale a quello seguito dal Fill metodo DbDataAdapter della classe.The name resolution scheme for this method is the same as that followed by the Fill method of the DbDataAdapter class.

Vedi anche

Si applica a