Partager via

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 permettant de remplir un seul DataTable avec des données, récupérées à partir d’un 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 leur ajout au conteneur de données actuel (dans ce cas, un DataSet). Ces scénarios décrivent l’utilisation standard d’un DataSet, décrivant son comportement de mise à jour et de fusion.

Un DataSet synchronise ou met à jour avec une seule source de données primaire. Effectue le DataSet suivi des modifications, ce qui permet la synchronisation avec la source de données primaire. En outre, un DataSet peut accepter des données incrémentielles provenant d’une ou de plusieurs sources de données secondaires. n’est DataSet 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 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. Le contenu d’un ou plusieurs DataTable sont modifiés. Plus tard, l’utilisateur a l’intention de propager les modifications à la source de données primaire.

  • Conservez les modifications et resynchroniser à partir de la source de données primaire. Dans ce scénario, l’utilisateur souhaite prendre le renseigné dans le DataSet 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 .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 de plusieurs sources de données secondaires et les propager à 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 la façon dont les lignes sont 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) Mises à jour la version d’origine de la ligne avec la valeur de la ligne entrante.
OverwriteChanges Mises à jour les versions actuelles et d’origine de la ligne avec la valeur de la ligne entrante.
Upsert Mises à jour la version actuelle de la ligne avec la valeur de la ligne entrante.

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

Load(IDataReader, LoadOption, DataTable[])

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

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 au , puis remplit le à DataSetl’aide DataSet de la Load méthode, récupérant 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 permettant de remplir un seul DataTable avec des données, récupérées à partir d’un 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 échoue avec un InvalidOperationException si l’une des colonnes de données sources dans les colonnes entrantes reader est calculée.

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 peut être l’une des valeurs de l’énumération LoadOption . Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation relative à 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 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 de jeux de résultats.

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

Voir aussi

S’applique à

Load(IDataReader, LoadOption, String[])

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

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 à 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 table correspondant au nom passé en tant que paramètre. Une fois les données chargées, l’exemple montre comment afficher 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’un 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 échoue avec un InvalidOperationException si l’une des colonnes de données sources dans les colonnes entrantes reader est calculée.

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 peut être l’une des valeurs de l’énumération LoadOption . Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation relative à 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 le DataSet nom correspondant au nom trouvé dans le tableau de 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 de 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 de jeux 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 de la Fill méthode de la DbDataAdapter classe .

Voir aussi

S’applique à

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

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

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 permettant de remplir un seul DataTable avec des données, récupérées à partir d’un 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 échoue avec un InvalidOperationException si l’une des colonnes de données sources dans les colonnes entrantes reader est calculée.

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 peut être l’une des valeurs de l’énumération LoadOption . Pour plus d’informations sur l’utilisation de ce paramètre, consultez la documentation relative à 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 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 remplissage. L’utilisation de ce mécanisme de 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 le traitement si vous le souhaitez. Le FillErrorEventArgs paramètre fournit une Continue propriété : définissez cette propriété sur true pour indiquer que vous avez géré l’erreur et que vous souhaitez continuer le traitement ; définissez la propriété sur false pour indiquer que vous souhaitez arrêter le traitement. N’oubliez pas que la définition de la propriété sur false entraîne la levée d’une exception dans le code qui a déclenché le problème.

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 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 de jeux de résultats.

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

Voir aussi

S’applique à