DataSet.Load Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Füllt eine DataSet mit Werten aus einer Datenquelle, die den angegebenen IDataReader verwendet.
Überlädt
Load(IDataReader, LoadOption, DataTable[]) |
Füllt ein DataSet mit Werten aus einer Datenquelle. Dazu werden der bereitgestellte IDataReader sowie ein Array von DataTable-Instanzen verwendet, mit dem Schema- und Namespaceinformationen bereitgestellt werden. |
Load(IDataReader, LoadOption, String[]) |
Füllt ein DataSet mit Werten aus einer Datenquelle. Dazu wird der bereitgestellte IDataReader sowie ein Array von Zeichenfolgen verwendet, mit dem die Namen der Tabellen im |
Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[]) |
Füllt ein DataSet mit Werten aus einer Datenquelle. Dazu werden der bereitgestellte IDataReader sowie ein Array von DataTable-Instanzen verwendet, mit dem Schema- und Namespaceinformationen bereitgestellt werden. |
Hinweise
Die Load -Methode bietet eine Technik zum Auffüllen einer Einzelnen DataTable mit Daten, die aus einem IDataReader instance abgerufen werden. Diese Methode bietet die gleiche Funktionalität, ermöglicht ihnen jedoch das Laden mehrerer Resultsets aus einem IDataReader
in mehrere Tabellen innerhalb eines DataSet
.
Wenn die DataSet
bereits Zeilen enthält, werden die eingehenden Daten aus der Datenquelle mit den vorhandenen Zeilen zusammengeführt.
Die Load
-Methode kann in mehreren gängigen Szenarien verwendet werden, die sich alle auf das Abrufen von Daten aus einer angegebenen Datenquelle und das Hinzufügen dieser Daten zum aktuellen Datencontainer (in diesem Fall ein DataSet
) beziehen. In diesen Szenarien wird die Standardverwendung für eine DataSet
beschrieben, wobei das Update- und Mergeverhalten beschrieben wird.
Ein DataSet
synchronisiert oder aktualisiert mit einer einzelnen primären Datenquelle. Verfolgt DataSet
Änderungen nach, sodass eine Synchronisierung mit der primären Datenquelle möglich ist. Darüber hinaus kann ein DataSet
inkrementelle Daten aus einer oder mehreren sekundären Datenquellen akzeptieren. Ist DataSet
nicht für die Nachverfolgung von Änderungen verantwortlich, um die Synchronisierung mit der sekundären Datenquelle zuzulassen.
Angesichts dieser beiden hypothetischen Datenquellen benötigt ein Benutzer wahrscheinlich eines der folgenden Verhaltensweisen:
Initialisieren
DataSet
von einer primären Datenquelle. In diesem Szenario möchte der Benutzer eine leereDataSet
mit Werten aus der primären Datenquelle initialisieren. Der Inhalt einer oder mehrerer DataTables wird geändert. Später möchte der Benutzer Änderungen zurück an die primäre Datenquelle weitergeben.Behalten Sie Änderungen bei, und synchronisieren Sie sie erneut aus der primären Datenquelle. In diesem Szenario möchte der Benutzer die
DataSet
im vorherigen Szenario ausgefüllte übernehmen und eine inkrementelle Synchronisierung mit der primären Datenquelle durchführen, wobei die in derDataSet
vorgenommenen Änderungen beibehalten werden.Inkrementeller Datenfeed aus sekundären Datenquellen. In diesem Szenario möchte der Benutzer Änderungen aus einer oder mehreren sekundären Datenquellen zusammenführen und diese Änderungen zurück an die primäre Datenquelle weitergeben.
Die Load
-Methode ermöglicht all diese Szenarien. Mit dieser Methode können Sie einen Parameter für die Ladeoption angeben, der angibt, wie Zeilen, die bereits in einem DataTable enthalten sind, mit den geladenen Zeilen kombiniert werden. In der folgenden Tabelle werden die drei Ladeoptionen beschrieben, die von der LoadOption Enumeration bereitgestellt werden. In jedem Fall gibt die Beschreibung das Verhalten an, wenn der Primärschlüssel einer Zeile in den eingehenden Daten mit dem Primärschlüssel einer vorhandenen Zeile übereinstimmt.
Option "Laden" | Beschreibung |
---|---|
PreserveChanges (Standardwert) |
Updates die ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile. |
OverwriteChanges |
Updates die aktuelle und die ursprüngliche Version der Zeile mit dem Wert der eingehenden Zeile. |
Upsert |
Updates die aktuelle Version der Zeile mit dem Wert der eingehenden Zeile. |
Im Allgemeinen sind die PreserveChanges
Optionen und OverwriteChanges
für Szenarien vorgesehen, in denen der Benutzer und die DataSet
zugehörigen Änderungen mit der primären Datenquelle synchronisieren muss. Die Upsert
Option erleichtert das Aggregieren von Änderungen aus einer oder mehreren sekundären Datenquellen.
Load(IDataReader, LoadOption, DataTable[])
- Quelle:
- DataSet.cs
- Quelle:
- DataSet.cs
- Quelle:
- DataSet.cs
Füllt ein DataSet mit Werten aus einer Datenquelle. Dazu werden der bereitgestellte IDataReader sowie ein Array von DataTable-Instanzen verwendet, mit dem Schema- und Namespaceinformationen bereitgestellt werden.
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())
Parameter
- reader
- IDataReader
Ein IDataReader, der ein oder mehrere Resultsets bereitstellt.
- loadOption
- LoadOption
Ein Wert aus der LoadOption-Enumeration, der angibt, wie bereits in den DataTable-Instanzen des DataSet vorhandene Zeilen mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.
- tables
- DataTable[]
Ein Array von DataTable-Instanzen, aus dem die Load(IDataReader, LoadOption, DataTable[])-Methode Namens- und Namespaceinformationen abruft. Jede dieser Tabellen muss ein Member der DataTableCollection sein, die in diesem DataSet enthalten ist.
Beispiele
Im folgenden Beispiel wird eine neue DataSeterstellt, der zwei DataTable Instanzen DataSethinzugefügt und dann mit der Load -Methode gefülltDataSet, wobei Daten aus einer DataTableReader abgerufen werden, die zwei Resultsets enthält. Schließlich zeigt das Beispiel den Inhalt der Tabellen im Konsolenfenster an.
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
Hinweise
Die Load -Methode bietet eine Technik zum Auffüllen einer Einzelnen DataTable mit Daten, die aus einem IDataReader instance abgerufen werden. Diese Methode bietet die gleiche Funktionalität, ermöglicht ihnen jedoch das Laden mehrerer Resultsets aus einem IDataReader in mehrere Tabellen innerhalb eines DataSet.
Hinweis
Der Ladevorgang schlägt mit einem InvalidOperationException fehl, wenn eine der Quelldatenspalten in den eingehenden reader
Spalten berechnet ist.
Mit loadOption
dem Parameter können Sie angeben, wie die importierten Daten mit vorhandenen Daten interagieren sollen. Dies kann jeder der Werte aus der LoadOption Enumeration sein. Weitere Informationen zur Verwendung dieses Parameters finden Sie in der DataTableLoad Dokumentation zur -Methode.
Mit tables
dem -Parameter können Sie ein Array von DataTable Instanzen angeben, das die Reihenfolge der Tabellen angibt, die den einzelnen Resultsets entsprechen, die vom Reader geladen werden. Die Load -Methode füllt jede bereitgestellte DataTable instance mit Daten aus einem einzelnen Resultset aus dem Quelldatenleser. Nach jedem Resultset wechselt die Load Methode zum nächsten Resultset innerhalb des Readers, bis keine Resultsets mehr vorhanden sind.
Das Namensauflösungsschema für diese Methode entspricht dem Schema, auf das die Fill -Methode der DbDataAdapter -Klasse folgt.
Weitere Informationen
Gilt für:
Load(IDataReader, LoadOption, String[])
- Quelle:
- DataSet.cs
- Quelle:
- DataSet.cs
- Quelle:
- DataSet.cs
Füllt ein DataSet mit Werten aus einer Datenquelle. Dazu wird der bereitgestellte IDataReader sowie ein Array von Zeichenfolgen verwendet, mit dem die Namen der Tabellen im DataSet
bereitgestellt werden.
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())
Parameter
- reader
- IDataReader
Ein IDataReader, der ein oder mehrere Resultsets bereitstellt.
- loadOption
- LoadOption
Ein Wert aus der LoadOption-Enumeration, der angibt, wie bereits in den DataTable-Instanzen des DataSet
vorhandene Zeilen mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.
- tables
- String[]
Ein Zeichenfolgenarray, aus dem die Load
-Methode Tabellennameninformationen abruft.
Beispiele
Im folgenden Konsolenanwendungsbeispiel werden zunächst Tabellen erstellt und Daten von einem Reader in ein DataSetgeladen, wobei die Load
-Methode verwendet wird. Im Beispiel werden dann Tabellen zu einer DataSet hinzugefügt, und es wird versucht, die Tabellen mit Daten aus einer DataTableReaderzu füllen. Da in diesem Beispiel die an die -Methode übergebenen Parameter einen Tabellennamen angeben, der Load
nicht vorhanden ist, erstellt die Load
Methode eine neue Tabelle, die dem als Parameter übergebenen Namen entspricht. Nachdem die Daten geladen wurden, zeigt das Beispiel den Inhalt aller zugehörigen Tabellen im Konsolenfenster an.
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
Hinweise
Die Load -Methode bietet eine Technik zum Auffüllen einer Einzelnen DataTable mit Daten, die aus einem IDataReader instance abgerufen werden. Diese Methode bietet die gleiche Funktionalität, ermöglicht ihnen jedoch das Laden mehrerer Resultsets aus einem IDataReader
in mehrere Tabellen innerhalb eines DataSet
.
Hinweis
Der Ladevorgang schlägt mit einem InvalidOperationException fehl, wenn eine der Quelldatenspalten in den eingehenden reader
Spalten berechnet ist.
Mit loadOption
dem Parameter können Sie angeben, wie die importierten Daten mit vorhandenen Daten interagieren sollen. Dies kann jeder der Werte aus der LoadOption Enumeration sein. Weitere Informationen zur Verwendung dieses Parameters finden Sie in der Load Dokumentation zur -Methode.
Mit tables
dem Parameter können Sie ein Array von Tabellennamen angeben, das die Reihenfolge der Tabellen angibt, die den einzelnen vom Reader geladenen Resultsets entsprechen. Die Load
-Methode versucht, eine Tabelle in der DataSet
Reihenfolge zu finden, die mit dem Namen übereinstimmt, der im Array der Tabellennamen gefunden wurde. Wenn eine übereinstimmende Tabelle gefunden wird, wird diese Tabelle mit dem Inhalt des aktuellen Resultsets geladen. Wenn keine übereinstimmende Tabelle gefunden wird, wird eine Tabelle mit dem im Array der Tabellennamen angegebenen Namen erstellt, und das Schema der neuen Tabelle wird aus dem Resultset abgeleitet. Nach jedem Resultset wechselt die Load
Methode zum nächsten Resultset innerhalb des Readers, bis keine Resultsets mehr vorhanden sind.
Der Standardnamespace DataSet
, der zugeordnet ist, falls vorhanden, ist jedem neu erstellten DataTable
zugeordnet. Das Namensauflösungsschema für diese Methode entspricht dem Schema, auf das die Fill -Methode der DbDataAdapter -Klasse folgt.
Weitere Informationen
Gilt für:
Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])
- Quelle:
- DataSet.cs
- Quelle:
- DataSet.cs
- Quelle:
- DataSet.cs
Füllt ein DataSet mit Werten aus einer Datenquelle. Dazu werden der bereitgestellte IDataReader sowie ein Array von DataTable-Instanzen verwendet, mit dem Schema- und Namespaceinformationen bereitgestellt werden.
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())
Parameter
- reader
- IDataReader
Ein IDataReader, der ein oder mehrere Resultsets bereitstellt.
- loadOption
- LoadOption
Ein Wert aus der LoadOption-Enumeration, der angibt, wie bereits in den DataTable-Instanzen des DataSet vorhandene Zeilen mit eingehenden Zeilen kombiniert werden, die denselben Primärschlüssel aufweisen.
- errorHandler
- FillErrorEventHandler
Ein FillErrorEventHandler-Delegat, der aufgerufen wird, wenn beim Laden von Daten Fehler auftreten.
- tables
- DataTable[]
Ein Array von DataTable-Instanzen, aus dem die Load(IDataReader, LoadOption, FillErrorEventHandler, DataTable[])-Methode Namens- und Namespaceinformationen abruft.
Beispiele
Im folgenden Beispiel wird einer DataSeteine Tabelle hinzugefügt, und dann wird versucht, die Load -Methode zu verwenden, um Daten aus einer DataTableReader zu laden, die ein inkompatibles Schema enthält. Anstatt den Fehler aufzufangen, wird in diesem Beispiel ein FillErrorEventHandler Delegat verwendet, um den Fehler zu untersuchen und zu behandeln. Die Ausgabe wird im Konsolenfenster angezeigt.
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
Hinweise
Die Load -Methode bietet eine Technik zum Auffüllen einer Einzelnen DataTable mit Daten, die aus einem IDataReader instance abgerufen werden. Diese Methode bietet die gleiche Funktionalität, ermöglicht ihnen jedoch das Laden mehrerer Resultsets aus einem IDataReader in mehrere Tabellen innerhalb eines DataSet.
Hinweis
Der Ladevorgang schlägt mit einem InvalidOperationException fehl, wenn eine der Quelldatenspalten in den eingehenden reader
Spalten berechnet ist.
Mit loadOption
dem Parameter können Sie angeben, wie die importierten Daten mit vorhandenen Daten interagieren sollen. Dies kann jeder der Werte aus der LoadOption Enumeration sein. Weitere Informationen zur Verwendung dieses Parameters finden Sie in der DataTableLoad Dokumentation zur -Methode.
Der errorHandler
Parameter ist ein FillErrorEventHandler Delegat, der auf eine Prozedur verweist, die aufgerufen wird, wenn beim Laden von Daten ein Fehler auftritt. Der FillErrorEventArgs an die Prozedur übergebene Parameter stellt Eigenschaften bereit, mit denen Sie Informationen zu dem aufgetretenen Fehler, der aktuellen Datenzeile und der DataTable zu füllenden Daten abrufen können. Wenn Sie diesen Delegatmechanismus anstelle eines einfacheren try/catch-Blocks verwenden, können Sie den Fehler ermitteln, die Situation behandeln und die Verarbeitung fortsetzen, wenn Sie möchten. Der FillErrorEventArgs Parameter stellt eine Continue Eigenschaft bereit: Legen Sie diese Eigenschaft auf fest true
, um anzugeben, dass Sie den Fehler behandelt haben und die Verarbeitung fortsetzen möchten. Legen Sie die -Eigenschaft auf fest false
, um anzugeben, dass Sie die Verarbeitung beenden möchten. Beachten Sie, dass das Festlegen der Eigenschaft auf false
bewirkt, dass der Code, der das Problem ausgelöst hat, eine Ausnahme auslöst.
Mit tables
dem -Parameter können Sie ein Array von DataTable Instanzen angeben, das die Reihenfolge der Tabellen angibt, die den einzelnen Resultsets entsprechen, die vom Reader geladen werden. Die Load -Methode füllt jede bereitgestellte DataTable instance mit Daten aus einem einzelnen Resultset aus dem Quelldatenleser. Nach jedem Resultset wechselt die Load Methode zum nächsten Resultset innerhalb des Readers, bis keine Resultsets mehr vorhanden sind.
Das Namensauflösungsschema für diese Methode entspricht dem Schema, auf das die Fill -Methode der DbDataAdapter -Klasse folgt.