Megosztás a következőn keresztül:

Alapszintű adatalkalmazás létrehozása ADO.NET használatával

Note

Az DataSet osztály és a kapcsolódó osztályok a 2000-es évek elejétől származó régi .NET-keretrendszer-technológiák, amelyek lehetővé teszik az alkalmazások számára a memóriában lévő adatokkal való munkát, miközben az alkalmazások leválasztva vannak az adatbázisról. A technológiák különösen hasznosak az olyan alkalmazások esetében, amelyek lehetővé teszik a felhasználók számára az adatok módosítását és a módosítások visszaállítását az adatbázisba. Bár az adathalmazok bizonyítottan sikeres technológiának számítanak, az új .NET-alkalmazásokhoz ajánlott az Entity Framework Core használata. Az Entity Framework természetesebb módot kínál a táblázatos adatok objektummodellként való használatához, és egyszerűbb programozási felülettel rendelkezik.

Amikor olyan alkalmazást hoz létre, amely egy adatbázisban módosítja az adatokat, általában olyan feladatokat hajt végre, mint a kapcsolati sztringek meghatározása, az adatok beszúrása és a tárolt eljárások futtatása. A cikk követésével megtudhatja, hogyan használhatja az adatbázisokat az űrlapokon keresztüli adatokon (FOD) keresztüli Windows Forms-alkalmazásokból a Visual C# vagy a Visual Basic és ADO.NET használatával. Az összes .NET-adattechnológia, beleértve az adathalmazokat, a LINQ-t (Language-Integrated Query) az SQL-hez és az Entity Framework-hez, végső soron az ebben a cikkben bemutatott lépésekhez hasonló lépéseket hajt végre.

Ez a cikk bemutatja, hogyan lehet gyorsan adatokat lekérni egy adatbázisból. Ha az alkalmazásnak nemtriviális módon kell módosítania az adatokat, és frissítenie kell az adatbázist, fontolja meg az Entity Framework és az adatkötés használatát. Így a felhasználói felület vezérlői automatikusan szinkronizálhatók a mögöttes adatok változásaival.

Az oktatóanyag teljes kódjának eléréséhez tekintse meg a Visual Studio docs GitHub C# -hoz és Visual Basichez készült adattárát.

Important

A kód egyszerűségének megőrzése érdekében nincs benne éles környezetre szánt kivételkezelés.

Prerequisites

  • Visual Studio az .NET asztali fejlesztési és a Adattárolási és feldolgozási számítási feladatok telepítésével. A telepítésükhöz nyissa meg a Visual Studio Installert, és válassza a Módosítani kívánt Visual Studio-verzió melletti Módosítás lehetőséget.

  • SQL Server Express LocalDB. Ha nem rendelkezik SQL Server Express LocalDB-vel, telepítheti a SQL Server letöltési oldaláról.

Ez a cikk feltételezi, hogy ismeri a Visual Studio IDE alapvető funkcióit. Azt is feltételezi, hogy létrehozhat egy Windows Forms-alkalmazást, hozzáadhat űrlapokat egy projekthez, gombokat és egyéb vezérlőket adhat hozzá az űrlapokhoz, beállíthatja a vezérlő tulajdonságait, és egyszerű eseményeket kódozhat. Ha nem ismeri ezeket a feladatokat, végezze el a Windows Forms-alkalmazás létrehozása a Visual Studióban C# oktatóanyaggal vagy a Windows Forms alkalmazás létrehozása a Visual Studióban Visual Basic-oktatóanyaggal , mielőtt elkezdené ezt az útmutatót.

A mintaadatbázis beállítása

Hozza létre a mintaadatbázist az alábbi lépések végrehajtásával:

  1. Nyissa meg a Kiszolgálókezelő ablakot a Visual Studióban.

  2. Kattintson a jobb gombbal az adatkapcsolatokra, és válassza az Új SQL Server-adatbázis létrehozása parancsot.

  3. A kiszolgáló neve legyen (localdb)\mssqllocaldb.

  4. Az Új adatbázis neve mezőbe írja be a Sales (Értékesítés) kifejezést, majd kattintson az OK gombra.

    A Visual Studio létrehoz egy üres Értékesítési adatbázist a Kiszolgálókezelő Adatkapcsolatok csomópontja alatt.

  5. Kattintson a jobb gombbal az Értékesítési adatkapcsolatra, és válassza az Új lekérdezés lehetőséget.

    Megnyílik egy lekérdezésszerkesztő ablak.

  6. Másolja a Sales Transact-SQL szkriptet a vágólapra.

  7. Illessze be a T-SQL-szkriptet a lekérdezésszerkesztő ablakába, majd válassza a Végrehajtás lehetőséget.

    Rövid idő elteltével a lekérdezés befejeződik, és létrejönnek az adatbázis-objektumok. Az adatbázis két táblát tartalmaz: Ügyfél és Rendelések. Ezek a táblák kezdetben nem tartalmaznak adatokat, de a létrehozott alkalmazás futtatásakor adatokat adhat hozzá. Az adatbázis öt alapvető tárolt eljárást is tartalmaz.

Űrlapok létrehozása és vezérlők hozzáadása

  1. Hozzon létre egy C# vagy Visual Basic projektet a Windows Forms App (.NET Framework) sablonnal, és nevezze el SimpleDataAppnak.

    A Visual Studio létrehozza a projektet és több fájlt, köztük egy Űrlap1 nevű üres Windows-űrlapot.

  2. A Megoldáskezelőben adjon hozzá két Windows-űrlapot a projekthez, hogy összesen három űrlapot használjon, és adja meg nekik a következő neveket:

    • Navigation

    • NewCustomer

    • FillOrCancel

  3. Minden űrlaphoz adja hozzá az alábbi ábrákon látható szövegdobozokat, gombokat és egyéb vezérlőket. Minden vezérlőelemhez adja meg a táblák által leírt tulajdonságokat.

    Note

    A csoportmező és a címkevezérlők növelik az egyértelműséget, de nem használják a kódban.

    navigációs űrlap

    Képernyőkép a navigációs űrlap részleteiről.

    A navigációs űrlap vezérlői

    Vezérlő szöveg Vezérlő típusa Vezérlőtulajdonságok
    Fiók hozzáadása Button Name = btnGoToAdd
    Rendelés kitöltése vagy lemondása Button Name = btnGoToFillOrCancel
    Exit Button Name = btnExit

    ÚjÜgyfél űrlap

    Képernyőkép a NewCustomer űrlap részleteiről.

    Az ÚjVásárló űrlap vezérlői

    Címke/vezérlőelem szövege Vezérlő típusa Vezérlőtulajdonságok
    Ügyfél neve TextBox Name = txtCustomerName
    Ügyfélazonosító TextBox Name = txtCustomerID
    ReadOnly = Igaz
    Fiók létrehozása Button Name = btnCreateAccount
    Rendelés összege NumericUpdown Name = numOrderAmount
    Decimális hely = 0
    Maximum = 5000
    Rendelés dátuma DateTimePicker Name = dtpOrderDate
    Formátum = Rövid
    Rendelés leadása Button Name = btnPlaceOrder
    Finish Button Name = btnAddFinish
    Másik fiók hozzáadása Button Name = btnAddAnotherAccount

    FillOrCancel űrlap

    Képernyőkép a FillOrCancel űrlap részleteiről.

    A FillOrCancel űrlap vezérlői

    Címke/vezérlőelem szövege Vezérlő típusa Vezérlőtulajdonságok
    Rendelés azonosítója TextBox Name = txtOrderID
    Rendelés keresése Button Name = btnFindByOrderID
    Megrendelés kitöltése esetén... DateTimePicker Name = dtpFillDate
    Formátum = Rövid
    (None) DataGridView Név = dgvÜgyfélRendelések
    ReadOnly = Igaz
    RowHeadersVisible = Nem látható
    Rendelés lemondása Button Name = btnCancelOrder
    Kitöltési sorrend Button Name = btnFillOrder
    Finish Button Name = btnFinishUpdates

A kapcsolati sztring tárolása

Amikor az alkalmazás megpróbál kapcsolatot nyitni az adatbázissal, az alkalmazásnak hozzá kell férnie a kapcsolati sztringhez. Annak érdekében, hogy ne kelljen manuálisan beírni a sztringet az egyes űrlapokon, tárolja a sztringet a projektApp.config fájljában. Ezután hozzon létre egy metódust, amely visszaadja a sztringet, amikor a metódust az alkalmazás bármely űrlapjáról meghívják.

Kapcsolati karakterlánc megkeresése:

  1. A Kiszolgálókezelőben kattintson a jobb gombbal az Értékesítési adatkapcsolatra, majd válassza a Tulajdonságok parancsot.

  2. Keresse meg a Kapcsolati sztring tulajdonságot, és másolja a sztring értékét a vágólapra.

A kapcsolati sztring tárolása a projektben:

  1. A Megoldáskezelőben végezze el az alábbi lépések egyikét a projekt típusától függően:

    • C#-projekt esetén bontsa ki a Projekt Tulajdonságok csomópontot, majd nyissa meg a Settings.settings fájlt.

    • Visual Basic-projekt esetén válassza az Összes fájl megjelenítése lehetőséget, bontsa ki a Saját projekt csomópontot, majd nyissa meg a Settings.settings fájlt.

  2. A Név oszlopban adja meg a connString értéket.

  3. A Típus listában válassza a (Kapcsolati sztring) lehetőséget.

  4. A Hatókör listában válassza Alkalmazáslehetőséget.

  5. Az Érték oszlopban adja meg a kapcsolati sztringet (külső idézőjelek nélkül), majd mentse a módosításokat.

    Képernyőkép a Kapcsolati karakterlánc adatairól a Settings.settings fájlban.

Caution

Valós alkalmazás esetén biztonságosan kell tárolni a kapcsolati karakterláncot, ahogy az a Kapcsolati sztringek és konfigurációs fájlokbekezdésben le van írva. A legjobb biztonság érdekében olyan hitelesítési módszert használjon, amely nem támaszkodik jelszó tárolására a kapcsolati sztringben. Például egy helyszíni SQL Server-adatbázis Windows-hitelesítése. További információ: Kapcsolati sztringek mentése és szerkesztése.

Az űrlapok kódjának írása

Ez a szakasz rövid áttekintést nyújt arról, hogy mit csinál az egyes űrlapok. Emellett a mögöttes logikát meghatározó kódot is tartalmazza, amikor kiválaszt egy gombot az űrlapon.

Az alkalmazás futtatásakor megnyílik a navigációs űrlap, amely a következő gombokat tartalmazza:

  • Fiók hozzáadása: Megnyitja a NewCustomer űrlapot.

  • Rendelések kitöltése vagy lemondása: Megnyitja a FillOrCancel űrlapot.

  • Kilépés: Bezárja az alkalmazást.

Tegye a Navigációs űrlapot az indítási űrlappá

C#-projektek esetén:

  1. A Megoldáskezelőben nyissa meg a Program.cs.

  2. Módosítsa a Application.Run sort erre: Application.Run(new Navigation());

Visual Basic-projektek esetén:

  1. A Megoldáskezelőben kattintson a jobb gombbal a projektre, és válassza a Tulajdonságok parancsot.

  2. A Projekttervezőben válassza az Alkalmazás lapot, majd az Indítási objektum listában válassza a Navigáció lehetőséget.

Automatikus eseménykezelők létrehozása a navigációs űrlaphoz

Üres eseménykezelő metódusok létrehozásához kattintson duplán a navigációs űrlap három gombjára. Ha duplán kattint egy gombra, automatikusan generált kódot ad hozzá a Tervező kódfájlban, így a gombkijelöléssel eseményt hozhat létre.

Ha úgy dönt, hogy közvetlenül a kódfájlokba másolja és illessze be a kódot a tervező dupla kattintásos művelete helyett, győződjön meg arról, hogy az eseménykezelőt a megfelelő módszerre állítja:

  1. Az űrlap kódfájljának Tulajdonságok ablakában váltson az Események lapra a Villámcsapás eszköztár gomb használatával.

  2. Keresse meg a Click tulajdonságot, és ellenőrizze, hogy az értéke a megfelelő eseménykezelő módszer-e.

Kód hozzáadása a navigációs űrlap logikájához

A navigációs űrlap kódlapján töltse ki a három gombos eseménykezelő metódustörzsét az alábbi kódban látható módon.

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

NewCustomer űrlap

Amikor megad egy ügyfélnevet, majd a Fiók létrehozása gombot választja, a NewCustomer űrlap létrehoz egy ügyfélfiókot, az SQL Server pedig identitásértéket ad vissza új ügyfélazonosítóként. Ezután az új fiók megrendelését egy összeg és egy rendelési dátum megadásával, valamint a Rendelés leadása gombra kattintva adhatja meg.

Automatikusan létrehozott eseménykezelők létrehozása a NewCustomer űrlaphoz

Hozzon létre egy üres Click eseménykezelőt a NewCustomer űrlap minden egyes gombjához a négy gomb mindegyikére duplán kattintva. A gombokra duplán kattintva automatikusan generált kódot is hozzáad a Tervező kódfájlhoz, amely lehetővé teszi, hogy egy gomb kiválasztva eseményt emeljen ki.

Kód hozzáadása a NewCustomer űrlaplogikához

A NewCustomer űrlaplogika elvégzéséhez kövesse az alábbi lépéseket:

  1. Tegye a névteret a System.Data.SqlClient hatókörébe, hogy ne kelljen teljesen kvalifikálnia a tagok nevét.

    using System.Data.SqlClient;

  1. Adjon hozzá néhány változót és segédmetórát az osztályhoz.

    // 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;
}

  1. Töltse ki a négy gombválasztó eseménykezelő metódustörzseit.

    /// <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 űrlap

A FillOrCancel űrlap egy lekérdezést futtat, amely egy rendelésazonosító megadásakor visszaadja a rendelést, majd válassza a Rendelés keresése gombot. A visszaadott sor egy csak olvasható adatrácsban jelenik meg. Ha a Rendelés lemondása gombot választja, a rendelést megszakítottként (X) jelölheti meg, vagy ha a Rendelés kitöltése gombot választja, a rendelést kitöltve (F) jelölheti meg. Ha ismét a Rendelés keresése gombra kattint, megjelenik a frissített sor.

Automatikus eseménykezelők létrehozása a FillOrCancel űrlaphoz

A FillOrCancel űrlap négy gombjának üres kattintási eseménykezelőinek létrehozásához kattintson duplán a gombokra. A gombokra duplán kattintva automatikusan generált kódot is hozzáad a Tervező kódfájlhoz, amely lehetővé teszi, hogy egy gomb kiválasztva eseményt emeljen ki.

Kód hozzáadása a FillOrCancel űrlaplogikához

A FillOrCancel űrlaplogika elvégzéséhez kövesse az alábbi lépéseket.

  1. Hozza a következő két névteret a hatókörbe, hogy ne kelljen teljesen minősítenie a tagok nevét.

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

  1. Adjon hozzá egy változót és egy segédmetódust az osztályhoz.

    // 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;
    }
}

  1. Töltse ki a négy gombválasztó eseménykezelő metódustörzseit.

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

Az alkalmazás tesztelése

Futtassa az alkalmazást, és próbáljon meg létrehozni néhány ügyfelet és rendelést, hogy ellenőrizze, minden a várt módon működik-e.

Annak ellenőrzéséhez, hogy az adatbázis frissült-e a módosításokkal:

  1. Nyissa meg a Táblák csomópontot a Kiszolgálókezelőben.

  2. Kattintson a jobb gombbal az Ügyfelek és rendelések csomópontokra, és válassza a Táblaadatok megjelenítése parancsot.

Kapcsolódó tartalom

  • Last updated on