Fylla i en datauppsättning från en DataAdapter

ADO.NET DataSet är en minnesbaserad representation av data som tillhandahåller en konsekvent relationsprogrammeringsmodell oberoende av datakällan. DataSet Representerar en fullständig uppsättning data som innehåller tabeller, begränsningar och relationer mellan tabellerna. Eftersom är DataSet oberoende av datakällan kan en DataSet innehålla data som är lokala för programmet och data från flera datakällor. Interaktion med befintliga datakällor styrs via DataAdapter.

SelectCommand-egenskapen hos DataAdapter är ett Command-objekt som hämtar data från datakällan. Egenskaperna InsertCommand, UpdateCommand och DeleteCommand hos DataAdapter är Command objekt som hanterar uppdateringar av data i datakällan enligt ändringar som gjorts i data i DataSet. Dessa egenskaper beskrivs mer detaljerat i Uppdatera datakällor med DataAdapters.

Metoden Fill för DataAdapter används för att fylla i en DataSet med resultaten av SelectCommand av DataAdapter. Fill tar som argument en DataSet som ska fyllas i, och ett DataTable objekt, eller namnet på den DataTable som ska fyllas med raderna som returneras från SelectCommand.

Metoden Fill använder DataReader -objektet implicit för att returnera kolumnnamnen och typerna som används för att skapa tabellerna DataSeti , och data för att fylla i raderna i tabellerna DataSeti . Tabeller och kolumner skapas bara om de inte redan finns. använder annars Fill det befintliga DataSet schemat. Kolumntyper skapas som .NET Framework-typer enligt tabellerna i Datatypmappningar i ADO.NET. Primära nycklar skapas inte om de inte finns i datakällan och DataAdapter.MissingSchemaAction har angetts till MissingSchemaAction.AddWithKey. Om Fill finner att en primärnyckel finns för en tabell, skrivs data över i DataSet med data från datakällan för de rader vars primärnyckelvärden matchar de rader som returnerats från datakällan. Om ingen primärnyckel hittas läggs data till i tabellerna i DataSet. Fill använder alla mappningar som kan finnas när du fyller i DataSet (se DataAdapter DataTable- och DataColumn-mappningar).

I följande kodexempel skapas en instans av en SqlDataAdapter som använder en SqlConnection till Microsoft SQL Server-databasen Northwind och fyller en DataTable i en DataSet med kundlistan. SQL-instruktionen och argumenten SqlConnection som skickas till konstruktorn SqlDataAdapter används för att skapa egenskapen SelectCommand av SqlDataAdapter.

Exempel

' 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");  

Flera resultatuppsättningar

När DataAdapter stöter på flera resultatuppsättningar skapas flera tabeller i DataSet. Tabellerna får ett inkrementellt standardnamn för TabellN, från och med "Tabell" för Table0. Om ett tabellnamn skickas som ett argument till Fill metoden får tabellerna ett inkrementellt standardnamn för TableNameN, som börjar med "TableName" för TableName0.

Fylla i en datauppsättning från flera DataAdapters

Valfritt antal DataAdapter objekt kan användas med en DataSet. Varje DataAdapter kan användas för att fylla ett eller flera DataTable objekt och återställa uppdateringar tillbaka till relevant datakälla. DataRelation och Constraint objekt kan läggas till DataSet lokalt, vilket gör att du kan relatera data från olika datakällor. En kan till exempel DataSet innehålla data från en Microsoft SQL Server-databas, en IBM DB2-databas som exponeras via OLE DB och en datakälla som strömmar XML. Ett eller flera DataAdapter objekt kan hantera kommunikation till varje datakälla.

Exempel

I följande kodexempel fylls en lista över kunder från Northwind databasen på Microsoft SQL Server och en lista över beställningar från databasen Northwind som lagras i Microsoft Access 2000. De ifyllda tabellerna är relaterade till en DataRelation, och listan över kunder visas sedan med beställningarna för den kunden. Mer information om DataRelation objekt finns i Lägga till DataRelations och Navigera i 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"]);  
}  

SQL Server-decimaltyp

Som standard lagrar data DataSet med hjälp av .NET Framework-datatyper. För de flesta program ger dessa en bekväm representation av datakällans information. Den här representationen kan dock orsaka problem när datatypen i datakällan är en SQL Server-decimal eller numerisk datatyp. Datatypen .NET Framework decimal tillåter högst 28 signifikanta siffror, medan SQL Server-datatypen decimal tillåter 38 signifikanta siffror. Om det avgörs under en SqlDataAdapter-åtgärd att precisionen för ett SQL Server Fill-fält är större än 28 tecken, läggs inte den aktuella raden till i decimal. FillError I stället inträffar händelsen, som gör att du kan avgöra om en förlust av precision kommer att inträffa och svara på rätt sätt. Mer information om händelsen finns i FillErrorHantera DataAdapter-händelser. Om du vill hämta SQL Server-värdet decimal kan du också använda ett SqlDataReader objekt och anropa GetSqlDecimal metoden.

ADO.NET 2.0 introducerade förbättrat stöd för System.Data.SqlTypes i DataSet. Mer information finns i SqlTypes och DataSet.

OLE DB-kapitel

Hierarkiska raduppsättningar eller kapitel (OLE DB-typ DBTYPE_HCHAPTER, ADO-typ adChapter) kan användas för att fylla innehållet i en DataSet. När OleDbDataAdapter påträffar en kapitelkolumn under en Fill åtgärd, skapas en DataTable för kapitelkolumnen, och den tabellen fylls med kolumnerna och raderna från kapitlet. Tabellen som skapats för den kapitelindelade kolumnen namnges med hjälp av både det överordnade tabellnamnet och det kapitlade kolumnnamnet i formatet "ParentTableNameChapteredColumnName". Om det redan finns en tabell i DataSet som matchar namnet på den kapitlade kolumnen fylls den aktuella tabellen med kapiteldata. Om det inte finns någon kolumn i en befintlig tabell som matchar en kolumn som finns i kapitlet läggs en ny kolumn till.

Innan tabellerna i DataSet fylls med data i kolumner med kapitelindelning, skapas en relation mellan de överordnade och underordnade tabellerna i den hierarkiska raduppsättningen genom att lägga till en heltalskolumn i både den överordnade och underordnade tabellen, ange den överordnade kolumnen till automatisk inkrementering och skapa en DataRelation med hjälp av de tillagda kolumnerna från båda tabellerna. Den tillagda relationen namnges med hjälp av de överordnade tabell- och kapitelkolumnnamnen i formatet "ParentTableNameChapterColumnName".

Observera att den relaterade kolumnen bara finns i DataSet. Efterföljande fyllningar från datakällan kan leda till att nya rader läggs till i tabellerna i stället för att ändringar sammanfogas till befintliga rader.

Observera också att om du använder överlagringen DataAdapter.Fill som tar en DataTable, fylls endast tabellen i. En automatisk inkrementell heltalskolumn läggs fortfarande till i tabellen, men ingen underordnad tabell skapas eller fylls i och ingen relation skapas.

I följande exempel används MSDataShape-providern för att generera en kapitelkolumn med beställningar för varje kund i en lista över kunder. A DataSet fylls sedan med 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");  
}  

När åtgärden Fill är klar innehåller den DataSet två tabeller: Customers och CustomersOrders, där CustomersOrders representerar den kapitlade kolumnen. Ytterligare en kolumn med namnet Orders läggs till i Customers tabellen och ytterligare en kolumn med namnet CustomersOrders läggs till i CustomersOrders tabellen. Kolumnen Orders i Customers-tabellen är inställd på automatisk inkrementering. En DataRelation, CustomersOrders, skapas med hjälp av kolumnerna som lades till i tabellerna med Customers som överordnad tabell. Följande tabeller visar några exempelresultat.

TableName: Kunder

Tabellnamn: Kundordrar

Se även

• DataAdapters och DataReaders
• Datatypmappningar i ADO.NET
• Ändra data med en DbDataAdapter
• Flera aktiva resultatuppsättningar (MARS)
• översikt över ADO.NET