Exemplarische Vorgehensweise: Aktualisieren von Daten mit Hilfe einer Datenbank-Aktualisierungsabfrage in Web Forms unter Verwendung von Visual J#

Artikel
04/01/2008

Die Web Forms-Datenbindungsarchitektur ermöglicht Ihnen, Steuerelementeigenschaften an eine Datenquelle zu binden, wodurch das Anzeigen von Daten auf der Seite erleichtert wird. Die Datenbindungsarchitektur unterstützt allerdings keine Aktualisierungen, d. h., die Datenbindung in Web Forms-Seiten ist unidirektional. Da in den meisten Webanwendungen Daten gelesen, aber nicht aktualisiert werden, können durch die unidirektionale Datenbindung die Größe und Komplexität der Seitenarchitektur auf ein für die meisten üblichen Szenarien hinreichendes Maß beschränkt werden.

Allerdings können Situationen eintreten, in denen Sie Daten aktualisieren möchten. Dazu gibt es mehrere Möglichkeiten. Wenn Sie ein Dataset verwenden, können Sie die Änderungen in das Dataset schreiben und dann den Datenadapter aufrufen, um Änderungen des Datasets an die Datenbank zu senden. (Ein Beispiel für dieses Szenario finden Sie unter Exemplarische Vorgehensweise: Verwenden eines DataGrid-Websteuerelements zum Lesen und Schreiben von Daten mit Hilfe von Visual J#.) Sie können stattdessen auch die Datenbank mit Hilfe von SQL-Anweisungen oder gespeicherten Prozeduren direkt aktualisieren. Dies wird in dieser exemplarischen Vorgehensweise veranschaulicht.

Hinweis Weitere Informationen über das Auswählen des geeigneten Verfahrens finden Sie unter Empfehlungen zur Zugriffsstrategie auf Webdaten.

Diese exemplarische Vorgehensweise veranschaulicht, wie Sie eine Web Forms-Seite erstellen können, um Daten mit Hilfe von SQL-Anweisungen aus einer Datenbank zu lesen und in die Datenbank zu schreiben. In dieser exemplarischen Vorgehensweise verwenden Sie die Tabelle Categories aus der SQL Server-Datenbank Northwind. Sie können einen Datensatz auf der Seite auswählen, bearbeiten und in der Datenbank speichern. Wenn Sie fertig sind, sieht die Seite etwa folgendermaßen aus:

Diese exemplarische Vorgehensweise veranschaulicht die folgenden Konzepte:

Erstellen von Befehlsobjekten, die SQL-Anweisungen enthalten
Verwenden einer SQL-Anweisung und eines Datenlesers zum Abrufen von Daten aus der Datenbank
Erstellen von parametrisierten Abfragen
Festlegen von Abfrageparametern und Ausführen von Abfragen

Um die exemplarische Vorgehensweise nachzuvollziehen, benötigen Sie:

Zugriff auf einen Server mit der SQL Server-Beispieldatenbank Northwind.
Die erforderlichen Berechtigungen zum Erstellen von ASP.NET-Webanwendungsprojekten auf dem Computer, auf dem der Webserver installiert ist.

Die exemplarische Vorgehensweise ist in kleinere Einheiten gegliedert:

Erstellen der Web Forms-Seite.
Hinzufügen der erforderlichen Datenkomponenten.
Hinzufügen von Steuerelementen zum Anzeigen der Daten.
Hinzufügen von Code zum Lesen und Schreiben von Daten.

Erstellen von Projekt und Formular

Der erste Schritt besteht darin, eine Webanwendung und eine Web Forms-Seite zu erstellen.

So erstellen Sie das Projekt und das Formular

Zeigen Sie im Menü Datei auf Neu, und klicken Sie anschließend auf Projekt.
Führen Sie im Dialogfeld Neues Projekt Folgendes aus:
1. Wählen Sie im Bereich Projekttypen die Option Visual J#-Projekte.
2. Klicken Sie im Bereich Vorlagen auf ASP.NET-Webanwendung.
3. Geben Sie im Feld Speicherort den vollständigen URL der Anwendung einschließlich der Zeichenfolge http:// an, sowie den Namen des Servers und des Projekts. Auf dem Webserver muss IIS Version 5 oder höher sowie .NET Framework installiert sein. Wenn auf dem Computer IIS installiert ist, können Sie https://localhost als Server angeben.
  
  Wenn Sie auf OK klicken, wird im Stammverzeichnis des angegebenen Webservers ein neues Web Forms-Projekt erstellt. Zusätzlich wird im Web Forms-Designer in der Entwurfsansicht eine neue Web Forms-Seite mit der Bezeichnung WebForm1.aspx angezeigt.
  
  Tipp Bei Problemen mit der Erstellung eines Webanwendungsprojekts finden Sie weitere Informationen unter Dialogfeld "Webzugriffsfehler".

Hinzufügen der Datenkomponenten

Um auf Daten zugreifen zu können, müssen Sie eine Verbindung zur Datenbank herstellen, von der gelesen werden soll. Sie benötigen außerdem zwei Befehlsobjekte mit SQL-SELECT-Anweisungen, um die Daten aus der Datenbank zu lesen, und ein drittes Befehlsobjekt mit einer SQL-UPDATE-Anweisung, um die Daten in der Datenbank zu aktualisieren. Für zwei dieser Befehle sind Parameter erforderlich, so dass Sie Laufzeitwerte an die Anweisungen übergeben können, bevor Sie sie ausführen. (Der Datenbefehl kann auf eine gespeicherte Prozedur anstelle einer SQL-Anweisung verweisen. In dieser exemplarischen Vorgehensweise verwenden Sie aber SQL-Anweisungen.)

Erstellen und Konfigurieren der Verbindung

Fügen Sie zuerst eine Verbindung hinzu, die auf die Datenbank verweist, von der Sie lesen möchten.

So erstellen Sie die Datenverbindung

Ziehen Sie in der Toolbox von der Registerkarte Daten ein SqlConnection-Objekt auf die Designeroberfläche.

Hinweis Da Sie SQL Server verwenden, verwenden Sie das SqlConnection-Objekt, das für SQL Server 7.0 oder höher optimiert ist. Bei einer anderen Datenbank verwenden Sie OleDbConnection, das Ihnen ADO.NET-Zugriff auf OLE DB-kompatible Datenquellen ermöglicht.
Wählen Sie die Verbindung aus, und klicken Sie im Eigenschaftenfenster auf die Schaltfläche im Eigenschaftenfeld ConnectionString.

Die Liste zeigt alle vorhandenen Verbindungen sowie die Option <Neue Verbindung...> an.
Wenn noch keine Verbindung zur SQL Server-Datenbank Northwind besteht, wählen Sie <Neue Verbindung...> aus.

Das Dialogfeld Datenverknüpfungseigenschaften wird angezeigt.
Erstellen Sie eine Verbindung, die auf SQL Server und die Datenbank Northwind verweist, und klicken Sie dann auf OK.

Hinweis Sie müssen über die erforderlichen Lese-/Schreibberechtigungen für den verwendeten SQL Server verfügen. Es wird empfohlen, dass Sie beim Erstellen von Verbindungen die integrierte Sicherheit von Windows angeben. Sie können stattdessen auch einen Benutzernamen und ein Kennwort angeben und diese Informationen mit der Verbindung speichern. Allerdings kann dieses Verfahren die Sicherheit beeinträchtigen. Weitere Informationen finden Sie unter Zugreifen auf SQL Server von einer Webanwendung aus.

Die angegebenen Verbindungsinformationen werden als Verbindungszeichenfolge für die Verbindung gespeichert.

Nun müssen Sie Befehle hinzufügen. Insgesamt sind drei Befehle erforderlich, jeder für eine andere Abfrage:

Ein Befehl zum Abrufen der ID-Werte der Kategorien.
Ein Befehl zum Abrufen der ausgewählten Kategorie anhand einer von Ihnen angegebenen ID.
Ein Befehl zum Aktualisieren einer Kategorie mit neuen Werten.

So erstellen Sie den Datenbefehl zum Abrufen aller Kategorie-IDs

Ziehen Sie in der Toolbox von der Registerkarte Daten ein SqlCommand-Objekt auf die Designeroberfläche.
Benennen Sie den Befehl in cmdCategoriesAll um.
Wählen Sie den Befehl aus, klicken Sie im Eigenschaftenfenster auf die Schaltfläche in der Connections-Eigenschaft, und wählen Sie die zuvor erstellte Verbindung. (Sie müssen den Existing-Knoten öffnen.)
Klicken Sie in der CommandText-Eigenschaft auf die Schaltfläche mit den Auslassungspunkten, um das Dialogfeld Abfrage-Generator zu öffnen.
Erstellen Sie im Dialogfeld Abfrage-Generator die folgende SQL-Anweisung:
```
SELECT CategoryID, CategoryName, Description FROM Categories
```
Schließen Sie das Dialogfeld Abfrage-Generator, wenn Sie fertig sind.

Die SQL-Anweisung wird in die CommandText-Eigenschaft eingefügt.

Die weiteren Befehle sind etwas komplizierter, da sie Parameter benötigen.

So erstellen Sie den Datenbefehl zum Abrufen eines einzelnen Kategorie-Datensatzes

Ziehen Sie ein zweites SqlCommand-Objekt auf die Designeroberfläche, und legen Sie dessen Connection-Eigenschaft auf SqlConnection1 fest.
Geben Sie dem Befehl den Namen cmdCategoriesById.
Klicken Sie in der CommandText-Eigenschaft auf die Schaltfläche mit den Auslassungspunkten, um das Dialogfeld Abfrage-Generator zu öffnen.
Erstellen Sie im Dialogfeld Abfrage-Generator die folgende SQL-Anweisung:
```
SELECT CategoryID, CategoryName, Description 
FROM Categories 
WHERE (CategoryID = @categoryid)
```
Hinweis Die @categoryid-Variable ist eine so genannte benannte Variable. Der genaue Name der in der WHERE-Klausel verwendeten Variablen ist ohne Bedeutung. Sie benötigen den Namen aber später in dieser exemplarischen Vorgehensweise. Das Präfix "@" ist für benannte Parameter von SQL Server erforderlich.

Der letzte Befehl enthält eine Update-Anweisung, um die Änderungen an die Datenbank zu senden.

So erstellen Sie den Datenbefehl zum Aktualisieren eines Kategorie-Datensatzes

Ziehen Sie ein drittes SqlCommand-Objekt auf die Designeroberfläche, und legen Sie dessen Connection-Eigenschaft auf SqlConnection1 fest.
Geben Sie dem Befehl den Namen cmdCategoriesUpdate.

Legen Sie für die CommandText-Eigenschaft des Befehls die folgende Anweisung fest:

UPDATE Categories 
SET CategoryName = @categoryname, Description = @categorydescription WHERE (CategoryID = @categoryid)

Das Hinzufügen von Datenkomponenten zu der Seite ist beendet.

Hinzufügen von Steuerelementen

Auf der Seite benötigen Sie eine Dropdownliste, in der die Benutzer eine Kategorie-ID auswählen können, Textfelder zum Anzeigen und Bearbeiten von Daten und eine Schaltfläche zum Speichern von Änderungen.

So fügen Sie dem Formular Steuerelemente hinzu

Fügen Sie von der Registerkarte Web Forms der Toolbox dem Formular die folgenden Steuerelemente hinzu, und legen Sie die angegebenen Eigenschaften wie folgt fest:

Steuerelement	Zweck	Eigenschaften
DropDownList	Ermöglicht den Benutzern die Auswahl einer Kategorie-Liste, die zur Laufzeit bereitgestellt wird.	ID: ddlCategoryID AutoPostBack: true
TextBox	Ermöglicht den Benutzern das Bearbeiten des Kategorie-Namens.	ID: txtCategoryName
TextBox	Ermöglicht den Benutzern das Bearbeiten der Kategorie-Beschreibung.	ID: txtCategoryDescription
Button	Aktualisiert die Datenbank mit Änderungen.	ID: btnSave Text: Speichern

Fügen Sie vor den Steuerelementen Bezeichnungen für die jeweilige Funktion ein.

**Tipp **Im Rasterlayoutmodus können Sie literalen Text mit dem Flow Layout Panel (Div-Steuerelemente (HTML)) auf der Registerkarte HTML in der Toolbox hinzufügen.

Hinzufügen von Code zum Anzeigen und Aktualisieren der Daten

Zum Fertigstellen der Seite müssen Sie Code hinzufügen, der die folgenden drei Aufgaben ausführt:

Wenn die Seite initialisiert ist, muss die Dropdownliste mit den Kategorie-IDs gefüllt werden. Da die erste Kategorie-ID automatisch ausgewählt wird, können Sie auch den Namen und die Beschreibung der ersten Kategorie in den Textfeldern anzeigen.
Wenn die Benutzer in der Dropdownliste eine Kategorie-ID auswählen, muss die betreffende ID ermittelt werden. Mit diesem Wert wird dann die SQL-Anweisung zum Abrufen eines einzelnen Datensatzes ausgeführt.
Wenn die Benutzer auf die Schaltfläche Speichern klicken, müssen die vorliegenden Änderungen abgerufen und eine UPDATE-Anweisung mit den neuen Werten ausgeführt werden.

Auffüllen der Dropdownliste bei der Seiteninitialisierung

Zum Auffüllen der Dropdownliste führen Sie eine Abfrage durch, die alle Datensätze in der Tabelle Categories zurückgibt. Dies ist nur erforderlich, wenn die Seite das erste Mal ausgeführt wird. Später sind die Werte der Liste im Anzeigestatus des Steuerelements gespeichert.

Nach dem Ausführen der Abfrage rufen Sie die Datensätze mit einem Datenleser (SqlDataReader-Objekt) ab. Der Datenleser wurde extra als schreibgeschützter Leser in Vorwärtsrichtung entworfen und ist daher für einen extrem schnellen Datenzugriff optimiert.

So fügen Sie Code zum Auffüllen der Dropdownliste hinzu

Doppelklicken Sie auf die Web Forms-Seite, um den Code-Editor zu öffnen, und suchen Sie den Page_Load-Ereignishandler.
Erstellen Sie Code zum Ausführen der folgenden Funktionen:
1. Überprüfen Sie die IsPostBack-Eigenschaft, um zu bestimmen, ob die Seite zum ersten Mal ausgeführt wird. Wenn dies der Fall ist, führen Sie die übrigen Schritte aus.
2. Erstellen Sie eine Instanzenvariable vom Typ SqlDataReader.
3. Öffnen Sie die Verbindung.
4. Rufen Sie die ExecuteReader-Methode des cmdCategoriesAll-Objekts auf, um die SQL-Anweisung im Datenbefehl auszuführen und das Resultset an das Datenleserobjekt zurückzugeben.
5. Stellen Sie eine Möglichkeit bereit, z. B. durch ein boolesches Flag, um festzustellen, wann der erste Datensatz abgerufen wird, da nur die Informationen dieses Datensatzes angezeigt werden sollen.
6. Rufen Sie die folgenden Datensätze mit Hilfe des Datenlesers in einer Schleife ab.
7. Erstellen Sie in der Dropdownliste ein neues Element pro Datensatz, und ordnen Sie dem Element die Kategorie-ID zu.
8. Rufen Sie den Kategorienamen und die Kategoriebeschreibung des ersten Datensatzes ab, und legen Sie die Text-Eigenschaft der Textfelder entsprechend fest.
9. Schließen Sie den Datenleser.
10. Beenden Sie die Verbindung. Dies ist ein wichtiger Schritt. Die Verbindung bleibt geöffnet, während Daten von der Datenbank abgerufen werden. Wenn Sie die Verbindung nicht länger benötigen, müssen Sie diese daher schließen, um die verwendeten Ressourcen freizugeben.
Im folgenden Beispiel wird die gesamte Page_Load-Methode mit dem zum Ausführen der oben genannten Schritte erforderlichen Code angezeigt:
```
// Visual J#
private void Page_Load(Object sender, System.EventArgs e)
{
   // Put user code to initialize the page here
   if (!this.get_IsPostBack())
   {
      // Executes only the first time the page is processed. After
      // that, the list is already in the drop-down list and is
      // preserved in view state.
      System.Data.SqlClient.SqlDataReader dreader;
      sqlConnection1.Open();
      dreader = cmdCategoriesAll.ExecuteReader();
      boolean firstrow = true;
      while (dreader.Read())
      {
         ddlCategoryID.get_Items().Add(new ListItem(dreader.get_Item(0).ToString()));
         if (firstrow)
         {
            txtCategoryName.set_Text(dreader.get_Item(1).ToString());
            txtCategoryDescription.set_Text ( dreader.get_Item(2).ToString());
            firstrow = false;
         }
      }
      dreader.Close();
      sqlConnection1.Close();
   }
}
```

Anzeigen eines Datensatzes nach dem Auswählen einer Kategorie-ID durch den Benutzer

In der Dropdownliste werden Kategorie-IDs angezeigt. Wenn der Benutzer eine Kategorie-ID auswählt und somit das SelectedIndexChanged-Ereignis des Steuerelements ausgelöst wird, soll der entsprechende Datensatz angezeigt werden.

Beim Erstellen der Dropdownliste haben Sie deren AutoPostBack-Eigenschaft auf true festgelegt. Deshalb wird die Seite an den Server gesendet, sobald der Benutzer eine Auswahl trifft.

Zum Abrufen eines Kategoriedatensatzes führen Sie eine SQL-Anweisung aus, die mit einer WHERE-Klausel ausschließlich nach der Kategorie sucht, deren ID der Benutzer ausgewählt hat. Um diesen Wert an die Anweisung zu übergeben, legen Sie den Wert eines Parameters (ein SqlParameter-Objekt) fest, der zum Datenbefehl gehört.

So fügen Sie Code zum Auffüllen der Dropdownliste hinzu

Doppelklicken Sie auf die Dropdownliste, um den Code-Editor zu öffnen, und erstellen Sie den SelectedIndexChanged-Ereignishandler.
Erstellen Sie Code zum Ausführen der folgenden Funktionen:
1. Rufen Sie in der Dropdownliste den Text der Benutzerauswahl ab.
2. Legen Sie den Parameter (@categoryid) des cmdCategoriesById-Befehls auf die ausgewählte ID fest.
3. Öffnen Sie die Verbindung.
4. Erstellen Sie eine Datenleser-Instanzenvariable, und rufen Sie die ExecuteReader-Methode des cmdCategoriesById-Objekts auf, um den Befehl auszuführen. In diesem Fall übergeben Sie ein Flag an die Methode, das angibt, dass nur ein einzelner Datensatz zurückgegeben werden soll.
5. Rufen Sie den zurückgegebenen Datensatz mit dem Datenleser ab, und zeigen Sie dessen Werte in den Textfeldern an.
6. Schließen Sie den Datenleser.
7. Beenden Sie die Verbindung.
Im folgenden Beispiel wird die gesamte SelectedIndexChanged-Methode mit dem zum Ausführen der oben genannten Schritte erforderlichen Code angezeigt:
```
// Visual J#
private void ddlCategoryID_SelectedIndexChanged (Object sender, System.EventArgs e)
{
   String categoryid;
   categoryid = ddlCategoryID.get_SelectedItem().get_Text();
   ((System.Data.SqlClient.SqlParameterCollection)cmdCategoriesById.get_Parameters()).
      get_Item("@categoryid").set_Value(categoryid);
   sqlConnection1.Open();
   System.Data.SqlClient.SqlDataReader dreader;
   dreader = cmdCategoriesById.ExecuteReader(CommandBehavior.SingleRow);
   if (dreader.Read())
   {
      txtCategoryName.set_Text(dreader.get_Item(1).ToString());
      txtCategoryDescription.set_Text(dreader.get_Item(2).ToString());
   }
   dreader.Close();
   sqlConnection1.Close();
}
```

Aktualisieren eines Datensatzes

Schließlich möchten Sie noch Code hinzufügen, der die Datenbank mit den Änderungen am in der Seite angezeigten Datensatz aktualisiert. Wie beim Abrufen eines einzelnen Datensatzes müssen Sie beim Aktualisieren zunächst einige Parameter festlegen und dann eine Anweisung ausführen (in diesem Fall eine UPDATE-Anweisung). Da die UPDATE-Anweisung jedoch keine Datensätze zurückgibt, ist der Code zum Ausführen der Anweisung relativ einfach.

So aktualisieren Sie Datensätze

Doppelklicken Sie auf die Schaltfläche Speichern, um einen Click-Handler zu erstellen.

Erstellen Sie Code zum Ausführen der folgenden Funktionen:

Legen Sie (insgesamt drei) Parameter für die Werte der Steuerelemente auf der Seite fest.
Öffnen Sie die Verbindung.
Rufen Sie die ExecuteNonQuery-Methode des cmdCategoriesUpdate-Befehls auf.
Beenden Sie die Verbindung.

Im folgenden Beispiel wird die gesamte Click-Methode mit dem zum Ausführen der oben genannten Schritte erforderlichen Code angezeigt:

// Visual J#
private void btnSave_Click (Object sender, System.EventArgs e)
{
   ((System.Data.SqlClient.SqlParameterCollection) cmdCategoriesUpdate.get_Parameters()).
      get_Item("@categoryid").set_Value(ddlCategoryID.
      get_SelectedItem().get_Text());
   ((System.Data.SqlClient.SqlParameterCollection)cmdCategoriesUpdate.get_Parameters()).
      get_Item("@categoryname").set_Value(txtCategoryName.get_Text());
   ((System.Data.SqlClient.SqlParameterCollection)cmdCategoriesUpdate.get_Parameters()).
      get_Item("@categorydescription").set_Value(txtCategoryDescription.get_Text());
   sqlConnection1.Open();
   cmdCategoriesUpdate.ExecuteNonQuery();
   sqlConnection1.Close();
}

Testen

Sie können jetzt das Formular testen, um sicherzustellen, dass Kategoriedaten angezeigt werden und Benutzer Aktualisierungen vornehmen können.

So testen Sie die Seite

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Seite, und wählen Sie In Browser anzeigen.
Wenn die Seite angezeigt wird, vergewissern Sie sich, dass die Dropdownliste eine Liste von Kategorie-IDs enthält und die erste Kategorie in den Textfeldern angezeigt wird.
Wählen Sie in der Liste eine andere Kategorie aus.

Der neue Datensatz wird angezeigt.

Hinweis Wenn beim Auswählen einer neuen Kategorie-ID in der Dropdownliste kein anderer Datensatz angezeigt wird, müssen Sie überprüfen, ob die AutoPostBack-Eigenschaft des Steuerelements auf true festgelegt ist.
Nehmen Sie eine Änderung in einem der Textfelder vor, und klicken Sie dann auf die Schaltfläche Speichern.
Wechseln Sie zu einem anderen Kategoriedatensatz und anschließend wieder zu dem geänderten Datensatz.

Die Änderungen werden angezeigt, wenn der Datensatz erneut angezeigt wird.

Nächste Schritte

In dieser exemplarischen Vorgehensweise wurden die grundlegenden Schritte veranschaulicht, um Datensätze mit einem Datenleser direkt aus der Datenbank abzurufen und Aktualisierungen mit einem Datenbefehl durchzuführen. Sie können einige der folgenden Vorschläge ausprobieren, um die von Ihnen erstellte Web Forms-Seite zu optimieren:

Bieten Sie den Benutzern eine weitere Möglichkeit, um Kategorien auszuwählen. Die Dropdownliste in dieser exemplarischen Vorgehensweise zeigt die Kategorie-IDs an. Diese sind i. d. R. für Benutzer nicht sehr hilfreich. Doch haben die Benutzer hier die Möglichkeit, bei Bedarf die Namen von Kategorien zu bearbeiten, und es wird deutlich, wie die Daten aus der Datenbank in die Steuerelemente gelangen und umgekehrt.

Eine vergleichsweise einfache Änderung besteht darin, die Kategorienamen als Text in der Dropdownliste (die sichtbaren Informationen in der Liste) und die Kategorie-IDs als Listenwerte anzuzeigen. (Dabei können die Benutzer die Namen jedoch nicht bearbeiten.) Anschließend kann der Wert als Parameterwert anstelle des Textes übergeben werden.
Fügen Sie eine Fehlersuche hinzu. Normalerweise soll Codestabilität dadurch erreicht werden, dass alle Anweisungen für Datenzugriffe in try-catch-Blöcke eingeschlossen werden. Der Datenzugriff kann durch eine Vielzahl möglicher Probleme beeinträchtigt werden, viele davon unabhängig von Ihrer Anwendung, z. B. Netzwerkprobleme. Weitere Informationen erhalten Sie unter Bewährte Verfahrensweisen zum Auslösen von Ausnahmen aus Komponenten.
Fügen Sie eine Parallelitätssteuerung hinzu. In dieser exemplarischen Vorgehensweise aktualisieren Sie einen Datensatz einfach in der Datenbank, ohne zuvor zu ermitteln, ob ein anderer Benutzer auch Änderungen vorgenommen hat. Weitere Informationen finden Sie unter Parallelitätssteuerung in ADO.NET.

Siehe auch

Exemplarische Vorgehensweise: Erstellen von schreibgeschütztem Datenzugriff in einer Web Forms-Seite mit Hilfe von Visual J# | Einführung in die Entwurfstools für ADO.NET-Verbindungen | Einführung in DataCommand-Objekte in Visual Studio | Ausführen von Datenbefehlen, die Resultsets zurückgeben | Ausführen von Aktualisierungen oder Datenbankbefehlen mit Hilfe von Datenbefehlen | Festlegen und Abrufen von Datenbefehlsparametern | Parallelitätssteuerung in ADO.NET | Exemplarische Vorgehensweisen für Web Forms

Freigeben über