DataSet.Load Méthode

Définition

Remplit un DataSet avec des valeurs issues d'une source de données à l'aide du IDataReader fourni.

Surcharges

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.

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.

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.

Remarques

La Load méthode fournit une technique pour remplir un seul DataTable avec des données, récupérée à partir d’une 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 au sein d’un 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.

La 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 l’ajout au conteneur de données actuel (dans ce cas, a DataSet ). Ces scénarios décrivent l’utilisation standard d’un DataSet , décrivant ses comportements de mise à jour et de fusion.

Effectue une DataSet synchronisation ou une mise à jour avec une seule source de données primaire. Le DataSet effectue le suivi des modifications, ce qui permet la synchronisation avec la source de données principale. En outre, un DataSet peut accepter des données incrémentielles provenant d’une ou de plusieurs sources de données secondaires. Le DataSet n’est pas responsable du suivi des modifications afin d’autoriser la synchronisation avec la source de données secondaire.

Compte tenu de ces deux sources de données hypothétiques, un utilisateur est susceptible d’exiger l’un des comportements suivants :

  • Initialise DataSet à partir d’une source de données primaire. Dans ce scénario, l’utilisateur souhaite initialiser un vide DataSet avec les valeurs de la source de données principale. Un ou plusieurs contenus de DataTable sont modifiés. Plus tard, l’utilisateur a l’intention de propager les modifications vers la source de données principale.

  • Conservez les modifications et resynchronisez-les à partir de la source de données principale. Dans ce scénario, l’utilisateur souhaite prendre la valeur DataSet remplie dans le scénario précédent et effectuer une synchronisation incrémentielle avec la source de données principale, en préservant les modifications apportées dans le DataSet .

  • Flux de données incrémentiel à partir de sources de données secondaires. Dans ce scénario, l’utilisateur souhaite fusionner les modifications à partir d’une ou de plusieurs sources de données secondaires, et propager ces modifications vers la source de données principale.

La Load méthode rend possible tous ces scénarios. Cette méthode vous permet de spécifier un paramètre d’option de chargement, qui indique comment les lignes déjà DataTable associées à des lignes sont chargées. Le tableau suivant décrit les trois options de chargement fournies par l' LoadOption énumération. 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.

Option de chargement Description
PreserveChanges (valeur par défaut) Met à jour la version d’origine de la ligne avec la valeur de la ligne entrante.
OverwriteChanges Met à jour les versions actuelles et d’origine de la ligne avec la valeur de la ligne entrante.
Upsert Met à jour la version actuelle de la ligne avec la valeur de la ligne entrante.

En général, les PreserveChanges OverwriteChanges options et sont destinées aux scénarios dans lesquels l’utilisateur doit synchroniser le DataSet et ses modifications avec la source de données principale. L' Upsert option facilite l’agrégation des modifications à partir d’une ou de plusieurs sources de données secondaires.

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.

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

Paramètres

reader
IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.

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.

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. Chacune de ces tables doit être membre du DataTableCollection contenu par ce DataSet.

Exemples

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

Remarques

La Load méthode fournit une technique pour remplir un seul DataTable avec des données, récupérée à partir d’une 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 au sein d’un DataSet .

Notes

L’opération de chargement échouera avec un InvalidOperationException si l’une des colonnes de données sources dans le entrant correspond à des reader colonnes calculées.

Le loadOption paramètre vous permet de spécifier la manière dont vous souhaitez que les données importées interagissent avec les données existantes, et peut être l’une des valeurs de l' LoadOption énumération. DataTable Load Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation relative à la méthode.

Le tables paramètre vous permet de spécifier un tableau d' DataTable instances, en indiquant l’ordre des tables correspondant à chaque jeu de résultats chargé à partir du lecteur. La Load méthode remplit chaque instance fournie DataTable avec les données d’un jeu de résultats unique à partir du lecteur de données source. Après chaque jeu de résultats, la Load méthode passe au jeu de résultats suivant dans le lecteur, jusqu’à ce qu’il n’y ait plus aucun jeu de résultats.

Le schéma de résolution de noms pour cette méthode est le même que celui suivi par la Fill méthode de la DbDataAdapter classe.

Voir aussi

S’applique à

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.

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

Paramètres

reader
IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.

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.

tables
String[]

Tableau de chaînes à partir duquel la méthode Load récupère les informations de nom de table.

Exemples

L’exemple d’application console suivant crée d’abord des tables et charge des données à partir d’un lecteur dans un DataSet , à l’aide de la Load méthode. L’exemple ajoute ensuite des tables à un DataSet et tente de remplir les tables avec les données d’un DataTableReader . Dans cet exemple, étant donné que les paramètres passés à la Load méthode indiquent un nom de table qui n’existe pas, la Load méthode crée une nouvelle table qui correspond au nom passé comme paramètre. Une fois les données chargées, l’exemple affiche le contenu de toutes ses tables dans la fenêtre de 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

Remarques

La Load méthode fournit une technique pour remplir un seul DataTable avec des données, récupérée à partir d’une 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 au sein d’un DataSet .

Notes

L’opération de chargement échouera avec un InvalidOperationException si l’une des colonnes de données sources dans le entrant correspond à des reader colonnes calculées.

Le loadOption paramètre vous permet de spécifier la manière dont vous souhaitez que les données importées interagissent avec les données existantes, et peut être l’une des valeurs de l' LoadOption énumération. LoadPour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation relative à la méthode.

Le tables paramètre vous permet de spécifier un tableau de noms de tables, en indiquant l’ordre des tables correspondant à chaque jeu de résultats chargé à partir du lecteur. La Load méthode tente de trouver une table dans la qui DataSet correspond au nom trouvé dans le tableau des noms de table, dans l’ordre. Si une table correspondante est trouvée, cette table est chargée avec le contenu du jeu de résultats actuel. Si aucune table correspondante n’est trouvée, une table est créée à l’aide du nom fourni dans le tableau des noms de table, et le schéma de la nouvelle table est déduit à partir du jeu de résultats. Après chaque jeu de résultats, la Load méthode passe au jeu de résultats suivant dans le lecteur, jusqu’à ce qu’il n’y ait plus aucun jeu de résultats.

L’espace de noms par défaut associé à DataSet , le cas échéant, est associé à chaque nouvellement créé DataTable . Le schéma de résolution de noms pour cette méthode est le même que celui suivi par la Fill méthode de la DbDataAdapter classe.

Voir aussi

S’applique à

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.

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

Paramètres

reader
IDataReader

IDataReader qui fournit un ou plusieurs jeux de résultats.

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.

errorHandler
FillErrorEventHandler

Un délégué FillErrorEventHandler à appeler lorsqu'une erreur se produit en chargeant des données.

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.

Exemples

L’exemple suivant ajoute une table à un DataSet , puis tente d’utiliser la Load méthode pour charger des données à partir d’un DataTableReader qui contient un schéma incompatible. Au lieu de piéger l’erreur, cet exemple utilise un FillErrorEventHandler délégué pour examiner et gérer l’erreur. La sortie s’affiche dans la fenêtre de 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

Remarques

La Load méthode fournit une technique pour remplir un seul DataTable avec des données, récupérée à partir d’une 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 au sein d’un DataSet .

Notes

L’opération de chargement échouera avec un InvalidOperationException si l’une des colonnes de données sources dans le entrant correspond à des reader colonnes calculées.

Le loadOption paramètre vous permet de spécifier la manière dont vous souhaitez que les données importées interagissent avec les données existantes, et peut être l’une des valeurs de l' LoadOption énumération. DataTable Load Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation relative à la méthode.

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. Le FillErrorEventArgs paramètre passé à 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 de données actuelle et le DataTable en cours de remplissage. À l’aide de ce mécanisme délégué, plutôt qu’un bloc try/catch plus simple, vous permet de déterminer l’erreur, de gérer la situation et de poursuivre le traitement si vous le souhaitez. Le FillErrorEventArgs paramètre fournit une Continue propriété : affectez à cette propriété la valeur true pour indiquer que vous avez géré l’erreur et souhaitez continuer le traitement ; affectez à la propriété la valeur false pour indiquer que vous souhaitez interrompre le traitement. N’oubliez pas que la définition de la propriété sur false entraîne la levée d’une exception par le code qui a déclenché le problème.

Le tables paramètre vous permet de spécifier un tableau d' DataTable instances, en indiquant l’ordre des tables correspondant à chaque jeu de résultats chargé à partir du lecteur. La Load méthode remplit chaque instance fournie DataTable avec les données d’un jeu de résultats unique à partir du lecteur de données source. Après chaque jeu de résultats, la Load méthode passe au jeu de résultats suivant dans le lecteur, jusqu’à ce qu’il n’y ait plus aucun jeu de résultats.

Le schéma de résolution de noms pour cette méthode est le même que celui suivi par la Fill méthode de la DbDataAdapter classe.

Voir aussi

S’applique à