Erstellen einer einfachen Datenanwendung mithilfe von ADO.NET

Wenn Sie eine Anwendung erstellen, die Daten in einer Datenbank bearbeitet, führen Sie in der Regel Aufgaben wie das Definieren von Verbindungszeichenfolgen, das Einfügen von Daten und das Ausführen gespeicherter Prozeduren durch. Während Sie diesem Artikel folgen, erfahren Sie, wie Sie mithilfe von Visual C# oder Visual Basic und ADO.NET innerhalb einer Windows Forms-Anwendung (Forms over Data, FOD) mit einer Datenbank interagieren können. Alle .NET-Datentechnologien, einschließlich Datasets, LINQ (Language-Integrated Query) zu SQL und Entity Framework, führen letztendlich Schritte aus, die den in diesem Artikel gezeigten Schritten ähneln.

In diesem Artikel wird veranschaulicht, wie Sie Daten schnell aus einer Datenbank herausholen. Wenn Ihre Anwendung Daten auf nichttrivielle Weise ändern und die Datenbank aktualisieren muss, erwägen Sie die Verwendung von Entity Framework und datenbindung. Auf diese Weise können Benutzeroberflächensteuerelemente automatisch mit Änderungen der zugrunde liegenden Daten synchronisiert werden.

Informationen zum Zugriff auf den vollständigen Code für dieses Lernprogramm finden Sie im GitHub-Repository von Visual Studio für C# und Visual Basic.

Prerequisites

• Visual Studio mit installierter .NET-Desktopentwicklung und Datenspeicher- und -verarbeitungs-Workloads. Um sie zu installieren, öffnen Sie Visual Studio Installer, und wählen Sie "Ä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 sie über die SQL Server-Downloadseiteinstallieren.

In diesem Artikel wird davon ausgegangen, dass Sie mit den grundlegenden Funktionen der Visual Studio-IDE vertraut sind. Außerdem wird davon ausgegangen, dass Sie eine Windows Forms-Anwendung erstellen, einem Projekt Formulare hinzufügen, Schaltflächen und andere Steuerelemente zu den Formularen hinzufügen, Steuerelementeigenschaften festlegen und einfache Codeereignisse festlegen können. Wenn Sie mit diesen Aufgaben nicht vertraut sind, führen Sie das Lernprogramm zum Erstellen einer Windows Forms-App in Visual Studio mit C# oder das Lernprogramm "Erstellen einer Windows Forms-App in Visual Studio mit Visual Basic " aus, bevor Sie mit dieser exemplarischen Vorgehensweise beginnen.

Einrichten der Beispieldatenbank

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

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

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

3. Geben Sie für den Servernamen(localdb)\mssqllocaldb ein.

4. Geben Sie für Neuer DatenbanknameVertrieb ein, und wählen Sie dann OK aus.

   Visual Studio erstellt eine leere Vertriebsdatenbank unter dem Knoten "Datenverbindungen " im Server-Explorer.

5. Klicken Sie mit der rechten Maustaste auf die Verkaufsdatenverbindung , 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 das Abfrage-Editor-Fenster ein, und wählen Sie dann "Ausführen" aus.

   Nach kurzer Zeit wird die Abfrage abgeschlossen, und die Datenbankobjekte werden erstellt. Die Datenbank enthält zwei Tabellen: "Kunde" und "Bestellungen". Diese Tabellen enthalten anfänglich keine Daten, Aber Sie können Daten hinzufügen, wenn Sie die von Ihnen erstellte Anwendung ausführen. Die Datenbank enthält auch fünf grundlegende gespeicherte Prozeduren.

Erstellen der Formulare und Hinzufügen von Steuerelementen

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 ihrem Projekt im Projektmappen-Explorer zwei Windows-Formulare hinzu, sodass es insgesamt drei Formulare enthält, und weisen Sie ihnen die folgenden Namen zu:

   • Navigation

   • NewCustomer

   • FillOrCancel

3. Fügen Sie für jedes Formular die Textfelder, Schaltflächen und andere Steuerelemente hinzu, die in den folgenden Abbildungen gezeigt werden. Legen Sie für jedes Steuerelement die Eigenschaften fest, die in den Tabellen beschrieben werden.

   Note

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

   Navigationsformular

   

   Steuerelemente für das Navigationsformular

   Kontrolltext	Steuerelementtyp	Steuerelementeigenschaften
   Konto hinzufügen	Button	Name = btnGoToAdd
   Ausfüllen oder Stornieren einer Bestellung	Button	Name = btnGoToFillOrCancel
   Exit	Button	Name = btnExit

   NewCustomer-Formular

   

   Steuerelemente für das NewCustomer-Formular

   Beschriftung/Steuerungstext	Steuerelementtyp	Steuerelementeigenschaften
   Kundenname	TextBox	Name = txtCustomerName
   Kunden-ID	TextBox	Name = txtCustomerID Schreibgeschützt = Wahr
   Konto erstellen	Button	Name = btnCreateAccount
   Bestellbetrag	NumericUpdown	Name = numOrderAmount Dezimalstellen = 0 Maximum = 5000
   Bestelldatum	DateTimePicker	Name = dtpOrderDate Format = Kurz
   Bestellung aufgeben	Button	Name = btnPlaceOrder
   Finish	Button	Name = btnAddFinish
   Hinzufügen eines weiteren Kontos	Button	Name = btnAddAnotherAccount

   FillOrCancel-Formular

   

   Steuerelemente für das FillOrCancel-Formular

   Beschriftung/Steuerungstext	Steuerelementtyp	Steuerelementeigenschaften
   Auftrags-ID	TextBox	Name = txtOrderID
   Bestellung suchen	Button	Name = btnFindByOrderID
   Wenn Sie eine Bestellung ausfüllen...	DateTimePicker	Name = dtpFillDate Format = Kurz
   (None)	DataGridView	Name = dgvCustomerOrders Schreibgeschützt = Wahr RowHeadersVisible = Falsch
   Bestellung stornieren	Button	Name = btnBestellungAbbrechen
   Reihenfolge des Auffüllens	Button	Name = btnFillOrder
   Finish	Button	Name = btnFinishUpdates

Speichern der Verbindungszeichenfolge

Wenn Ihre Anwendung versucht, eine Verbindung mit der Datenbank zu öffnen, muss Ihre Anwendung Zugriff auf die Verbindungszeichenfolge haben. Um zu vermeiden, dass die Zeichenfolge manuell auf jedem Formular eingegeben werden muss, speichern Sie die Zeichenfolge in der App.config Datei in Ihrem Projekt. Erstellen Sie dann eine Methode, die die Zeichenfolge zurückgibt, wenn die Methode aus einem beliebigen Formular in Ihrer Anwendung aufgerufen wird.

So finden Sie die Verbindungszeichenfolge:

1. Klicken Sie im Server-Explorer mit der rechten Maustaste auf die Verkaufsdatenverbindung , und wählen Sie dann "Eigenschaften" aus.

2. Suchen Sie die Eigenschaft Verbindungszeichenfolge und kopieren Sie den Wert der Zeichenfolge in die Zwischenablage.

So speichern Sie die Verbindungszeichenfolge in Ihrem Projekt:

1. Führen Sie im Projektmappen-Explorer einen der folgenden Schritte aus, je nach Projekttyp:

   • Erweitern Sie für ein C#-Projekt den Knoten "Eigenschaften" unter dem Projekt, und öffnen Sie dann die Datei "Settings.settings" .

   • Wählen Sie für ein Visual Basic-Projekt " Alle Dateien anzeigen", erweitern Sie den Knoten "Mein Projekt ", und öffnen Sie dann die Datei "Settings.settings" .

2. Tragen Sie connString in der Spalte Name ein.

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

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

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

   

Schreiben des Codes für die Formulare

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

Navigationsformular

Das Navigationsformular wird geöffnet, wenn Sie die Anwendung ausführen und die folgenden Schaltflächen enthalten:

• Konto hinzufügen: Öffnet das Formular "NewCustomer ".

• Ausfüllen oder Abbrechen von Bestellungen: Öffnet das FillOrCancel-Formular .

• Exit: Schließt die Anwendung.

Erstellen des Navigationsformulars als Startformular

Für C#-Projekte:

1. Öffnen Sie Program.cs imProjektmappen-Explorer.

2. Ändern Sie die Application.Run Zeile in: Application.Run(new Navigation());

Für Visual Basic-Projekte:

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie "Eigenschaften" aus.

2. Wählen Sie im Project Designer die Registerkarte "Anwendung " und dann " Navigation " in der Startobjektliste aus.

Erstellen automatisch generierter Ereignishandler für das Navigationsformular

Um leere Ereignishandlermethoden zu erstellen, doppelklicken Sie auf jede der drei Schaltflächen im Navigationsformular. Durch Doppelklicken auf eine Schaltfläche wird automatisch generierter Code in der Designer-Codedatei hinzugefügt, wodurch eine Schaltflächenauswahl ein Ereignis auslösen kann.

Wenn Sie code direkt in Ihre Codedateien kopieren und einfügen möchten, anstatt die Doppelklickaktion im Designer zu verwenden, stellen Sie sicher, dass Sie den Ereignishandler auf die richtige Methode festlegen:

1. Wechseln Sie im Eigenschaftenfenster der Codedatei für das Formular mithilfe der Schaltfläche "Blitzsymbolleiste" zur Registerkarte " Ereignisse ".

2. Suchen Sie nach der Click-Eigenschaft , und überprüfen Sie, ob der Wert die richtige Ereignishandlermethode ist.

Hinzufügen von Code für die Navigationsformularlogik

Vervollständigen Sie in der Codeseite für das Navigationsformular die Methodenkörper für die drei Ereignishandler für die Schaltflächenauswahl 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

Formular "NewCustomer"

Wenn Sie einen Kundennamen eingeben und dann die Schaltfläche " Konto erstellen " auswählen, erstellt das Formular "NewCustomer" ein Kundenkonto, und SQL Server gibt einen IDENTITÄTswert als neue Kunden-ID zurück. Sie können dann eine Bestellung für das neue Konto aufgeben, indem Sie einen Betrag und ein Bestelldatum angeben und die Schaltfläche " Bestellung aufgeben " auswählen.

Erstellen automatisch generierter Ereignishandler für das NewCustomer-Formular

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 eine Schaltfläche zum Auslösen eines Ereignisses ausgewählt werden kann.

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

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

1. Bringen Sie den Namenspace System.Data.SqlClient in den Geltungsbereich, damit Sie die Namen seiner Mitglieder nicht vollständig qualifizieren müssen.

   • C#
   • VB

   using System.Data.SqlClient;
   

2. Fügen Sie der Klasse einige Variablen und Hilfsmethoden hinzu.

   • 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. Vervollständigen Sie die Methodenkörper für die vier Ereignishandler für die Schaltflächenauswahl.

   • 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 FillOrCancel-Formular führt eine Abfrage aus, um eine Bestellung zurückzugeben, wenn Sie eine Auftrags-ID eingeben, und wählen Sie dann die Schaltfläche " Bestellung suchen" aus . Die zurückgegebene Zeile wird in einem schreibgeschützten Datenraster angezeigt. Sie können die Bestellung als abgebrochen (X) markieren, wenn Sie die Schaltfläche " Bestellung abbrechen " auswählen, oder Sie können die Bestellung als ausgefüllt (F) markieren, wenn Sie die Schaltfläche " Bestellung ausfüllen" auswählen. Wenn Sie die Schaltfläche " Reihenfolge suchen " erneut auswählen, wird die aktualisierte Zeile angezeigt.

Erstellen von automatisch generierten Ereignishandlern für das Formular FillOrCancel

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 eine Schaltfläche zum Auslösen eines Ereignisses ausgewählt werden kann.

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.

   • 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. Vervollständigen Sie die Methodenkörper für die vier Ereignishandler für die Schaltflächenauswahl.

   • 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 Der Anwendung

Führen Sie die Anwendung aus, und versuchen Sie, einige Kunden und Bestellungen zu erstellen, um zu überprüfen, ob alles wie erwartet funktioniert.

So überprüfen Sie, ob die Datenbank mit Ihren Änderungen aktualisiert wird:

1. Öffnen Sie den Knoten "Tabellen" im Server-Explorer.

2. Klicken Sie mit der rechten Maustaste auf die Knoten "Kunden " und "Bestellungen ", und wählen Sie " Tabellendaten anzeigen" aus.

Verwandte Inhalte

• Visual Studio-Datentools für .NET-