Freigeben über

Erstellen einer einfachen Datenanwendung mithilfe von ADO.NET

Anmerkung

Datasets und verwandte Klassen sind ältere .NET Framework-Technologien aus den frühen 2000er Jahren, mit denen Anwendungen mit Daten im Arbeitsspeicher arbeiten können, während die Anwendungen von der Datenbank getrennt werden. Die Technologien sind besonders nützlich für Anwendungen, mit denen Benutzer Daten ändern und die Änderungen wieder in der Datenbank speichern können. Obwohl Datasets sich als sehr erfolgreiche Technologie erwiesen haben, empfehlen wir, dass neue .NET-Anwendungen Entity Framework Coreverwenden. Entity Framework bietet eine natürlichere Möglichkeit, mit tabellarischen Daten als Objektmodelle zu arbeiten und verfügt über eine einfachere Programmierschnittstelle.

Wenn Sie eine Anwendung erstellen, die Daten in einer Datenbank bearbeitet, führen Sie grundlegende Aufgaben wie das Definieren von Verbindungszeichenfolgen, das Einfügen von Daten und das Ausführen gespeicherter Prozeduren durch. Anhand dieses Themas können Sie mithilfe von Visual C# oder Visual Basic und ADO.NET in einer einfachen Windows Forms-Anwendung "Formulare über Daten" mit einer Datenbank interagieren. 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 nichttrivielle 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.

Wichtig

Um den Code einfach zu halten, enthält er keine produktionsbereite Ausnahmebehandlung.

Anmerkung

Auf den vollständigen Code für dieses Lernprogramm kann im GitHub-Repository von Visual Studio in C#- und Visual Basic-zugegriffen werden.

Voraussetzungen

Zum Erstellen der Anwendung benötigen Sie Folgendes:

  • 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 sie über die SQL Server-Downloadseiteinstallieren.

In diesem Thema wird davon ausgegangen, dass Sie mit den grundlegenden Funktionen der Visual Studio-IDE vertraut sind und eine Windows Forms-Anwendung erstellen, dem Projekt Formulare hinzufügen, Schaltflächen und andere Steuerelemente auf den Formularen platzieren, Eigenschaften der Steuerelemente festlegen und einfache Codeereignisse erstellen können. Wenn Sie mit diesen Aufgaben nicht vertraut sind, empfehlen wir Ihnen, das Lernprogramm Erstellen einer Windows Forms-App in Visual Studio mit Visual Basic oder das Lernprogramm Erstellen einer Windows Forms-App in Visual Studio mit C# abzuschließen, bevor Sie mit dieser Anleitung 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 erstellenaus.

  3. Geben Sie im Textfeld Servernamen(localdb)\mssqllocaldbein.

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

    Die leere Sales-Datenbank wird erstellt und dem Knoten "Datenverbindungen" im 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: "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 vier einfache 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 dann SimpleDataApp-.

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

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

    • Navigation

    • NewCustomer

    • AusfüllenOderStornieren

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

    Anmerkung

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

    Navigationsformular

    Dialogfeld

Steuerelemente für das Navigationsformular Eigenschaften
Schaltfläche Name = btnGoToAdd
Schaltfläche Name = btnGoToFillOrCancel
Schaltfläche Name = btnExit

NewCustomer-Formular

Neuen Kunden hinzufügen und eine Bestellung aufgeben

Steuerelemente für das NewCustomer-Formular Eigenschaften
Textfeld Name = txtCustomerName
Textfeld Name = txtCustomerID

Readonly = True
Schaltfläche Name = btnCreateAccount
NumericUpdown DecimalPlaces = 0

Maximum = 5000

Name = numOrderAmount
DateTimePicker Format = Kurz

Name = dtpOrderDate
Schaltfläche Name = btnPlaceOrder
Schaltfläche Name = btnAddAnotherAccount
Schaltfläche Name = btnAddFinish

FillOrCancel-Formular

bestellungen ausfüllen oder stornieren

Steuerelemente für das FillOrCancel-Formular Eigenschaften
Textfeld Name = txtOrderID
Schaltfläche Name = btnFindByOrderID
DateTimePicker Format = Kurz

Name = dtpFillDate
DataGridView Name = dgvCustomerOrders

Readonly = True

RowHeadersVisible = False
Schaltfläche Name = btnCancelOrder
Schaltfläche Name = btnFillOrder
Schaltfläche 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 die Zeichenfolge für jedes Formular manuell einzugeben, speichern Sie die Zeichenfolge in der App.config Datei in Ihrem Projekt, und erstellen Sie eine Methode, die die Zeichenfolge zurückgibt, wenn die Methode aus einem beliebigen Formular in Ihrer 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 Projekt-Explorerden Knoten Eigenschaften unter dem Projekt, und öffnen Sie dann die Datei Settings.settings. Wenn Sie Visual Basic verwenden, klicken Sie im Projektmappen-Explorerauf "Alle Dateien anzeigen", erweitern Sie den Knoten "Mein Projekt", und öffnen Sie dann die Datei "Einstellungen.settings".

  2. Geben Sie in der Spalte Name den Wert connStringein.

  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 äußere Anführungszeichen) ein und speichern Sie die Änderungen.

    Screenshot: Verbindungszeichenfolge in „Settings.settings“

Vorsicht

In einer echten Anwendung sollten Sie die Verbindungszeichenfolge sicher speichern, wie in Verbindungszeichenfolgen und Konfigurationsdateienbeschrieben. Verwenden Sie für optimale Sicherheit eine Authentifizierungsmethode, die nicht darauf basiert, ein Kennwort in der Verbindungszeichenfolge zu speichern, z. B. die Windows-Authentifizierung für eine lokale SQL Server-Datenbank. Siehe Speichern und Bearbeiten von Verbindungszeichenfolgen.

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 auf eine Schaltfläche im Formular geklickt wird.

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

Erstellen des Navigationsformulars als Startformular

Wenn Sie C# verwenden, öffnen Sie im Projektmappen-ExplorerProgram.cs, und ändern Sie dann die Application.Run Zeile wie folgt: Application.Run(new Navigation());

Wenn Sie Visual Basic verwenden, öffnen Sie im Projektmappen-Explorerdas 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 ein Schaltflächenklick zum Auslösen eines Ereignisses ermöglicht wird.

Anmerkung

Wenn Sie die Doppelklickaktion im Designer überspringen und einfach den Code kopieren und in Ihre Codedateien einfügen, vergessen Sie nicht, den Ereignishandler auf die richtige Methode festzulegen. Dies können Sie im Fenster Eigenschaften ausführen. Wechseln Sie zur Registerkarte Ereignisse (verwenden Sie die Schaltfläche mit dem Blitzsymbol in der Symbolleiste), und suchen Sie nach dem Click-Handler.

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();
}

Anmerkung

Der Code für dieses Lernprogramm ist in C# und Visual Basic verfügbar. Um die Codesprache auf dieser Seite zwischen C# und Visual Basic zu wechseln, verwenden Sie den Codesprachenwechsel oben in jedem Codebeispiel.

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

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 ein Schaltflächenklick 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. Bringen Sie den System.Data.SqlClient-Namensraum in den Geltungsbereich, damit Sie die Namen seiner Mitglieder nicht vollständig qualifizieren müssen.

    using System.Data.SqlClient;

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

    // 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.

    /// <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 Bestell-ID eingeben und die Schaltfläche Bestellung suchen auswählen. 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 Füllreihenfolge auswählen. Wenn Sie erneut die Schaltfläche "Reihenfolge 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 ein Schaltflächenklick 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.

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

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

    // 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.

    /// <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. Um zu überprüfen, ob die Datenbank mit Ihren Änderungen aktualisiert wurde, öffnen Sie den Tabellen-Knoten im Server-Explorer, klicken Sie mit der rechten Maustaste auf die Knoten Customers und Orders und wählen Sie Tabellendaten anzeigenaus.

Verwandte Inhalte