DataSet.Load Méthode

  • Référence

Définition

Espace de noms:
System.Data
Assembly:
System.Data.Common.dll
Assembly:
System.Data.dll
Assembly:
netstandard.dll

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ées à partir d’une IDataReader instance. Cette méthode fournit la même fonctionnalité, 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, toutes centrées sur l’obtention de données à partir d’une source de données spécifiée et son 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 son comportement de mise à jour et de fusion.

Une DataSet synchronisation ou une mise à jour avec une seule source de données primaire. Le DataSet 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 à partir d’une ou plusieurs sources de données secondaires. Il DataSet n’est pas responsable du suivi des modifications afin d’autoriser la synchronisation avec la source de données secondaire.

Étant donné ces deux sources de données hypothétiques, un utilisateur a probablement besoin de l’un des comportements suivants :

  • Initialiser DataSet à partir d’une source de données primaire. Dans ce scénario, l’utilisateur souhaite initialiser un vide DataSet avec des valeurs de la source de données primaire. 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 primaire.

  • Conservez les modifications et resynchronisez à partir de la source de données primaire. Dans ce scénario, l’utilisateur souhaite prendre le DataSet remplissage dans le scénario précédent et effectuer une synchronisation incrémentielle avec la source de données primaire, en conservant 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 d’une ou plusieurs sources de données secondaires et propager ces modifications vers la source de données primaire.

La Load méthode rend tous ces scénarios possibles. Cette méthode vous permet de spécifier un paramètre d’option de chargement, indiquant comment les lignes déjà dans une DataTable combinaison avec les lignes chargées. Le tableau suivant décrit les trois options de chargement fournies par l’énumération LoadOption . 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 options et OverwriteChanges les PreserveChanges options sont destinées aux scénarios dans lesquels l’utilisateur doit synchroniser et DataSet ses modifications avec la source de données primaire. L’option Upsert facilite l’agrégation des modifications d’une ou 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 DataSetnouveau , ajoute deux DataTable instances au DataSet, puis remplit la DataSet méthode à l’aide de la Load méthode, en récupérant des données à partir 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 permettant de remplir un seul DataTable avec des données, récupérées à partir d’une IDataReader instance. Cette méthode fournit la même fonctionnalité, mais vous permet de charger plusieurs jeux de résultats à partir d’une IDataReader dans plusieurs tables au sein d’un DataSet.

Notes

L’opération de chargement échoue avec une InvalidOperationException colonne de données source dans les colonnes entrantes reader .

Le loadOption paramètre vous permet de spécifier la façon dont vous souhaitez que les données importées interagissent avec les données existantes et peuvent être l’une des valeurs de l’énumération LoadOption . Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation de la DataTableLoad méthode.

Le tables paramètre vous permet de spécifier un tableau d’instances DataTable , 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 des données à partir 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 de jeux de résultats.

Le schéma de résolution de noms de cette méthode est identique à celui suivi de 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 d’un lecteur dans un DataSet, à l’aide de la Load méthode. L’exemple ajoute ensuite des tables à une DataSet et tente de remplir les tables avec des 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 table pour correspondre au nom passé en tant que paramètre. Une fois les données chargées, l’exemple affiche le contenu de toutes ses tables dans la fenêtre 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 permettant de remplir un seul DataTable avec des données, récupérées à partir d’une IDataReader instance. Cette méthode fournit la même fonctionnalité, mais vous permet de charger plusieurs jeux de résultats à partir d’une IDataReader dans plusieurs tables au sein d’un DataSet.

Notes

L’opération de chargement échoue avec une InvalidOperationException colonne de données source dans les colonnes entrantes reader .

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

Le tables paramètre vous permet de spécifier un tableau de noms de tables, 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 correspondance du DataSet 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 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 de jeux de résultats.

L’espace de noms par défaut associé DataSetà , le cas échéant, est associé à chaque nouvel espace de noms créé DataTable. Le schéma de résolution de noms de cette méthode est identique à celui suivi de 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 DataSettableau, puis tente d’utiliser la Load méthode pour charger des données à partir d’un DataTableReader schéma incompatible. Au lieu d’intercepter 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 permettant de remplir un seul DataTable avec des données, récupérées à partir d’une IDataReader instance. Cette méthode fournit la même fonctionnalité, mais vous permet de charger plusieurs jeux de résultats à partir d’une IDataReader dans plusieurs tables au sein d’un DataSet.

Notes

L’opération de chargement échoue avec une InvalidOperationException colonne de données source dans les colonnes entrantes reader .

Le loadOption paramètre vous permet de spécifier la façon dont vous souhaitez que les données importées interagissent avec les données existantes et peuvent être l’une des valeurs de l’énumération LoadOption . Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation de la DataTableLoad méthode.

Le errorHandler paramètre est un FillErrorEventHandler délégué qui fait référence à une procédure appelée lorsqu’une erreur se produit lors du chargement des données. 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 l’en DataTable cours de remplissage. L’utilisation 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 continuer à traiter si vous le souhaitez. Le FillErrorEventArgs paramètre fournit une Continue propriété : définissez cette propriété pour true indiquer que vous avez géré l’erreur et que vous souhaitez continuer à traiter ; définissez la propriété pour false indiquer que vous souhaitez arrêter le traitement. N’oubliez pas que la définition de la propriété pour false provoquer le code qui a déclenché le problème pour lever une exception.

Le tables paramètre vous permet de spécifier un tableau d’instances DataTable , 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 des données à partir 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 de jeux de résultats.

Le schéma de résolution de noms de cette méthode est identique à celui suivi de la Fill méthode de la DbDataAdapter classe.

Voir aussi

S’applique à