Delen via

Een eenvoudige gegevenstoepassing maken met behulp van ADO.NET

Note

De DataSet klassen en gerelateerde klassen zijn verouderde .NET Framework-technologieën uit het begin van de jaren 2000 waarmee toepassingen met gegevens in het geheugen kunnen werken terwijl de apps losgekoppeld zijn van de database. De technologieën zijn vooral handig voor apps waarmee gebruikers gegevens kunnen wijzigen en de wijzigingen weer kunnen behouden in de database. Hoewel gegevenssets een bewezen succesvolle technologie zijn, is de aanbevolen aanpak voor nieuwe .NET-toepassingen het gebruik van Entity Framework Core. Entity Framework biedt een natuurlijkere manier om met tabelgegevens te werken als objectmodellen en heeft een eenvoudigere programmeerinterface.

Wanneer u een toepassing maakt die gegevens in een database bewerkt, voert u doorgaans taken uit, zoals het definiëren van verbindingsreeksen, het invoegen van gegevens en het uitvoeren van opgeslagen procedures. Terwijl u dit artikel volgt, kunt u ontdekken hoe u kunt communiceren met een database vanuit een formulier via gegevens (FOD) windows forms met behulp van Visual C# of Visual Basic en ADO.NET. Alle .NET-gegevenstechnologieën, waaronder gegevenssets, LINQ (Language-Integrated Query) naar SQL en Entity Framework, voeren uiteindelijk stappen uit die vergelijkbaar zijn met die stappen die in dit artikel worden weergegeven.

In dit artikel wordt beschreven hoe u snel gegevens uit een database haalt. Als uw toepassing gegevens op niet-triviele manieren moet wijzigen en de database moet bijwerken, kunt u overwegen Entity Framework en gegevensbinding te gebruiken. Hierdoor kunnen besturingselementen van de gebruikersinterface automatisch worden gesynchroniseerd met wijzigingen in de onderliggende gegevens.

Zie de GitHub-opslagplaats voor Visual Studio voor C# en Visual Basic voor toegang tot de volledige code voor deze zelfstudie.

Important

Om de code eenvoudig te houden, bevat deze geen verwerking van uitzonderingen die gereed zijn voor productie.

Prerequisites

  • Visual Studio met de .NET-desktopontwikkeling en Gegevensopslag en -verwerking workloads geïnstalleerd. Als u deze wilt installeren, opent u Visual Studio Installer en kiest u Wijzigen naast de versie van Visual Studio die u wilt wijzigen.

  • SQL Server Express LocalDB. Als u geen SQL Server Express LocalDB hebt, kunt u deze installeren vanaf de downloadpagina van SQL Server.

In dit artikel wordt ervan uitgegaan dat u bekend bent met de basisfunctionaliteit van de Visual Studio IDE. Er wordt ook van uitgegaan dat u een Windows Forms-toepassing kunt maken, formulieren kunt toevoegen aan een project, knoppen en andere besturingselementen aan de formulieren kunt toevoegen, besturingselementeigenschappen en eenvoudige code-gebeurtenissen kunt instellen. Als u niet vertrouwd bent met deze taken, voltooit u de zelfstudie Een Windows Forms-app maken in Visual Studio met C# of de zelfstudie Een Windows Forms-app maken in Visual Studio met Visual Basic voordat u aan deze procedure begint.

De voorbeelddatabase instellen

Maak de voorbeelddatabase door de volgende stappen uit te voeren:

  1. Open in Visual Studio het venster Server Explorer.

  2. Klik met de rechtermuisknop op Gegevensverbindingen en kies Nieuwe SQL Server-database maken.

  3. Voer voor servernaam(localdb)\mssqllocaldb in.

  4. Voer verkoop in voor de naam van de nieuwe database en kies VERVOLGENS OK.

    Visual Studio maakt een lege verkoopdatabase onder het knooppunt Gegevensverbindingen in Server Explorer.

  5. Klik met de rechtermuisknop op de verbinding Verkoopgegevens en selecteer Nieuwe query.

    Er wordt een venster van de queryeditor geopend.

  6. Kopieer Sales Transact-SQL script naar je klembord.

  7. Plak het T-SQL-script in het venster van de queryeditor en selecteer Vervolgens Uitvoeren.

    Na korte tijd is de query voltooid en worden de databaseobjecten gemaakt. De database bevat twee tabellen: Klant en Orders. Deze tabellen bevatten in eerste instantie geen gegevens, maar u kunt gegevens toevoegen wanneer u de toepassing uitvoert die u maakt. De database bevat ook vijf eenvoudige opgeslagen procedures.

Formulieren maken en besturingselementen toevoegen

  1. Maak een C# of Visual Basic-project met de Sjabloon Windows Forms App (.NET Framework) en noem deze SimpleDataApp.

    Visual Studio maakt het project en verschillende bestanden, waaronder een leeg Windows-formulier met de naam Form1.

  2. Voeg in Solution Explorer twee Windows-formulieren toe aan uw project, zodat het in totaal drie formulieren bevat en geef ze de volgende namen:

    • Navigation

    • NewCustomer

    • FillOrCancel

  3. Voeg voor elk formulier de tekstvakken, knoppen en andere besturingselementen toe die worden weergegeven in de volgende illustraties. Stel voor elk besturingselement de eigenschappen in die in de tabellen worden beschreven.

    Note

    Het groepsvak en de labelbesturingselementen voegen duidelijkheid toe, maar worden niet gebruikt in de code.

    navigatieformulier

    Schermopname van de details van het navigatieformulier.

    Besturingselementen voor het navigatieformulier

    Controle tekst Soort bedieningselement Besturingseigenschappen
    Een account toevoegen Button Name = btnGoToAdd
    Een bestelling invullen of annuleren Button Name = btnGoToFillOrCancel
    Exit Button Name = btnExit

    Formulier NewCustomer

    Schermopname van de details van het formulier NewCustomer.

    Besturingselementen voor het formulier NewCustomer

    Tekst van label/besturingselement Soort bedieningselement Besturingseigenschappen
    Klantnaam TextBox Name = txtCustomerName
    Klant-id TextBox Name = txtCustomerID
    Alleen-lezen = Waar
    Account maken Button Name = btnCreateAccount
    Orderbedrag NumericUpdown Name = numOrderAmount (het orderbedrag nummer)
    DecimalPlaces = 0
    Maximum = 5000
    Orderdatum DateTimePicker Name = dtpOrderDate
    Formaat = Kort
    Bestelling plaatsen Button Name = btnPlaceOrder
    Finish Button Name = btnAddFinish
    Een ander account toevoegen Button Name = btnAddAnotherAccount

    FillOrCancel-formulier

    Schermopname van de details van het formulier FillOrCancel.

    Besturingselementen voor het formulier FillOrCancel

    Tekst van label/besturingselement Soort bedieningselement Besturingseigenschappen
    Ordernummer TextBox Name = txtOrderID
    Bestelling zoeken Button Name = btnFindByOrderID
    Als u een bestelling invult... DateTimePicker Name = dtpFillDate
    Formaat = Kort
    (None) DataGridView Name = dgvCustomerOrders
    Alleen-lezen = Waar
    RowHeadersVisible = False
    Bestelling annuleren Button Name = btnAnnuleerBestelling
    Opvulvolgorde Button Name = btnFillOrder
    Finish Button Name = btnFinishUpdates

De verbindingsreeks opslaan

Wanneer uw toepassing probeert een verbinding met de database te openen, moet uw toepassing toegang hebben tot de verbindingsreeks. Sla de tekenreeks in het App.config-bestand in uw project op om te voorkomen dat u de tekenreeks handmatig moet invoeren in elk formulier. Maak vervolgens een methode die de tekenreeks retourneert wanneer de methode wordt aangeroepen vanuit een formulier in uw toepassing.

De verbindingstekenreeks vinden:

  1. Klik in Server Explorer met de rechtermuisknop op de verbinding Verkoopgegevens en kies Eigenschappen.

  2. Zoek de eigenschap Verbindingsreeks en kopieer de tekenreekswaarde naar het klembord.

De verbindingsreeks opslaan in uw project:

  1. Voer in Solution Explorer een van de volgende stappen uit, afhankelijk van uw projecttype:

    • Vouw voor een C#-project het knooppunt Eigenschappen onder het project uit en open vervolgens het bestand Settings.settings .

    • Voor een Visual Basic-project selecteert u Alle bestanden weergeven, vouwt u het knooppunt Mijn project uit en opent u vervolgens het bestand Settings.settings .

  2. Voer connString in de kolom Naam in.

  3. Selecteer (verbindingsreeks) in de lijst Type.

  4. Selecteer toepassingin de bereiklijst.

  5. Voer in de kolom Waarde de verbindingsreeks (zonder externe aanhalingstekens) in en sla de wijzigingen op.

    Schermopname van de verbindingstekenreeksgegevens in Settings.settings.

Caution

In een echte toepassing moet u de verbindingsreeks veilig opslaan, zoals beschreven in verbindingsreeksen en configuratiebestanden. Gebruik voor de beste beveiliging een verificatiemethode die niet afhankelijk is van het opslaan van een wachtwoord in de verbindingsreeks. Bijvoorbeeld Windows-verificatie voor een on-premises SQL Server-database. Zie Verbindingsreeksen opslaan en bewerken voor meer informatie.

De code voor de formulieren schrijven

Deze sectie bevat korte overzichten van wat elk formulier doet. Het bevat ook de code waarmee de onderliggende logica wordt gedefinieerd wanneer u een knop in het formulier selecteert.

Het navigatieformulier wordt geopend wanneer u de toepassing uitvoert en bevat de volgende knoppen:

  • Een account toevoegen: Hiermee opent u het formulier NewCustomer .

  • Orders doorvoeren of annuleren: hiermee opent u het formulier FillOrCancel .

  • Afsluiten: Sluit de toepassing.

Het navigatieformulier als startformulier instellen

Voor C#-projecten:

  1. Open Program.cs in Solution Explorer.

  2. Wijzig de Application.Run regel in: Application.Run(new Navigation());

Voor Visual Basic-projecten:

  1. Klik in Solution Explorer met de rechtermuisknop op het project en kies Eigenschappen.

  2. Selecteer in Projectontwerper het tabblad Toepassing en selecteer vervolgens Navigatie in de lijst met opstartobjecten .

Automatisch gegenereerde event handlers maken voor het navigatieformulier

Als u lege methoden voor eventhandlers wilt maken, dubbelklikt u op elk van de drie knoppen in het Navigatie-formulier. Als u dubbelklikt op een knop, wordt automatisch gegenereerde code toegevoegd in het codebestand Designer, waardoor een knopselectie een gebeurtenis kan genereren.

Als u besluit om code rechtstreeks in uw codebestanden te kopiëren en plakken in plaats van de dubbelklikactie in de ontwerpfunctie te gebruiken, moet u ervoor zorgen dat u de gebeurtenis-handler instelt op de juiste methode:

  1. Ga in het venster Eigenschappen van het codebestand dat bij het formulier hoort naar het tabblad Gebeurtenissen met behulp van de bliksemschicht-knop op de werkbalk.

  2. Zoek de eigenschap Click en controleer of de waarde de juiste gebeurtenis-handlermethode is.

Code toevoegen voor de logica van het navigatieformulier

Vul op de codepagina voor het navigatieformulier de methodenlichamen in voor de drie event handlers voor knopselectie, zoals weergegeven in de volgende code.

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

Formulier NewCustomer

Wanneer u een klantnaam invoert en vervolgens de knop Account maken selecteert, maakt het formulier NewCustomer een klantaccount en retourneert SQL Server een ID-waarde als de nieuwe klant-id. Vervolgens kunt u een bestelling voor het nieuwe account plaatsen door een bedrag en een orderdatum op te geven en de knop Bestelling plaatsen te selecteren.

Automatisch gegenereerde event handlers maken voor de NewCustomer-formulier

Maak een lege Click-gebeurtenisverwerker voor elke knop op het formulier NewCustomer door dubbel te klikken op elk van de vier knoppen. Als u dubbelklikt op de knoppen, wordt ook automatisch gegenereerde code toegevoegd in het Designer-codebestand waarmee een knop een gebeurtenis kan starten.

Code toevoegen voor de formulierlogica NewCustomer

Voer de volgende stappen uit om de formulierlogica NewCustomer te voltooien:

  1. Breng de naamruimte in de scope zodat u de namen van de leden niet volledig hoeft te specificeren.

    using System.Data.SqlClient;

  1. Voeg enkele variabelen en helpermethoden toe aan de klasse.

    // 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. Voltooi de methode-implementaties voor de vier gebeurtenis-handlers voor knoppen voor selectie.

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

Het formulier FillOrCancel voert een query uit om een order te retourneren wanneer u een order-id invoert en selecteer vervolgens de knop Order zoeken . De geretourneerde rij wordt weergegeven in een alleen-lezen gegevensrooster. U kunt de order markeren als geannuleerd (X) als u de knop Order annuleren selecteert, of u kunt de order markeren als ingevuld (F) als u de knop Order doorvoeren selecteert. Als u de knop Order zoeken opnieuw selecteert, wordt de bijgewerkte rij weergegeven.

Automatisch gegenereerde gebeurtenishandlers maken voor het formulier "FillOrCancel"

Maak lege klikgebeurtenishandlers voor de vier knoppen in het formulier FillOrCancel door te dubbelklikken op de knoppen. Als u dubbelklikt op de knoppen, wordt ook automatisch gegenereerde code toegevoegd in het Designer-codebestand waarmee een knop een gebeurtenis kan starten.

Code toevoegen voor de formulierlogica FillOrCancel

Volg deze stappen om de formulierlogica FillOrCancel te voltooien.

  1. Breng de volgende twee naamruimten binnen het bereik zodat u de namen van hun leden niet volledig hoeft te kwalificeren.

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

  1. Voeg een variabele en helpermethode toe aan de klasse.

    // 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. Voltooi de methode-implementaties voor de vier gebeurtenis-handlers voor knoppen voor selectie.

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

Uw toepassing testen

Voer de toepassing uit en probeer een paar klanten en orders te maken om te controleren of alles werkt zoals verwacht.

Ga als volgt te werk om te controleren of de database is bijgewerkt met uw wijzigingen:

  1. Open het knooppunt Tabellen in Server Explorer.

  2. Klik met de rechtermuisknop op de knooppunten Klanten en Orders en kies Tabelgegevens weergeven.

Verwante inhoud

  • Last updated on