DataSet.Load DataSet.Load DataSet.Load Method

Définition

Remplit un DataSet avec des valeurs issues d'une source de données à l'aide du IDataReader fourni.Fills a DataSet with values from a data source using the supplied IDataReader.

Surcharges

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

Remplit un DataSet avec des valeurs issues d'une source de données, à l'aide du IDataReader fourni, en utilisant un tableau d'instances de DataTable pour fournir les informations de schéma et d'espace de noms.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[])

Remplit un DataSet avec des valeurs issues d'une source de données, à l'aide du IDataReader fourni, en utilisant un tableau de chaînes pour fournir les noms des tables dans le 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[])

Remplit un DataSet avec des valeurs issues d'une source de données, à l'aide du IDataReader fourni, en utilisant un tableau d'instances de DataTable pour fournir les informations de schéma et d'espace de noms.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.

Remarques

Le Load méthode fournit une technique de remplissage d’un seul DataTable avec les données récupérées à partir d’un IDataReader instance.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Cette méthode fournit les mêmes fonctionnalités, mais vous permet de charger plusieurs jeux de résultats à partir d’un IDataReader dans plusieurs tables d’un DataSet.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Si DataSet contient déjà des lignes, les données entrantes à partir de la source de données sont fusionnées avec les lignes existantes.If the DataSet already contains rows, the incoming data from the data source is merged with the existing rows.

Le Load méthode peut être utilisée dans plusieurs scénarios courants, tous centrés sur l’obtention de données à partir d’une source de données spécifiée et en l’ajoutant au conteneur de données actuel (dans ce cas, un DataSet).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). Les scénarios suivants décrivent l’utilisation standard pour un DataSet, décrivant sa mise à jour et le comportement de la fusion.These scenarios describe standard usage for a DataSet, describing its update and merge behavior.

Un DataSet synchronise ou met à jour avec une source de données primaire.A DataSet synchronizes or updates with a single primary data source. Le DataSet effectue le suivi des modifications, autorisant la synchronisation avec la source de données primaire.The DataSet tracks changes, allowing synchronization with the primary data source. En outre, un DataSet peut accepter des données incrémentielles à partir d’une ou plusieurs sources de données secondaires.In addition, a DataSet can accept incremental data from one or more secondary data sources. Le DataSet n’est pas responsable du suivi des modifications afin de permettre la synchronisation avec la source de données secondaire.The DataSet isn't responsible for tracking changes in order to allow synchronization with the secondary data source.

Étant donné ces deux sources de données hypothétiques, un utilisateur est susceptible de demander un des comportements suivants :Given these two hypothetical data sources, a user is likely to require one of the following behaviors:

  • Initialiser DataSet à partir d’une source de données principale.Initialize DataSet from a primary data source. Dans ce scénario, l’utilisateur souhaite initialiser vide DataSet avec les valeurs de la source de données primaire.In this scenario, the user wants to initialize an empty DataSet with values from the primary data source. Un ou plusieurs de contenu du DataTable est modifiées.One or more DataTable's contents are modified. Plus tard l’utilisateur envisage de propager les modifications à la source de données primaire.Later the user intends to propagate changes back to the primary data source.

  • Conserver les modifications et ré-synchroniser à partir de la source de données primaire.Preserve changes and re-synchronize from the primary data source. Dans ce scénario, l’utilisateur souhaite prendre le DataSet rempli dans le scénario précédent et exécuter une synchronisation incrémentielle avec la source de données principale, en conservant les modifications apportées dans le DataSet.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.

  • Flux de données incrémentielles à partir de sources de données secondaires.Incremental data feed from secondary data sources. Dans ce scénario, l’utilisateur souhaite fusionner les modifications à partir d’une ou plusieurs sources de données secondaires et propager ces modifications à la source de données primaire.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.

Le Load méthode rend tous ces scénarios possibles.The Load method makes all these scenarios possible. Cette méthode vous permet de spécifier un paramètre d’option de chargement, indiquant comment les lignes déjà présentes dans un DataTable associées aux lignes en cours de chargement.This method allows you to specify a load option parameter, indicating how rows already in a DataTable combine with rows being loaded. Le tableau suivant décrit les trois options de chargement fournies par le LoadOption énumération.The following table describes the three load options provided by the LoadOption enumeration. Dans chaque cas, la description indique le comportement lorsque la clé primaire d’une ligne dans les données entrantes correspond à la clé primaire d’une ligne existante.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.

Option de chargementLoad Option DescriptionDescription
PreserveChanges (valeur par défaut)PreserveChanges (default) Met à jour la version d’origine de la ligne avec la valeur de la ligne entrante.Updates the original version of the row with the value of the incoming row.
OverwriteChanges Met à jour les versions actuelles et d’origine de la ligne avec la valeur de la ligne entrante.Updates the current and original versions of the row with the value of the incoming row.
Upsert Met à jour la version actuelle de la ligne avec la valeur de la ligne entrante.Updates the current version of the row with the value of the incoming row.

En règle générale, le PreserveChanges et OverwriteChanges options sont destinées aux scénarios dans lesquels l’utilisateur doit synchroniser le DataSet et ses modifications avec la source de données primaire.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. Le Upsert option facilite l’agrégation des modifications à partir d’une ou plusieurs sources de données secondaires.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[])

Remplit un DataSet avec des valeurs issues d'une source de données, à l'aide du IDataReader fourni, en utilisant un tableau d'instances de DataTable pour fournir les informations de schéma et d'espace de noms.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

Paramètres

reader
IDataReader IDataReader IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.An IDataReader that provides one or more result sets.

loadOption
LoadOption LoadOption LoadOption

Valeur issue de l'énumération LoadOption qui indique comment les lignes déjà présentes dans les instances de DataTable du DataSet seront associées aux lignes entrantes qui partagent la même clé primaire.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[]

Tableau d'instances de DataTable à partir desquelles la méthode Load(IDataReader, LoadOption, DataTable[]) récupère les informations de nom et d'espace de noms.An array of DataTable instances, from which the Load(IDataReader, LoadOption, DataTable[]) method retrieves name and namespace information. Chacune de ces tables doit être membre du DataTableCollection contenu par ce DataSet.Each of these tables must be a member of the DataTableCollection contained by this DataSet.

Exemples

L’exemple suivant crée un nouveau DataSet, ajoute deux DataTable instances à la DataSet, puis remplit le DataSet à l’aide de la Load méthode, la récupération des données à partir d’un DataTableReader qui contient deux jeux de résultats.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. Enfin, l’exemple affiche le contenu des tables dans la fenêtre de 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

Remarques

Le Load méthode fournit une technique de remplissage d’un seul DataTable avec les données récupérées à partir d’un IDataReader instance.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Cette méthode fournit les mêmes fonctionnalités, mais vous permet de charger plusieurs jeux de résultats à partir d’un IDataReader dans plusieurs tables d’un DataSet.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Notes

L’opération de chargement échoue avec un InvalidOperationException si les colonnes de données source en entrant reader sont des colonnes calculées.The load operation will fail with an InvalidOperationException if any of the source data columns in the incoming reader are computed columns.

Le loadOption paramètre vous permet de spécifier comment les données importées pour interagir avec des données existantes et peut prendre l’une des valeurs à partir de la LoadOption énumération.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. Consultez la documentation de la DataTable Load (méthode) pour plus d’informations sur l’utilisation de ce paramètre.See the documentation for the DataTableLoad method for more information on using this parameter.

Le tables paramètre vous permet de spécifier un tableau de DataTable instances, indiquant l’ordre des tables correspondant à chaque jeux de résultats chargés à partir du lecteur.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. Le Load méthode remplit chaque fourni DataTable instance avec les données en un seul jeu de résultats à partir du lecteur de données source.The Load method fills each supplied DataTable instance with data from a single result set from the source data reader. Après chaque jeu de résultats, le Load méthode passe au prochain jeu dans le lecteur, jusqu'à ce qu’il existe des jeux de résultats n’est plus de résultats.After each result set, the Load method moves on to the next result set within the reader, until there are no more result sets.

Le schéma de résolution de noms de cette méthode est identique à celui suivi par le Fill méthode de la DbDataAdapter classe.The name resolution scheme for this method is the same as that followed by the Fill method of the DbDataAdapter class.

Voir aussi

Load(IDataReader, LoadOption, String[]) Load(IDataReader, LoadOption, String[]) Load(IDataReader, LoadOption, String[])

Remplit un DataSet avec des valeurs issues d'une source de données, à l'aide du IDataReader fourni, en utilisant un tableau de chaînes pour fournir les noms des tables dans le 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

Paramètres

reader
IDataReader IDataReader IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.An IDataReader that provides one or more result sets.

loadOption
LoadOption LoadOption LoadOption

Valeur issue de l'énumération LoadOption qui indique comment les lignes déjà présentes dans les instances de DataTable du DataSet seront associées aux lignes entrantes qui partagent la même clé primaire.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[]

Tableau de chaînes à partir duquel la méthode Load récupère les informations de nom de table.An array of strings, from which the Load method retrieves table name information.

Exemples

Tout d’abord, l’exemple d’application Console suivant crée les tables et charge les données à partir d’un lecteur dans un DataSet, en utilisant le Load (méthode).The following Console application example first creates tables and loads data from a reader into a DataSet, using the Load method. L’exemple ajoute ensuite les tables à une DataSet et tente de se remplir les tables de données à partir d’un DataTableReader.The example then adds tables to a DataSet and attempts to fill the tables with data from a DataTableReader. Dans cet exemple, étant donné que les paramètres passés à la Load méthode indiquer un nom de table qui n’existe pas, le Load méthode crée une nouvelle table pour correspondre au nom passé comme paramètre.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. Une fois que les données ont été chargées, l’exemple affiche le contenu de toutes ses tables dans la fenêtre de 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

Remarques

Le Load méthode fournit une technique de remplissage d’un seul DataTable avec les données récupérées à partir d’un IDataReader instance.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Cette méthode fournit les mêmes fonctionnalités, mais vous permet de charger plusieurs jeux de résultats à partir d’un IDataReader dans plusieurs tables d’un DataSet.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Notes

L’opération de chargement échoue avec un InvalidOperationException si les colonnes de données source en entrant reader sont des colonnes calculées.The load operation will fail with an InvalidOperationException if any of the source data columns in the incoming reader are computed columns.

Le loadOption paramètre vous permet de spécifier comment les données importées pour interagir avec des données existantes et peut prendre l’une des valeurs à partir de la LoadOption énumération.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. Consultez la documentation de la Load méthode pour plus d’informations sur l’utilisation de ce paramètre.See the documentation for the Load method for more information on using this parameter.

Le tables paramètre vous permet de spécifier un tableau de noms de table, indiquant l’ordre des tables correspondant à chaque jeux de résultats chargés à partir du lecteur.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. Le Load méthode essaie de rechercher une table dans le DataSet correspondant au nom trouvé dans le tableau de noms de table, dans l’ordre.The Load method attempts to find a table within the DataSet matching the name found in the array of table names, in order. Si une table de correspondance est trouvée, cette table est chargée avec le contenu du jeu de résultats actuel.If a matching table is found, that table is loaded with the content of the current result set. Si aucune table correspondante n’est trouvée, une table est créée en utilisant le nom fourni dans le tableau de noms de table et schéma de la nouvelle table est déduit du jeu de résultats.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. Après chaque jeu de résultats, le Load méthode passe au prochain jeu dans le lecteur, jusqu'à ce qu’il existe des jeux de résultats n’est plus de résultats.After each result set, the Load method moves on to the next result set within the reader, until there are no more result sets.

L’espace de noms par défaut associé DataSet, le cas échéant, est associé à chaque nouvellement créé DataTable.The default namespace associated with DataSet, if any, is associated with each newly created DataTable. Le schéma de résolution de noms de cette méthode est identique à celui suivi par le Fill méthode de la DbDataAdapter classe.The name resolution scheme for this method is the same as that followed by the Fill method of the DbDataAdapter class.

Voir aussi

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

Remplit un DataSet avec des valeurs issues d'une source de données, à l'aide du IDataReader fourni, en utilisant un tableau d'instances de DataTable pour fournir les informations de schéma et d'espace de noms.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

Paramètres

reader
IDataReader IDataReader IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.An IDataReader that provides one or more result sets.

loadOption
LoadOption LoadOption LoadOption

Valeur issue de l'énumération LoadOption qui indique comment les lignes déjà présentes dans les instances de DataTable du DataSet seront associées aux lignes entrantes qui partagent la même clé primaire.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

Un délégué FillErrorEventHandler à appeler lorsqu'une erreur se produit en chargeant des données.A FillErrorEventHandler delegate to call when an error occurs while loading data.

tables
DataTable[]

Tableau d'instances de DataTable à partir desquelles la méthode Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) récupère les informations de nom et d'espace de noms.An array of DataTable instances, from which the Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) method retrieves name and namespace information.

Exemples

L’exemple suivant ajoute une table à une DataSet, puis tente d’utiliser le Load méthode pour charger des données à partir d’un DataTableReader qui contient un schéma incompatible.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. Au lieu d’intercepter l’erreur, cet exemple utilise un FillErrorEventHandler délégué pour examiner et gérer l’erreur.Rather than trapping the error, this example uses a FillErrorEventHandler delegate to investigate and handle the error. La sortie s’affiche dans la fenêtre de 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

Remarques

Le Load méthode fournit une technique de remplissage d’un seul DataTable avec les données récupérées à partir d’un IDataReader instance.The Load method provides a technique for filling a single DataTable with data, retrieved from an IDataReader instance. Cette méthode fournit les mêmes fonctionnalités, mais vous permet de charger plusieurs jeux de résultats à partir d’un IDataReader dans plusieurs tables d’un DataSet.This method provides the same functionality, but allows you to load multiple result sets from an IDataReader into multiple tables within a DataSet.

Notes

L’opération de chargement échoue avec un InvalidOperationException si les colonnes de données source en entrant reader sont des colonnes calculées.The load operation will fail with an InvalidOperationException if any of the source data columns in the incoming reader are computed columns.

Le loadOption paramètre vous permet de spécifier comment les données importées pour interagir avec des données existantes et peut prendre l’une des valeurs à partir de la LoadOption énumération.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. Consultez la documentation de la DataTable Load (méthode) pour plus d’informations sur l’utilisation de ce paramètre.See the documentation for the DataTableLoad method for more information on using this parameter.

Le errorHandler paramètre est un FillErrorEventHandler délégué qui fait référence à une procédure qui est appelée lorsqu’une erreur se produit lors du chargement des données.The errorHandler parameter is a FillErrorEventHandler delegate that refers to a procedure that is called when an error occurs while loading data. Le FillErrorEventArgs paramètre transmis à la procédure fournit des propriétés qui vous permettent de récupérer des informations sur l’erreur qui s’est produite, la ligne actuelle de données, et le DataTable remplie.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. À l’aide de ce mécanisme de délégué, au lieu d’un bloc try/catch plus simple, vous permet de déterminer l’erreur, gérer la situation et continuer le traitement si vous le souhaitez.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. Le FillErrorEventArgs paramètre fournit un Continue propriété : définissez cette propriété sur true pour indiquer que vous avez géré l’erreur et souhaitez continuer le traitement ; affectez à la propriété false pour indiquer que vous souhaitez arrêter le traitement.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. N’oubliez pas que la définition de la propriété false provoque le code qui a déclenché le problème pour lever une exception.Be aware that setting the property to false causes the code that triggered the problem to throw an exception.

Le tables paramètre vous permet de spécifier un tableau de DataTable instances, indiquant l’ordre des tables correspondant à chaque jeux de résultats chargés à partir du lecteur.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. Le Load méthode remplit chaque fourni DataTable instance avec les données en un seul jeu de résultats à partir du lecteur de données source.The Load method fills each supplied DataTable instance with data from a single result set from the source data reader. Après chaque jeu de résultats, le Load méthode passe au prochain jeu dans le lecteur, jusqu'à ce qu’il existe des jeux de résultats n’est plus de résultats.After each result set, the Load method moves on to the next result set within the reader, until there are no more result sets.

Le schéma de résolution de noms de cette méthode est identique à celui suivi par le Fill méthode de la DbDataAdapter classe.The name resolution scheme for this method is the same as that followed by the Fill method of the DbDataAdapter class.

Voir aussi

S’applique à