Remplissage d'un DataSet à partir d'un DataAdapterPopulating a DataSet from a DataAdapter

ADO.NET DataSet est une représentation résidente en mémoire de données qui fournit un modèle de programmation relationnel cohérent indépendant de la source de données.The ADO.NET DataSet is a memory-resident representation of data that provides a consistent relational programming model independent of the data source. Le DataSet représente un jeu de données complet qui comprend des tables, des contraintes et des relations entre les tables.The DataSet represents a complete set of data that includes tables, constraints, and relationships among the tables. Étant donné que le DataSet est indépendant de la source de données, le DataSet peut inclure des données locales par rapport à l'application ainsi que des données provenant de plusieurs sources.Because the DataSet is independent of the data source, a DataSet can include data local to the application, and data from multiple data sources. L'interaction avec les sources de données existantes est contrôlée par le DataAdapter.Interaction with existing data sources is controlled through the DataAdapter.

La propriété SelectCommand du DataAdapter est un objet Command qui extrait les données de la source de données.The SelectCommand property of the DataAdapter is a Command object that retrieves data from the data source. Les propriétés InsertCommand, UpdateCommandet DeleteCommand du DataAdapter sont des objets Command qui gèrent les mises à jour des données dans la source de données conformément aux modifications apportées dans le DataSet.The InsertCommand, UpdateCommand, and DeleteCommand properties of the DataAdapter are Command objects that manage updates to the data in the data source according to modifications made to the data in the DataSet. Ces propriétés sont abordées plus en détail dans la mise à jour des Sources de données avec des DataAdapters.These properties are covered in more detail in Updating Data Sources with DataAdapters.

La méthode Fill du DataAdapter sert à remplir un DataSet avec les résultats de la SelectCommand du DataAdapter.The Fill method of the DataAdapter is used to populate a DataSet with the results of the SelectCommand of the DataAdapter. La méthodeFill prend comme arguments un DataSet à remplir, ainsi qu'un objet DataTable , ou le nom du DataTable à remplir avec les lignes retournées par SelectCommand.Fill takes as its arguments a DataSet to be populated, and a DataTable object, or the name of the DataTable to be filled with the rows returned from the SelectCommand.

Notes

L'utilisation du DataAdapter pour extraire une table dans son intégralité prend du temps, particulièrement si la table contient de nombreuses lignes.Using the DataAdapter to retrieve all of a table takes time, especially if there are many rows in the table. Cela vient du fait qu'accéder à la base de données, localiser et traiter les données, puis transférer les données au client prend du temps.This is because accessing the database, locating and processing the data, and then transferring the data to the client is time-consuming. L'extraction de l'intégralité de la table vers le client verrouille également toutes les lignes sur le serveur.Pulling all of the table to the client also locks all of the rows on the server. Pour améliorer les performances, vous pouvez utiliser la clause WHERE pour réduire drastiquement le nombre de lignes retournées au client.To improve performance, you can use the WHERE clause to greatly reduce the number of rows returned to the client. Vous pouvez également réduire la quantité de données retournées au client en répertoriant de façon explicite uniquement les colonnes requises dans l'instruction SELECT .You can also reduce the amount of data returned to the client by only explicitly listing required columns in the SELECT statement. Une autre solution de contournement efficace consiste à extraire les lignes par lots, par exemple plusieurs centaines de lignes à la fois, et à extraire le lot suivant uniquement lorsque le client a terminé le traitement du lot actuel.Another good workaround is to retrieve the rows in batches (such as several hundred rows at a time) and only retrieve the next batch when the client is finished with the current batch.

La méthode Fill utilise l'objet DataReader de manière implicite pour retourner les noms et les types de colonnes utilisés pour créer les tables du DataSetainsi que les données pour remplir les lignes des tables du DataSet.The Fill method uses the DataReader object implicitly to return the column names and types that are used to create the tables in the DataSet, and the data to populate the rows of the tables in the DataSet. Les tables et les colonnes ne sont créées que si elles n'existent pas encore ; sinon Fill utilise le schéma DataSet existant.Tables and columns are only created if they do not already exist; otherwise Fill uses the existing DataSet schema. Types de colonnes sont créées en tant que types .NET Framework en fonction des tableaux dans mappages de Type de données dans ADO.NET.Column types are created as .NET Framework types according to the tables in Data Type Mappings in ADO.NET. Les clés primaires ne sont pas créées, sauf si elles existent dans la source de données et que DataAdapter.MissingSchemaActionPrimary keys are not created unless they exist in the data source and DataAdapter.MissingSchemaAction a la valeur MissingSchemaAction.AddWithKey.is set to MissingSchemaAction.AddWithKey. Si Fill détecte qu'il existe une clé primaire pour une table, elle remplace les données du DataSet par celles de la source de données pour les lignes dont les valeurs de colonne de clé primaire correspondent à celles de la ligne retournée par la source de données.If Fill finds that a primary key exists for a table, it will overwrite data in the DataSet with data from the data source for rows where the primary key column values match those of the row returned from the data source. Si aucune clé primaire n'est trouvée, les données sont ajoutées à la table dans le DataSet.If no primary key is found, the data is appended to the tables in the DataSet. Fill utilise tous les mappages qui peuvent exister lorsque vous renseignez la DataSet (consultez DataAdapter mappages DataTable et DataColumn).Fill uses any mappings that may exist when you populate the DataSet (see DataAdapter DataTable and DataColumn Mappings).

Notes

Si SelectCommand retourne les résultats d'une jointure externe, le DataAdapter ne définit pas de valeur PrimaryKey pour le DataTableobtenu.If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a PrimaryKey value for the resulting DataTable. Vous devez définir vous-même la PrimaryKey pour garantir une résolution correcte des lignes dupliquées.You must define the PrimaryKey yourself to make sure that duplicate rows are resolved correctly. Pour plus d’informations, consultez définition des clés primaires.For more information, see Defining Primary Keys.

L'exemple de code suivant crée une instance d'un objet SqlDataAdapter qui utilise un objet SqlConnection sur la base de données Northwind Microsoft SQL Server et remplit un objet DataTable dans un DataSet avec la liste des clients.The following code example creates an instance of a SqlDataAdapter that uses a SqlConnection to the Microsoft SQL Server Northwind database and populates a DataTable in a DataSet with the list of customers. L'instruction SQL et les arguments SqlConnection passés au constructeur SqlDataAdapter sont utilisés pour créer la propriété SelectCommand de l'objet SqlDataAdapter.The SQL statement and SqlConnection arguments passed to the SqlDataAdapter constructor are used to create the SelectCommand property of the SqlDataAdapter.

ExempleExample

' Assumes that connection is a valid SqlConnection object.  
Dim queryString As String = _  
  "SELECT CustomerID, CompanyName FROM dbo.Customers"  
Dim adapter As SqlDataAdapter = New SqlDataAdapter( _  
  queryString, connection)  
  
Dim customers As DataSet = New DataSet  
adapter.Fill(customers, "Customers")  
// Assumes that connection is a valid SqlConnection object.  
string queryString =   
  "SELECT CustomerID, CompanyName FROM dbo.Customers";  
SqlDataAdapter adapter = new SqlDataAdapter(queryString, connection);  
  
DataSet customers = new DataSet();  
adapter.Fill(customers, "Customers");  

Notes

Ce code n'ouvre pas et ne ferme pas la Connectionde manière explicite.The code shown in this example does not explicitly open and close the Connection. La méthode Fill ouvre implicitement la Connection que le DataAdapter utilise si la connexion n'est pas déjà ouverte.The Fill method implicitly opens the Connection that the DataAdapter is using if it finds that the connection is not already open. Si Fill a ouvert la connexion, Fill la ferme aussi lorsque son exécution est terminée.If Fill opened the connection, it also closes the connection when Fill is finished. Cela peut simplifier votre code lorsque vous ne traitez qu'une seule opération comme Fill ou Update.This can simplify your code when you deal with a single operation such as a Fill or an Update. Cependant, si vous effectuez plusieurs opérations qui nécessitent une connexion ouverte, vous pouvez améliorer les performances de votre application en appelant de manière explicite la méthode Open de Connection, en effectuant les opérations sur la source de données, puis en appelant la méthode Close de Connection.However, if you are performing multiple operations that require an open connection, you can improve the performance of your application by explicitly calling the Open method of the Connection, performing the operations against the data source, and then calling the Close method of the Connection. Vous devez tenter de réduire autant que possible le temps d'ouverture des connexions à la source de données pour libérer des ressources afin que d'autres applications clientes puissent les utiliser.You should try to keep connections to the data source open as briefly as possible to free resources for use by other client applications.

Jeux de résultats multiplesMultiple Result Sets

Si le DataAdapter détecte plusieurs jeux de résultats, il crée plusieurs tables dans le DataSet.If the DataAdapter encounters multiple result sets, it creates multiple tables in the DataSet. Les tables reçoivent un nom incrémentiel par défaut de TableN, commençant par « Table » pour Table0.The tables are given an incremental default name of TableN, starting with "Table" for Table0. Si un nom de table est passé comme argument à la méthode Fill , les tables reçoivent le nom incrémentiel par défaut TableNameN, commençant par « TableName » pour TableName0.If a table name is passed as an argument to the Fill method, the tables are given an incremental default name of TableNameN, starting with "TableName" for TableName0.

Remplissage d'un DataSet à partir de plusieurs DataAdaptersPopulating a DataSet from Multiple DataAdapters

Un nombre quelconque de DataAdapter objets peuvent être utilisés avec un DataSet.Any number of DataAdapter objects can be used with a DataSet. Chaque DataAdapter peut être utilisé pour remplir un ou plusieurs objets DataTable et répercuter les mises à jour dans la source de données concernée.Each DataAdapter can be used to fill one or more DataTable objects and resolve updates back to the relevant data source. Les objetsDataRelation et Constraint peuvent être ajoutés localement au DataSet , ce qui vous permet de relier des données provenant de sources de données hétérogènes.DataRelation and Constraint objects can be added to the DataSet locally, which enables you to relate data from dissimilar data sources. Par exemple, un DataSet peut contenir des données provenant d'une base de données Microsoft SQL Server, d'une base de données IBM DB2 exposée via OLE DB et d'une source de données qui diffuse le XML en continu.For example, a DataSet can contain data from a Microsoft SQL Server database, an IBM DB2 database exposed through OLE DB, and a data source that streams XML. Un ou plusieurs objets DataAdapter peuvent gérer la communication vers chaque source de données.One or more DataAdapter objects can handle communication to each data source.

ExempleExample

L'exemple de code suivant remplit une liste de clients provenant de la base de données Northwind sur Microsoft SQL Server, ainsi qu'une liste de commandes provenant de la base de données Northwind stockée dans Microsoft Access 2000.The following code example populates a list of customers from the Northwind database on Microsoft SQL Server, and a list of orders from the Northwind database stored in Microsoft Access 2000. Les tables remplies sont reliées par un DataRelationet la liste des clients est ensuite affichée avec les commandes du client concerné.The filled tables are related with a DataRelation, and the list of customers is then displayed with the orders for that customer. Pour plus d’informations sur DataRelation , consultez Ajout de DataRelations et DataRelations accédant.For more information about DataRelation objects, see Adding DataRelations and Navigating DataRelations.

' Assumes that customerConnection is a valid SqlConnection object.  
' Assumes that orderConnection is a valid OleDbConnection object.  
Dim custAdapter As SqlDataAdapter = New SqlDataAdapter( _  
  "SELECT * FROM dbo.Customers", customerConnection)  
  
Dim ordAdapter As OleDbDataAdapter = New OleDbDataAdapter( _  
  "SELECT * FROM Orders", orderConnection)  
  
Dim customerOrders As DataSet = New DataSet()  
custAdapter.Fill(customerOrders, "Customers")  
ordAdapter.Fill(customerOrders, "Orders")  
  
Dim relation As DataRelation = _  
  customerOrders.Relations.Add("CustOrders", _  
  customerOrders.Tables("Customers").Columns("CustomerID"), _   
  customerOrders.Tables("Orders").Columns("CustomerID"))  
  
Dim pRow, cRow As DataRow  
For Each pRow In customerOrders.Tables("Customers").Rows  
  Console.WriteLine(pRow("CustomerID").ToString())  
  
  For Each cRow In pRow.GetChildRows(relation)  
    Console.WriteLine(vbTab & cRow("OrderID").ToString())  
  Next  
Next  
// Assumes that customerConnection is a valid SqlConnection object.  
// Assumes that orderConnection is a valid OleDbConnection object.  
SqlDataAdapter custAdapter = new SqlDataAdapter(  
  "SELECT * FROM dbo.Customers", customerConnection);  
OleDbDataAdapter ordAdapter = new OleDbDataAdapter(  
  "SELECT * FROM Orders", orderConnection);  
  
DataSet customerOrders = new DataSet();  
  
custAdapter.Fill(customerOrders, "Customers");  
ordAdapter.Fill(customerOrders, "Orders");  
  
DataRelation relation = customerOrders.Relations.Add("CustOrders",  
  customerOrders.Tables["Customers"].Columns["CustomerID"],  
  customerOrders.Tables["Orders"].Columns["CustomerID"]);  
  
foreach (DataRow pRow in customerOrders.Tables["Customers"].Rows)  
{  
  Console.WriteLine(pRow["CustomerID"]);  
   foreach (DataRow cRow in pRow.GetChildRows(relation))  
    Console.WriteLine("\t" + cRow["OrderID"]);  
}  

Type décimal SQL ServerSQL Server Decimal Type

Par défaut, le DataSet stocke les données à l’aide des types de données .NET Framework.By default, the DataSet stores data by using .NET Framework data types. Pour la plupart des applications, ils fournissent une représentation pratique des informations de la source de données.For most applications, these provide a convenient representation of data source information. Cette représentation peut néanmoins poser un problème lorsque le type de données dans la source de données est un decimal SQL Server ou un type de données numérique.However, this representation may cause a problem when the data type in the data source is a SQL Server decimal or numeric data type. Le .NET Framework decimal type de données autorise un maximum de 28 chiffres significatifs, tandis que le serveur SQL Server decimal type de données autorise 38 chiffres significatifs.The .NET Framework decimal data type allows a maximum of 28 significant digits, whereas the SQL Server decimal data type allows 38 significant digits. Si SqlDataAdapter détermine pendant une opération Fill que la précision d'un champ decimal SQL Server est supérieure à 28 caractères, la ligne actuelle n'est pas ajoutée au DataTable.If the SqlDataAdapter determines during a Fill operation that the precision of a SQL Server decimal field is larger than 28 characters, the current row is not added to the DataTable. Au lieu de cela, l'événement FillError se produit, ce qui vous permet de déterminer une éventuelle perte de précision et de répondre de manière appropriée.Instead the FillError event occurs, which enables you to determine whether a loss of precision will occur, and respond appropriately. Pour plus d’informations sur la FillError événement, consultez gestion des événements DataAdapter.For more information about the FillError event, see Handling DataAdapter Events. Pour obtenir la valeur decimal SQL Server, vous pouvez également utiliser un objet SqlDataReader et appeler la méthode GetSqlDecimal .To get the SQL Server decimal value, you can also use a SqlDataReader object and call the GetSqlDecimal method.

ADO.NET 2.0 a introduit meilleure prise en charge System.Data.SqlTypes dans le DataSet.ADO.NET 2.0 introduced enhanced support for System.Data.SqlTypes in the DataSet. Pour plus d'informations, consultez SqlTypes and the DataSet.For more information, see SqlTypes and the DataSet.

Chapitres OLE DBOLE DB Chapters

Les jeux de lignes hiérarchiques ou chapitres (DBTYPE_HCHAPTER de type OLE DB, adChapter de type ADO) peuvent être utilisés pour remplir le contenu d'un DataSet.Hierarchical rowsets, or chapters (OLE DB type DBTYPE_HCHAPTER, ADO type adChapter) can be used to fill the contents of a DataSet. Lorsque l'objet OleDbDataAdapter rencontre une colonne chapitre pendant une opération Fill , un DataTable est créé pour cette colonne et la table correspondante est remplie avec les colonnes et les lignes provenant du chapitre.When the OleDbDataAdapter encounters a chaptered column during a Fill operation, a DataTable is created for the chaptered column, and that table is filled with the columns and rows from the chapter. La table créée pour la colonne chapitre est nommée à l'aide des noms de la table parente et de la colonne chapitre sous la forme «ParentTableNameChapteredColumnName».The table created for the chaptered column is named by using both the parent table name and the chaptered column name in the form "ParentTableNameChapteredColumnName". Si une table correspondant au nom de la colonne chapitre existe déjà dans le DataSet , la table actuelle est remplie avec les données du chapitre.If a table already exists in the DataSet that matches the name of the chaptered column, the current table is filled with the chapter data. S'il n'y a pas de colonne, dans une table existante, qui corresponde à une colonne trouvée dans le chapitre, une nouvelle colonne est ajoutée.If there is no column in an existing table that matches a column found in the chapter, a new column is added.

Avant que les tables du DataSet ne soient remplies avec les données des colonnes chapitres, une relation est créée entre les tables parent et enfant du jeu de lignes hiérarchique par l'ajout d'une colonne d'entiers aux deux tables, la définition de l'incrémentation automatique de la colonne parente et la création d'un DataRelation à l'aide des colonnes ajoutées des deux tables.Before the tables in the DataSet are filled with the data in the chaptered columns, a relation is created between the parent and child tables of the hierarchical rowset by adding an integer column to both the parent and child table, setting the parent column to auto-increment, and creating a DataRelation using the added columns from both tables. La relation ajoutée est nommée à l'aide des noms de table parente et de colonne chapitre sous la forme «ParentTableNameChapterColumnName».The added relation is named by using the parent table and chapter column names in the form "ParentTableNameChapterColumnName".

Notez que la colonne associée n'existe que dans le DataSet.Note that the related column only exists in the DataSet. Les remplissages suivants à partir de la source de données peuvent engendrer l'ajout de nouvelles lignes aux tables plutôt que la fusion des modifications dans les lignes existantes.Subsequent fills from the data source can cause new rows to be added to the tables instead of changes being merged into existing rows.

Notez par ailleurs que si vous utilisez la surcharge DataAdapter.Fill qui prend un DataTable, seule cette table sera remplie.Note also that, if you use the DataAdapter.Fill overload that takes a DataTable, only that table will be filled. Une colonne entier auto-incrémentée sera toujours ajoutée à la table mais aucune table enfant ne sera créée ni remplie et aucune relation ne sera créée.An auto-incrementing integer column will still be added to the table, but no child table will be created or filled, and no relation will be created.

L'exemple suivant utilise le fournisseur MSDataShape pour générer une colonne chapitre de commandes pour chaque client d'une liste de clients.The following example uses the MSDataShape Provider to generate a chapter column of orders for each customer in a list of customers. Un DataSet est alors rempli avec les données.A DataSet is then filled with the data.

Using connection As OleDbConnection = New OleDbConnection( _  
  "Provider=MSDataShape;Data Provider=SQLOLEDB;" & _  
  "Data Source=(local);Integrated " & _  
  "Security=SSPI;Initial Catalog=northwind")  
  
Dim adapter As OleDbDataAdapter = New OleDbDataAdapter( _  
  "SHAPE {SELECT CustomerID, CompanyName FROM Customers} " & _  
  "APPEND ({SELECT CustomerID, OrderID FROM Orders} AS Orders " & _  
  "RELATE CustomerID TO CustomerID)", connection)  
  
Dim customers As DataSet = New DataSet()  
  
adapter.Fill(customers, "Customers")  
End Using  
using (OleDbConnection connection = new OleDbConnection("Provider=MSDataShape;Data Provider=SQLOLEDB;" +  
  "Data Source=(local);Integrated Security=SSPI;Initial Catalog=northwind"))  
{  
OleDbDataAdapter adapter = new OleDbDataAdapter("SHAPE {SELECT CustomerID, CompanyName FROM Customers} " +  
  "APPEND ({SELECT CustomerID, OrderID FROM Orders} AS Orders " +  
  "RELATE CustomerID TO CustomerID)", connection);  
  
DataSet customers = new DataSet();  
adapter.Fill(customers, "Customers");  
}  

Une fois l'opération Fill terminée, le DataSet contient deux tables : Customers et CustomersOrders, où CustomersOrders représente la colonne chapitre.When the Fill operation is complete, the DataSet contains two tables: Customers and CustomersOrders, where CustomersOrders represents the chaptered column. Une colonne supplémentaire nommée Orders est ajoutée à la table Customers et une colonne supplémentaire nommée CustomersOrders est ajoutée à la table CustomersOrders .An additional column named Orders is added to the Customers table, and an additional column named CustomersOrders is added to the CustomersOrders table. L'incrémentation automatique de la colonne Orders dans la table Customers est définie.The Orders column in the Customers table is set to auto-increment. Un DataRelation, CustomersOrders, est créé avec les colonnes ajoutées aux tables, Customers étant la table parente.A DataRelation, CustomersOrders, is created by using the columns that were added to the tables with Customers as the parent table. Les tableaux suivants présentent certains résultats de l'exemple.The following tables show some sample results.

TableName : CustomersTableName: Customers

CustomerIDCustomerID CompanyNameCompanyName OrdersOrders
ALFKIALFKI Alfreds FutterkisteAlfreds Futterkiste 00
ANATRANATR Ana Trujillo Emparedados y heladosAna Trujillo Emparedados y helados 11

TableName : CustomersOrdersTableName: CustomersOrders

CustomerIDCustomerID OrderIDOrderID CustomersOrdersCustomersOrders
ALFKIALFKI 1064310643 00
ALFKIALFKI 1069210692 00
ANATRANATR 1030810308 11
ANATRANATR 1062510625 11

Voir aussiSee also