Erstellen einer einfachen Datenanwendung mit ADO.NET

Wenn Sie eine Anwendung erstellen, die Daten in einer Datenbank bearbeitet, führen Sie grundlegende Aufgaben aus wie Definieren von Verbindungszeichenfolgen, Einfügen von Daten und Ausführen gespeicherter Prozeduren. In diesem Thema erfahren Sie, wie Sie aus einer einfachen daten- und formularbasierten Windows Forms-Anwendung mit einer Datenbank interagieren, indem Sie Visual C# oder Visual Basic und ADO.NET verwenden. Alle .NET-Datentechnologien, einschließlich Datasets, LINQ to SQL und Entity Framework, führen letztendlich Schritte aus, die denen in diesem Artikel sehr ähnlich sind.

In diesem Artikel wird eine einfache Möglichkeit zum schnellen Abrufen von Daten aus einer Datenbank veranschaulicht. Wenn Ihre Anwendung Daten auf nicht triviale Weise ändern und die Datenbank aktualisieren muss, sollten Sie die Verwendung von Entity Framework und die Verwendung der Datenbindung in Betracht ziehen, um Benutzeroberflächensteuerelemente automatisch mit Änderungen der zugrunde liegenden Daten zu synchronisieren.

Voraussetzungen

Zum Erstellen der Anwendung benötigen Sie:

• Visual Studio mit installierter .NET-Desktopentwicklung und Datenspeicher- und -verarbeitungs-Workloads. Um diese zu installieren, öffnen Sie Visual Studio-Installer und wählen Ändern (oder Weitere>Ändern) neben der Version von Visual Studio aus, die Sie ändern möchten.

• SQL Server Express LocalDB. Wenn Sie nicht über SQL Server Express LocalDB verfügen, können Sie es über die SQL Server-Downloadseite installieren.

In diesem Thema wird davon ausgegangen, dass Sie mit der grundlegenden Funktionalität der Visual Studio IDE vertraut sind und eine Windows Forms-Anwendung erstellen, dem Projekt Formulare hinzufügen, Schaltflächen und andere Steuerelemente in den Formularen einfügen, Eigenschaften für die Steuerelemente einrichten und einfache Ereignisse programmieren können. Wenn Sie mit diesen Aufgaben nicht vertraut sind, empfehlen wir Ihnen, das Tutorial Erstellen einer Windows Forms-App in Visual Studio mit Visual Basic Lernprogramm oder das Tutorial Erstellen einer Windows Forms-App in Visual Studio mit C# abzuschließen, bevor Sie mit dieser exemplarischen Vorgehensweise beginnen.

Die Beispieldatenbank einrichten

Erstellen Sie die Beispieldatenbank, indem Sie die folgenden Schritte durchführen:

1. Öffnen Sie in Visual Studio das Server-Explorer-Fenster.

2. Klicken Sie mit der rechten Maustaste auf Datenverbindungen, und wählen Sie Neue SQL Server-Datenbank erstellen aus.

3. Geben Sie im Textfeld Servername entsprechend (localdb)\mssqllocaldb ein.

4. Geben Sie im Textfeld Neuer Datenbankname entsprechend Umsatz (Sales) ein, und wählen Sie dann OK aus.

   Die leere Umsatz-Datenbank wird erstellt und zum Knoten „Datenverbindungen“ in Server-Explorer hinzugefügt.

5. Klicken Sie mit der rechten Maustaste auf die Datenverbindung Umsatz, und wählen Sie Neue Abfrage aus.

   Ein Abfrage-Editor-Fenster wird geöffnet.

6. Kopieren Sie das Transact-SQL-Skript für den Umsatz in die Zwischenablage.

7. Fügen Sie das T-SQL-Skript in den Abfrage-Editor ein, und wählen Sie dann die Schaltfläche Ausführen aus.

   Nach kurzer Zeit wird die Abfrage abgeschlossen und die Datenbankobjekte werden erstellt. Die Datenbank enthält zwei Tabellen: „Kunden“ (Customer) und „Bestellungen“ (Orders). Diese Tabellen enthalten anfangs keine Daten, aber Sie können Daten hinzufügen, wenn Sie die von Ihnen erstellte Anwendung ausführen. Die Datenbank enthält auch vier einfache gespeicherte Prozeduren.

Die Formulare erstellen und Steuerelemente hinzufügen

1. Erstellen Sie ein C#- oder Visual Basic-Projekt mit der Vorlage Windows Forms-App (.NET Framework), und nennen Sie es SimpleDataApp.

   Visual Studio erstellt das Projekt und mehrere Dateien, einschließlich eines leeren Windows-Formulars namens Form1.

2. Fügen Sie dem Projekt zwei Windows-Formulare hinzu, sodass es drei Formulare enthält, und geben Sie ihnen die folgenden Namen:

   • Navigation

   • NewCustomer

   • FillOrCancel

3. Fügen Sie für jedes Formular die Textfelder, Schaltflächen und anderen Steuerelementen hinzu, die in der folgenden Abbildung dargestellt werden. Legen Sie für jedes Steuerelement die Eigenschaften fest, die in den Tabellen beschrieben werden.

   Hinweis

   Das Gruppenfeld und die Bezeichnungsfelder sorgen für Klarheit, werden im Code jedoch nicht verwendet.

   Navigationsformular

   

NewCustomer-Formular

FillOrCancel-Formular

Die Verbindungszeichenfolge speichern

Wenn die Anwendung versucht, eine Verbindung zur Datenbank zu öffnen, muss die Anwendung Zugriff auf die Verbindungszeichenfolge haben. Um zu vermeiden, dass die Zeichenfolge auf jedem Formular manuell eingegeben werden muss, speichern Sie die Zeichenfolge in der Datei App.config im Projekt, und erstellen Sie eine Methode, die die Zeichenfolge zurückgibt, wenn die Methode über ein beliebiges Formular in der Anwendung aufgerufen wird.

Sie finden die Verbindungszeichenfolge, indem Sie mit der rechten Maustaste auf die Datenverbindung Umsatz im Server-Explorer klicken und Eigenschaften auswählen. Suchen Sie die ConnectionString-Eigenschaft, und verwenden Sie dann STRG+A, STRG+C, um die Zeichenfolge auszuwählen und in die Zwischenablage zu kopieren.

1. Wenn Sie C# verwenden, erweitern Sie im Projektmappen-Explorer den Knoten Eigenschaften unter dem Projekt, und öffnen Sie dann die Datei Settings.settings. Wenn Sie Visual Basic verwenden, klicken Sie im Projektmappen-Explorer auf Alle Dateien anzeigen, erweitern Sie den Knoten Mein Projekt, und öffnen Sie dann die Datei Settings.settings.

2. Geben Sie in der Spalte Name entsprechend connString ein.

3. Wählen Sie in der Liste Typ(Verbindungszeichenfolge) aus.

4. Wählen Sie in der Liste Bereich die Option Anwendung aus.

5. Geben Sie in der Spalte Wert die Verbindungszeichenfolge (ohne Anführungszeichen) ein, und speichern Sie die Änderungen.

   

Den Code für die Formulare schreiben

Dieser Abschnitt enthält kurze Übersichten über die Funktionen der einzelnen Formulare. Außerdem wird der Code bereitgestellt, der die zugrunde liegende Logik definiert, wenn auf eine Schaltfläche im Formular geklickt wird.

Navigationsformular

Das Navigationsformular wird geöffnet, wenn Sie die Anwendung ausführen. Die Schaltfläche Konto hinzufügen öffnet das NewCustomer-Formular. Die Schaltfläche Auftrag ausfüllen oder abbrechen öffnet das FillOrCancel-Formular. Die Schaltfläche Beenden schließt die Anwendung.

Das Navigationsformular als Startformular festlegen

Wenn Sie C# verwenden, öffnen Sie Program.cs im Projektmappen-Explorer und ändern die Zeile Application.Run in Application.Run(new Navigation());.

Wenn Sie Visual Basic verwenden, öffnen Sie im Projektmappen-Explorer das Fenster Eigenschaften, wählen Sie die Registerkarte Anwendung aus, und wählen Sie dann SimpleDataApp.Navigation in der Liste Startformular aus.

Erstellen automatisch generierter Ereignishandler

Doppelklicken Sie auf die drei Schaltflächen im Navigationsformular, um leere Ereignishandlermethoden zu erstellen. Durch Doppelklicken auf die Schaltflächen wird auch automatisch generierter Code in der Designer-Codedatei hinzugefügt, mit dem das Anklicken einer Schaltfläche zum Auslösen eines Ereignisses ermöglicht wird.

Hinzufügen von Code für die Navigationsformularlogik

Füllen Sie auf der Codeseite für das Navigationsformular die Methodentexte für die drei Click-Ereignishandler der Schaltfläche aus, wie im folgenden Code gezeigt.

/// <summary>
/// Opens the NewCustomer form as a dialog box,
/// which returns focus to the calling form when it is closed. 
/// </summary>
private void btnGoToAdd_Click(object sender, EventArgs e)
{
    Form frm = new NewCustomer();
    frm.Show();
}

/// <summary>
/// Opens the FillorCancel form as a dialog box. 
/// </summary>
private void btnGoToFillOrCancel_Click(object sender, EventArgs e)
{
    Form frm = new FillOrCancel();
    frm.ShowDialog();
}

/// <summary>
/// Closes the application (not just the Navigation form).
/// </summary>
private void btnExit_Click(object sender, EventArgs e)
{
    this.Close();
}

''' <summary>
''' Opens the NewCustomer form as a dialog box, which returns focus to the calling form when it closes.
''' </summary>  
Private Sub btnGoToAdd_Click(sender As Object, e As EventArgs) Handles btnGoToAdd.Click
    Dim frm As Form = New NewCustomer()
    frm.Show()
End Sub

''' <summary>
''' Opens the FillOrCancel form as a dialog box.
''' </summary>
Private Sub btnGoToFillOrCancel_Click(sender As Object, e As EventArgs) Handles btnGoToFillOrCancel.Click
    Dim frm As Form = New FillOrCancel()
    frm.ShowDialog()
End Sub

''' <summary>
''' Closes the application (not just the navigation form).
''' </summary>
Private Sub btnExit_Click(sender As Object, e As EventArgs) Handles btnExit.Click
    Me.Close()
End Sub

NewCustomer-Formular

Wenn Sie einen Kundennamen eingeben und dann auf die Schaltfläche Konto erstellen klicken, erstellt das NewCustomer-Formular ein Kundenkonto, und SQL Server gibt einen IDENTITY-Wert als neue Kunden-ID zurück. Sie können dann eine Bestellung für das neue Konto aufgeben, indem Sie eine Menge und ein Bestelldatum angeben und auf die Schaltfläche Bestellung aufgeben klicken.

Erstellen automatisch generierter Ereignishandler

Erstellen Sie einen leeren Click-Ereignishandler für jede Schaltfläche im NewCustomer-Formular, indem Sie auf jede der vier Schaltflächen doppelklicken. Durch Doppelklicken auf die Schaltflächen wird auch automatisch generierter Code in der Designer-Codedatei hinzugefügt, mit dem das Anklicken einer Schaltfläche zum Auslösen eines Ereignisses ermöglicht wird.

Hinzufügen von Code für die NewCustomer-Formularlogik

Führen Sie die folgenden Schritte aus, um die NewCustomer-Formularlogik abzuschließen.

1. Versetzen Sie den System.Data.SqlClient-Namespace in den Bereich, sodass Sie die Namen seiner Member nicht vollständig qualifizieren müssen.

   • C#
   • VB

   using System.Data.SqlClient;
   

2. Fügen Sie der Klasse einige Variablen und Hilfsmethoden hinzu, wie im folgenden Code gezeigt.

   • C#
   • VB

   // Storage for IDENTITY values returned from database.
   private int parsedCustomerID;
   private int orderID;
   
   /// <summary>
   /// Verifies that the customer name text box is not empty.
   /// </summary>
   private bool IsCustomerNameValid()
   {
       if (txtCustomerName.Text == "")
       {
           MessageBox.Show("Please enter a name.");
           return false;
       }
       else
       {
           return true;
       }
   }
   
   /// <summary>
   /// Verifies that a customer ID and order amount have been provided.
   /// </summary>
   private bool IsOrderDataValid()
   {
       // Verify that CustomerID is present.
       if (txtCustomerID.Text == "")
       {
           MessageBox.Show("Please create customer account before placing order.");
           return false;
       }
       // Verify that Amount isn't 0.
       else if ((numOrderAmount.Value < 1))
       {
           MessageBox.Show("Please specify an order amount.");
           return false;
       }
       else
       {
           // Order can be submitted.
           return true;
       }
   }
   
   /// <summary>
   /// Clears the form data.
   /// </summary>
   private void ClearForm()
   {
       txtCustomerName.Clear();
       txtCustomerID.Clear();
       dtpOrderDate.Value = DateTime.Now;
       numOrderAmount.Value = 0;
       this.parsedCustomerID = 0;
   }
   

3. Schließen Sie die Methodentexte für die vier Click-Ereignishandler der Schaltfläche ab, wie im folgenden Code dargestellt.

   • C#
   • VB

   /// <summary>
   /// Creates a new customer by calling the Sales.uspNewCustomer stored procedure.
   /// </summary>
   private void btnCreateAccount_Click(object sender, EventArgs e)
   {
       if (IsCustomerNameValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create a SqlCommand, and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspNewCustomer", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add input parameter for the stored procedure and specify what to use as its value.
                   sqlCommand.Parameters.Add(new SqlParameter("@CustomerName", SqlDbType.NVarChar, 40));
                   sqlCommand.Parameters["@CustomerName"].Value = txtCustomerName.Text;
   
                   // Add the output parameter.
                   sqlCommand.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
                   sqlCommand.Parameters["@CustomerID"].Direction = ParameterDirection.Output;
   
                   try
                   {
                       connection.Open();
   
                       // Run the stored procedure.
                       sqlCommand.ExecuteNonQuery();
   
                       // Customer ID is an IDENTITY value from the database.
                       this.parsedCustomerID = (int)sqlCommand.Parameters["@CustomerID"].Value;
   
                       // Put the Customer ID value into the read-only text box.
                       this.txtCustomerID.Text = Convert.ToString(parsedCustomerID);
                   }
                   catch
                   {
                       MessageBox.Show("Customer ID was not returned. Account could not be created.");
                   }
                   finally
                   {
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Calls the Sales.uspPlaceNewOrder stored procedure to place an order.
   /// </summary>
   private void btnPlaceOrder_Click(object sender, EventArgs e)
   {
       // Ensure the required input is present.
       if (IsOrderDataValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create SqlCommand and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspPlaceNewOrder", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add the @CustomerID input parameter, which was obtained from uspNewCustomer.
                   sqlCommand.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
                   sqlCommand.Parameters["@CustomerID"].Value = this.parsedCustomerID;
   
                   // Add the @OrderDate input parameter.
                   sqlCommand.Parameters.Add(new SqlParameter("@OrderDate", SqlDbType.DateTime, 8));
                   sqlCommand.Parameters["@OrderDate"].Value = dtpOrderDate.Value;
   
                   // Add the @Amount order amount input parameter.
                   sqlCommand.Parameters.Add(new SqlParameter("@Amount", SqlDbType.Int));
                   sqlCommand.Parameters["@Amount"].Value = numOrderAmount.Value;
   
                   // Add the @Status order status input parameter.
                   // For a new order, the status is always O (open).
                   sqlCommand.Parameters.Add(new SqlParameter("@Status", SqlDbType.Char, 1));
                   sqlCommand.Parameters["@Status"].Value = "O";
   
                   // Add the return value for the stored procedure, which is  the order ID.
                   sqlCommand.Parameters.Add(new SqlParameter("@RC", SqlDbType.Int));
                   sqlCommand.Parameters["@RC"].Direction = ParameterDirection.ReturnValue;
   
                   try
                   {
                       //Open connection.
                       connection.Open();
   
                       // Run the stored procedure.
                       sqlCommand.ExecuteNonQuery();
   
                       // Display the order number.
                       this.orderID = (int)sqlCommand.Parameters["@RC"].Value;
                       MessageBox.Show("Order number " + this.orderID + " has been submitted.");
                   }
                   catch
                   {
                       MessageBox.Show("Order could not be placed.");
                   }
                   finally
                   {
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Clears the form data so another new account can be created.
   /// </summary>
   private void btnAddAnotherAccount_Click(object sender, EventArgs e)
   {
       this.ClearForm();
   }
   
   /// <summary>
   /// Closes the form/dialog box.
   /// </summary>
   private void btnAddFinish_Click(object sender, EventArgs e)
   {
       this.Close();
   }
   

FillOrCancel-Formular

Das Formular „FillOrCancel“ führt eine Abfrage aus, um eine Bestellung zurückzugeben, wenn Sie eine Bestell-ID eingeben. Wählen Sie anschließend die Schaltfläche Bestellung suchen aus. Die zurückgegebene Zeile wird in einem schreibgeschützten Datenraster angezeigt. Sie können die Bestellung als abgebrochen markieren (X), wenn Sie auf die Schaltfläche Bestellung abbrechen klicken, oder Sie können die Bestellung als ausgefüllt markieren (F), wenn Sie auf die Schaltfläche Bestellung ausfüllen klicken. Wenn Sie noch einmal die Schaltfläche Bestellung suchen auswählen, wird die aktualisierte Zeile angezeigt.

Erstellen automatisch generierter Ereignishandler

Erstellen Sie leere Click-Ereignishandler für die vier Schaltflächen im FillOrCancel-Formular, indem Sie auf die Schaltflächen doppelklicken. Durch Doppelklicken auf die Schaltflächen wird auch automatisch generierter Code in der Designer-Codedatei hinzugefügt, mit dem das Anklicken einer Schaltfläche zum Auslösen eines Ereignisses ermöglicht wird.

Hinzufügen von Code für die FillOrCancel-Formularlogik

Führen Sie die folgenden Schritte aus, um die FillOrCancel-Formularlogik abzuschließen.

1. Versetzen Sie die folgenden beiden Namespaces in den Bereich, damit Sie die Namen ihrer Member nicht vollständig qualifizieren müssen.

   • C#
   • VB

   using System.Data.SqlClient;
   using System.Text.RegularExpressions;
   

2. Fügen Sie der Klasse eine Variable und Hilfsmethode hinzu, wie im folgenden Code gezeigt.

   • C#
   • VB

   // Storage for the order ID value.
   private int parsedOrderID;
   
   /// <summary>
   /// Verifies that an order ID is present and contains valid characters.
   /// </summary>
   private bool IsOrderIDValid()
   {
       // Check for input in the Order ID text box.
       if (txtOrderID.Text == "")
       {
           MessageBox.Show("Please specify the Order ID.");
           return false;
       }
   
       // Check for characters other than integers.
       else if (Regex.IsMatch(txtOrderID.Text, @"^\D*$"))
       {
           // Show message and clear input.
           MessageBox.Show("Customer ID must contain only numbers.");
           txtOrderID.Clear();
           return false;
       }
       else
       {
           // Convert the text in the text box to an integer to send to the database.
           parsedOrderID = Int32.Parse(txtOrderID.Text);
           return true;
       }
   }
   

3. Schließen Sie die Methodentexte für die vier Click-Ereignishandler der Schaltfläche ab, wie im folgenden Code dargestellt.

   • C#
   • VB

   /// <summary>
   /// Executes a t-SQL SELECT statement to obtain order data for a specified
   /// order ID, then displays it in the DataGridView on the form.
   /// </summary>
   private void btnFindByOrderID_Click(object sender, EventArgs e)
   {
       if (IsOrderIDValid())
       {
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Define a t-SQL query string that has a parameter for orderID.
               const string sql = "SELECT * FROM Sales.Orders WHERE orderID = @orderID";
   
               // Create a SqlCommand object.
               using (SqlCommand sqlCommand = new SqlCommand(sql, connection))
               {
                   // Define the @orderID parameter and set its value.
                   sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
                   sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
   
                   try
                   {
                       connection.Open();
   
                       // Run the query by calling ExecuteReader().
                       using (SqlDataReader dataReader = sqlCommand.ExecuteReader())
                       {
                           // Create a data table to hold the retrieved data.
                           DataTable dataTable = new DataTable();
   
                           // Load the data from SqlDataReader into the data table.
                           dataTable.Load(dataReader);
   
                           // Display the data from the data table in the data grid view.
                           this.dgvCustomerOrders.DataSource = dataTable;
   
                           // Close the SqlDataReader.
                           dataReader.Close();
                       }
                   }
                   catch
                   {
                       MessageBox.Show("The requested order could not be loaded into the form.");
                   }
                   finally
                   {
                       // Close the connection.
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Cancels an order by calling the Sales.uspCancelOrder
   /// stored procedure on the database.
   /// </summary>
   private void btnCancelOrder_Click(object sender, EventArgs e)
   {
       if (IsOrderIDValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create the SqlCommand object and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspCancelOrder", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add the order ID input parameter for the stored procedure.
                   sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
                   sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
   
                   try
                   {
                       // Open the connection.
                       connection.Open();
   
                       // Run the command to execute the stored procedure.
                       sqlCommand.ExecuteNonQuery();
                   }
                   catch
                   {
                       MessageBox.Show("The cancel operation was not completed.");
                   }
                   finally
                   {
                       // Close connection.
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Fills an order by calling the Sales.uspFillOrder stored
   /// procedure on the database.
   /// </summary>
   private void btnFillOrder_Click(object sender, EventArgs e)
   {
       if (IsOrderIDValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create command and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspFillOrder", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add the order ID input parameter for the stored procedure.
                   sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
                   sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
   
                   // Add the filled date input parameter for the stored procedure.
                   sqlCommand.Parameters.Add(new SqlParameter("@FilledDate", SqlDbType.DateTime, 8));
                   sqlCommand.Parameters["@FilledDate"].Value = dtpFillDate.Value;
   
                   try
                   {
                       connection.Open();
   
                       // Execute the stored procedure.
                       sqlCommand.ExecuteNonQuery();
                   }
                   catch
                   {
                       MessageBox.Show("The fill operation was not completed.");
                   }
                   finally
                   {
                       // Close the connection.
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Closes the form.
   /// </summary>
   private void btnFinishUpdates_Click(object sender, EventArgs e)
   {
       this.Close();
   }
   

Testen Ihrer Anwendung

Führen Sie die Anwendung aus, und versuchen Sie, einige Kunden und Bestellungen zu erstellen, um sicherzustellen, dass alles wie erwartet funktioniert. Um zu überprüfen, ob die Datenbank mit Ihren Änderungen aktualisiert wird, öffnen Sie den Knoten Tabellen in Server-Explorer, klicken Sie mit der rechten Maustaste auf die Knoten für Customers und Bestellungen, und wählen Sie Tabellendaten anzeigen aus.

Zugehöriger Inhalt

• Visual Studio-Datentools für .NET