Créer une application de données de base à l’aide de ADO.NET

Note

La DataSet classe et les classes associées sont des technologies .NET Framework héritées du début des années 2000 qui permettent aux applications d’utiliser des données en mémoire pendant que les applications sont déconnectées de la base de données. Les technologies sont particulièrement utiles pour les applications qui permettent aux utilisateurs de modifier les données et de conserver les modifications apportées à la base de données. Bien que les jeux de données soient une technologie éprouvée, l’approche recommandée pour les nouvelles applications .NET consiste à utiliser Entity Framework Core. Entity Framework offre un moyen plus naturel d’utiliser des données tabulaires en tant que modèles objet et dispose d’une interface de programmation plus simple.

Lorsque vous créez une application qui manipule des données dans une base de données, vous effectuez généralement des tâches telles que la définition de chaînes de connexion, l’insertion de données et l’exécution de procédures stockées. À mesure que vous suivez cet article, vous pouvez découvrir comment interagir avec une base de données au sein d'une application Windows Forms forms over data (FOD) en utilisant Visual C# ou Visual Basic et ADO.NET. Toutes les technologies de données .NET, y compris les jeux de données, LINQ (Language-Integrated Query) vers SQL et Entity Framework, effectuent finalement des étapes similaires à celles présentées dans cet article.

Cet article explique comment extraire rapidement des données d’une base de données. Si votre application doit modifier les données de manière nontriviale et mettre à jour la base de données, envisagez d’utiliser Entity Framework et la liaison de données. Cela permet à vos contrôles d’interface utilisateur de se synchroniser automatiquement avec les modifications apportées aux données sous-jacentes.

Pour accéder au code complet de ce didacticiel, consultez le dépôt GitHub de Visual Studio docs pour C# et Visual Basic.

Important

Pour simplifier le code, il n’inclut pas la gestion des exceptions prêtes pour la production.

Prerequisites

Avec les charges de travail Développement de bureau .NET et Stockage et traitement des données installées dans Visual Studio. Pour les installer, ouvrez Visual Studio Installer et choisissez Modifier en regard de la version de Visual Studio que vous souhaitez modifier.
SQL Server Express LocalDB. Si vous n'avez pas SQL Server Express LocalDB, vous pouvez l’installer à partir de la page de téléchargement SQL Server .

Cet article part du principe que vous connaissez les fonctionnalités de base de l’IDE Visual Studio. Il suppose également que vous pouvez créer une application Windows Forms, ajouter des formulaires à un projet, ajouter des boutons et d’autres contrôles aux formulaires, définir des propriétés de contrôle et coder des événements simples. Si vous n’êtes pas à l’aise avec ces tâches, suivez le didacticiel Créer une application Windows Forms dans Visual Studio avec C# ou créer une application Windows Forms dans Visual Studio avec visual Basic avant de commencer cette procédure pas à pas.

Configurer l’exemple de base de données

Créez l’exemple de base de données en procédant comme suit :

Dans Visual Studio, ouvrez la fenêtre de l’Explorateur de serveurs.
Cliquez avec le bouton droit sur Connexions de données et choisissez Créer une base de données SQL Server.
Pour le nom du serveur, entrez (localdb)\mssqllocaldb.
Pour nouveau nom de base de données, entrez Sales, puis choisissez OK.

Visual Studio crée une base de données Sales vide sous le nœud Connexions de données dans l’Explorateur de serveurs.
Cliquez avec le bouton droit sur la connexion de données Sales et sélectionnez Nouvelle requête.

Une fenêtre de l’éditeur de requête s’ouvre.
Copiez le script Ventes Transact-SQL dans votre Presse-papiers.
Collez le script T-SQL dans la fenêtre de l’éditeur de requête, puis sélectionnez Exécuter.

Après un court moment, la requête termine son exécution et les objets de base de données sont créés. La base de données contient deux tables : Customer et Orders. Ces tables ne contiennent pas de données initialement, mais vous pouvez ajouter des données lorsque vous exécutez l’application que vous créez. La base de données contient également cinq procédures stockées de base.

Créer les formulaires et ajouter des contrôles

Créez un projet C# ou Visual Basic avec le modèle Application Windows Forms (.NET Framework) et nommez-le SimpleDataApp.

Visual Studio crée le projet et plusieurs fichiers, y compris un formulaire Windows vide nommé Form1.
Dans l’Explorateur de solutions, ajoutez deux formulaires Windows à votre projet afin qu’il dispose d’un total de trois formulaires et donnez-lui les noms suivants :
- Navigation
- NewCustomer
- FillOrCancel

Pour chaque formulaire, ajoutez les zones de texte, les boutons et d’autres contrôles présentés dans les illustrations suivantes. Pour chaque contrôle, définissez les propriétés que les tables décrivent.

Note

La zone de groupe et les contrôles d’étiquette ajoutent de la clarté, mais ne sont pas utilisées dans le code.

formulaire de navigation

Capture d’écran montrant les détails du formulaire de navigation.

Contrôles du formulaire de navigation

Texte de contrôle	Type de contrôle	Propriétés de contrôle
Ajouter un compte	Button	Name = btnGoToAdd
Remplir ou annuler une commande	Button	Name = btnGoToFillOrCancel
Exit	Button	Name = btnExit

Formulaire NewCustomer

Capture d’écran montrant les détails du formulaire NewCustomer.

Contrôles pour le formulaire NewCustomer

Texte d’étiquette/contrôle	Type de contrôle	Propriétés de contrôle
Nom de client	TextBox	Name = txtCustomerName
ID de client	TextBox	Name = txtCustomerID ReadOnly = True
Créer le compte	Button	Name = btnCréerUnCompte
Montant de la commande	NumericUpdown	Name = numOrderAmount Nombre de décimales = 0 Maximum = 5000
Date de commande	DateTimePicker	Name = dtpOrderDate Format = Court
Passer une commande	Button	Name = btnPlaceOrder
Finish	Button	Name = btnAddFinish
Ajouter un autre compte	Button	Name = btnAddAnotherAccount

Formulaire FillOrCancel

Capture d’écran montrant les détails du formulaire FillOrCancel.

Contrôles du formulaire FillOrCancel

Texte d’étiquette/contrôle	Type de contrôle	Propriétés de contrôle
ID de commande	TextBox	Name = txtOrderID
Trouver la commande	Button	Name = btnFindByOrderID
Si vous remplissez une commande...	DateTimePicker	Name = dtpFillDate Format = Court
(None)	DataGridView	Name = dgvCustomerOrders ReadOnly = True RowHeadersVisible = Faux
Annuler l’ordre	Button	Name = btnCancelOrder
Remplir la commande	Button	Name = btnFillOrder
Finish	Button	Name = btnFinishUpdates

Stocker la chaîne de connexion

Lorsque votre application tente d’ouvrir une connexion à la base de données, votre application doit avoir accès à la chaîne de connexion. Pour éviter d’avoir à entrer la chaîne manuellement sur chaque formulaire, stockez la chaîne dans le fichier App.config dans votre projet. Ensuite, créez une méthode qui retourne la chaîne lorsque la méthode est appelée à partir de n’importe quel formulaire dans votre application.

Pour rechercher la chaîne de connexion :

Dans l’Explorateur de serveurs, cliquez avec le bouton droit sur la connexion de données Sales , puis choisissez Propriétés.
Recherchez la propriété Chaîne de connexion et copiez sa valeur de chaîne dans le Presse-papiers.

Pour stocker la chaîne de connexion dans votre projet :

Dans l’Explorateur de solutions, effectuez l’une des étapes suivantes, en fonction du type de projet :
- Pour un projet C#, développez le nœud Propriétés sous le projet, puis ouvrez le fichier Settings.settings .
- Pour un projet Visual Basic, sélectionnez Afficher tous les fichiers, développez le nœud Mon projet , puis ouvrez le fichier Settings.settings .
Dans la colonne Name , entrez connString.
Dans la liste Type , sélectionnez (Chaîne de connexion).
Dans la liste Étendue, sélectionnez Application.
Dans la colonne Valeur, entrez votre chaîne de connexion (sans guillemets extérieurs), puis enregistrez vos modifications.

Caution

Dans une application réelle, vous devez stocker la chaîne de connexion en toute sécurité, comme décrit dans chaînes de connexion et fichiers de configuration. Pour une meilleure sécurité, utilisez une méthode d’authentification qui ne repose pas sur le stockage d’un mot de passe dans la chaîne de connexion. Par exemple, l’authentification Windows pour une base de données SQL Server locale. Pour plus d’informations, consultez Enregistrer et modifier les chaînes de connexion.

Écrire le code pour les formulaires

Cette section contient de brèves présentations de ce que fait chaque formulaire. Il fournit également le code qui définit la logique sous-jacente lorsque vous sélectionnez un bouton sur le formulaire.

Le formulaire de navigation s’ouvre lorsque vous exécutez l’application et inclut les boutons suivants :

Ajouter un compte : ouvre le formulaire NewCustomer .
Remplir ou annuler les commandes : ouvre le formulaire FillOrCancel .
Quitter : ferme l’application.

Pour les projets C# :

Dans l’Explorateur de solutions, ouvrez Program.cs.
Remplacez la Application.Run ligne par : Application.Run(new Navigation());

Pour les projets Visual Basic :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet et choisissez Propriétés.
Dans le Concepteur de projets, sélectionnez l’onglet Application , puis sélectionnez Navigation dans la liste des objets de démarrage .

Pour créer des méthodes de gestionnaire d’événements vides, double-cliquez sur chacun des trois boutons du formulaire de navigation. Double-cliquez sur un bouton pour ajouter du code généré automatiquement dans le fichier de code concepteur, ce qui permet à une sélection de bouton de déclencher un événement.

Si vous décidez de copier et coller du code directement dans vos fichiers de code au lieu d’utiliser l’action double-clic dans le concepteur, veillez à définir le gestionnaire d’événements sur la méthode appropriée :

Dans la fenêtre Propriétés du fichier de code du formulaire, basculez vers l’onglet Événements à l’aide du bouton de barre d’outils lightning bolt.
Recherchez la propriété Click et vérifiez que sa valeur est la méthode de gestionnaire d’événements correcte.

Dans la page de codes du formulaire de navigation, complétez les corps de méthode pour les trois gestionnaires d’événements button-select, comme indiqué dans le code suivant.

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

Formulaire NewCustomer

Lorsque vous entrez un nom de client, puis sélectionnez le bouton Créer un compte , le formulaire NewCustomer crée un compte client et SQL Server retourne une valeur IDENTITY comme nouvel ID client. Vous pouvez ensuite passer une commande pour le nouveau compte en spécifiant un montant et une date de commande, puis en sélectionnant le bouton Passer une commande .

Créer des gestionnaires d’événements générés automatiquement pour le formulaire NewCustomer

Créez un gestionnaire d’événements Click vide pour chaque bouton du formulaire NewCustomer en double-cliquant sur chacun des quatre boutons. Le double-clic sur les boutons ajoute également du code généré automatiquement dans le fichier de code concepteur qui permet à un bouton de sélectionner pour déclencher un événement.

Ajouter du code pour la logique de formulaire NewCustomer

Pour terminer la logique de formulaire NewCustomer, procédez comme suit :

Placez l’espace de noms System.Data.SqlClient dans l’étendue afin que vous n’ayez pas à qualifier pleinement les noms de ses membres.
- C#
- VB
```
using System.Data.SqlClient;
```
```
Imports System.Data.SqlClient
```

Ajoutez des variables et des méthodes d’assistance à la classe.

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

' Storage for ID values returned from the database.  
Private parsedCustomerID As Integer
Private orderID As Integer

''' <summary>
''' Verifies that the customer name text box is not empty.
''' </summary>
Private ReadOnly Property IsCustomerNameValid As Boolean
    Get
        If txtCustomerName.Text = "" Then
            MessageBox.Show("Please enter a name.")
            Return False
        Else
            Return True
        End If
    End Get
End Property

''' <summary>
''' Verifies the order data is valid. 
''' </summary>
Private Function IsOrderDataValid() As Boolean

    ' Verify that CustomerID is present.  
    If txtCustomerID.Text = "" Then
        MessageBox.Show("Please create a customer account before placing order.")
        Return False

        ' Verify that order amount isn't 0.   
    ElseIf (numOrderAmount.Value < 1) Then
        MessageBox.Show("Please specify an order amount.")
        Return False
    Else
        ' Order can be submitted.  
        Return True
    End If
End Function

''' <summary>
''' Clears values from controls.
''' </summary>
Private Sub ClearForm()
    txtCustomerName.Clear()
    txtCustomerID.Clear()
    dtpOrderDate.Value = DateTime.Now
    numOrderAmount.Value = 0
    Me.parsedCustomerID = 0
End Sub

Complétez les corps de méthode pour les quatre gestionnaires d’événements button-select.

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

''' <summary>
''' Creates a new account by executing the Sales.uspNewCustomer
''' stored procedure on the database.
''' </summary>
Private Sub btnCreateAccount_Click(sender As Object, e As EventArgs) Handles btnCreateAccount.Click

    ' Ensure a customer name has been entered.
    If IsCustomerNameValid Then

        ' Create the SqlConnection object. 
        Using connection As New SqlConnection(My.Settings.connString)

            ' Create a SqlCommand, and identify the command type as a stored procedure.  
            Using sqlCommand As New SqlCommand("Sales.uspNewCustomer", connection)
                sqlCommand.CommandType = CommandType.StoredProcedure

                ' Add the customer name input parameter for the stored procedure.  
                sqlCommand.Parameters.Add(New SqlParameter("@CustomerName", SqlDbType.NVarChar, 40))
                sqlCommand.Parameters("@CustomerName").Value = txtCustomerName.Text

                ' Add the customer ID output parameter.  
                sqlCommand.Parameters.Add(New SqlParameter("@CustomerID", SqlDbType.Int))
                sqlCommand.Parameters("@CustomerID").Direction = ParameterDirection.Output

                Try
                    ' Open the connection.  
                    connection.Open()

                    ' Run the stored procedure.  
                    sqlCommand.ExecuteNonQuery()

                    ' Convert the Customer ID value to an Integer.   
                    Me.parsedCustomerID = CInt(sqlCommand.Parameters("@CustomerID").Value)

                    ' Insert the customer ID into the corresponding text box.
                    Me.txtCustomerID.Text = Convert.ToString(parsedCustomerID)
                Catch
                    MessageBox.Show("Customer ID was not returned. Account could not be created.")
                Finally
                    ' Close the connection.  
                    connection.Close()
                End Try
            End Using
        End Using
    End If
End Sub

''' <summary>
''' Places the order by executing the Sales.uspPlaceNewOrder
''' stored procedure on the database.
''' </summary>
Private Sub btnPlaceOrder_Click(sender As Object, e As EventArgs) Handles btnPlaceOrder.Click

    If IsOrderDataValid() Then

        ' Create the connection.  
        Using connection As New SqlConnection(My.Settings.connString)

            ' Create SqlCommand and identify it as a stored procedure.  
            Using sqlCommand As New SqlCommand("Sales.uspPlaceNewOrder", connection)
                sqlCommand.CommandType = CommandType.StoredProcedure

                ' Add the @CustomerID parameter, which was an output parameter from uspNewCustomer.  
                sqlCommand.Parameters.Add(New SqlParameter("@CustomerID", SqlDbType.Int))
                sqlCommand.Parameters("@CustomerID").Value = Me.parsedCustomerID

                ' Add the @OrderDate parameter.  
                sqlCommand.Parameters.Add(New SqlParameter("@OrderDate", SqlDbType.DateTime, 8))
                sqlCommand.Parameters("@OrderDate").Value = dtpOrderDate.Value

                ' Add the @Amount parameter.  
                sqlCommand.Parameters.Add(New SqlParameter("@Amount", SqlDbType.Int))
                sqlCommand.Parameters("@Amount").Value = numOrderAmount.Value

                ' Add the @Status 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 a return value parameter for the stored procedure, which is the orderID.  
                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.  
                    Me.orderID = CInt(sqlCommand.Parameters("@RC").Value)
                    MessageBox.Show("Order number " & (Me.orderID).ToString & " has been submitted.")
                Catch
                    ' A simple catch.  
                    MessageBox.Show("Order could  not be placed.")
                Finally
                    ' Always close a connection after you finish using it,
                    ' so that it can be released to the connection pool.
                    connection.Close()
                End Try
            End Using
        End Using
    End If
End Sub

''' <summary>
''' Resets the form for another new account.
''' </summary>
Private Sub btnAddAnotherAccount_Click(sender As Object, e As EventArgs) Handles btnAddAnotherAccount.Click
    Me.ClearForm()
End Sub

''' <summary>
''' Closes the NewCustomer form and returns focus to the Navigation form.
''' </summary>
Private Sub btnAddFinish_Click(sender As Object, e As EventArgs) Handles btnAddFinish.Click
    Me.Close()
End Sub

Formulaire FillOrCancel

Le formulaire FillOrCancel exécute une requête pour retourner une commande lorsque vous entrez un ID de commande, puis sélectionnez le bouton Rechercher l’ordre . La ligne retournée apparaît dans une grille de données en lecture seule. Vous pouvez marquer la commande comme annulée (X) si vous sélectionnez le bouton Annuler la commande , ou vous pouvez marquer l’ordre comme rempli (F) si vous sélectionnez le bouton Ordre de remplissage . Si vous sélectionnez à nouveau le bouton Rechercher l’ordre , la ligne mise à jour s’affiche.

Créer des gestionnaires d’événements générés automatiquement pour le formulaire FillOrCancel

Créez des gestionnaires d’événements Click vides pour les quatre boutons du formulaire FillOrCancel en double-cliquant sur les boutons. Le double-clic sur les boutons ajoute également du code généré automatiquement dans le fichier de code concepteur qui permet à un bouton de sélectionner pour déclencher un événement.

Ajouter du code pour la logique de formulaire FillOrCancel

Pour terminer la logique de formulaire FillOrCancel, procédez comme suit.

Placez les deux espaces de noms suivants dans l’étendue afin que vous n’ayez pas à qualifier pleinement les noms de leurs membres.
- C#
- VB
```
using System.Data.SqlClient;
using System.Text.RegularExpressions;
```
```
Imports System.Data.SqlClient
Imports System.Text.RegularExpressions
```

Ajoutez une variable et une méthode d’assistance à la classe.

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

' Storage for OrderID.  
Private parsedOrderID As Integer

''' <summary>
''' Verifies that OrderID is valid.
''' </summary>
Private Function IsOrderIDValid() As Boolean

    ' Check for input in the Order ID text box.  
    If txtOrderID.Text = "" Then
        MessageBox.Show("Please specify the Order ID.")
        Return False

        ' Check for characters other than integers.  
    ElseIf Regex.IsMatch(txtOrderID.Text, "^\D*$") Then
        ' Show message and clear input.  
        MessageBox.Show("Please specify integers only.")
        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
    End If
End Function

Complétez les corps de méthode pour les quatre gestionnaires d’événements button-select.

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

''' <summary>
''' Executes a t-SQL SELECT query on the database to
''' obtain order data for a specified order ID.
''' </summary>
Private Sub btnFindByOrderID_Click(sender As Object, e As EventArgs) Handles btnFindByOrderID.Click

    ' Prepare the connection and the command.
    If IsOrderIDValid() Then

        ' Create the connection.  
        Using connection As New SqlConnection(My.Settings.connString)

            ' Define the query string that has a parameter for orderID.  
            Const sql As String = "select * from Sales.Orders where orderID = @orderID"

            ' Create a SqlCommand object.  
            Using sqlCommand As New SqlCommand(sql, connection)

                ' Define the @orderID parameter and its value.  
                sqlCommand.Parameters.Add(New SqlParameter("@orderID", SqlDbType.Int))
                sqlCommand.Parameters("@orderID").Value = parsedOrderID

                Try
                    ' Open connection.  
                    connection.Open()

                    ' Execute the query.  
                    Dim dataReader As SqlDataReader = sqlCommand.ExecuteReader()

                    ' Create a data table to hold the retrieved data.  
                    Dim dataTable As 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.  
                    Me.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()
                End Try
            End Using
        End Using
    End If
End Sub

''' <summary>
''' Fills an order by running the Sales.uspFillOrder stored procedure on the database.
''' </summary>
Private Sub btnFillOrder_Click(sender As Object, e As EventArgs) Handles btnFillOrder.Click

    ' Set up and run stored procedure only if OrderID is valid.  
    If IsOrderIDValid() Then

        ' Create the connection. 
        Using connection As New SqlConnection(My.Settings.connString)

            ' Create command and identify it as a stored procedure.  
            Using sqlCommand As New SqlCommand("Sales.uspFillOrder", connection)

                sqlCommand.CommandType = CommandType.StoredProcedure

                ' Add input parameter for the stored procedure.  
                sqlCommand.Parameters.Add(New SqlParameter("@orderID", SqlDbType.Int))
                sqlCommand.Parameters("@orderID").Value = parsedOrderID

                ' Add second input parameter.  
                sqlCommand.Parameters.Add(New SqlParameter("@FilledDate", SqlDbType.DateTime, 8))
                sqlCommand.Parameters("@FilledDate").Value = dtpFillDate.Value

                Try
                    ' Open the connection.  
                    connection.Open()

                    ' Run the SqlCommand.   
                    sqlCommand.ExecuteNonQuery()
                Catch
                    ' A simple catch.  
                    MessageBox.Show("The fill operation was not completed.")
                Finally
                    ' Close the connection.  
                    connection.Close()
                End Try
            End Using
        End Using
    End If
End Sub

''' <summary>
''' Cancels an order by running the Sales.uspCancelOrder stored procedure on the database.
''' </summary>
Private Sub btnCancelOrder_Click(sender As Object, e As EventArgs) Handles btnCancelOrder.Click

    ' Set up and run the stored procedure only if OrderID is ready.  
    If IsOrderIDValid() Then

        ' Create the connection. 
        Using connection As New SqlConnection(My.Settings.connString)

            ' Create the command and identify it as a stored procedure.  
            Using sqlCommand As New SqlCommand("Sales.uspCancelOrder", connection)
                sqlCommand.CommandType = CommandType.StoredProcedure

                ' Add 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 SqlCommand.  
                    sqlCommand.ExecuteNonQuery()
                Catch
                    ' A simple catch.  
                    MessageBox.Show("The cancel operation was not completed.")
                Finally
                    ' Close connection.  
                    connection.Close()
                End Try
            End Using
        End Using
    End If
End Sub

''' <summary>
''' Closes the form and returns focus to the Navigation form.
''' </summary>
Private Sub btnFinishUpdates_Click(sender As Object, e As EventArgs) Handles btnFinishUpdates.Click
    Me.Close()
End Sub

Tester votre application

Exécutez l’application et essayez de créer quelques clients et commandes pour vérifier que tout fonctionne comme prévu.

Pour vérifier que la base de données est mise à jour avec vos modifications :

Ouvrez le nœud Tables dans l’Explorateur de serveurs.
Cliquez avec le bouton droit sur les nœuds Clients et Commandes , puis choisissez Afficher les données de table.

Outils de données Visual Studio pour .NET

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-12-12

Partager via