Partager via

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

  • Article

Remarque

Les jeux de données 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 très réussie, nous recommandons que les nouvelles applications .NET utilisent Entity Framework Core. Entity Framework offre un moyen plus naturel d’utiliser des données tabulaires en tant que modèles objet et offre 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 des tâches de base telles que la définition de chaînes de connexion, l’insertion de données et l’exécution de procédures stockées. En suivant cette rubrique, vous pouvez découvrir comment interagir avec une base de données à partir d’une application « formulaires sur des données » Windows Forms simple à l’aide de Visual C# ou Visual Basic et de ADO.NET. Toutes les technologies de données .NET, y compris les jeux de données, LINQ to SQL et Entity Framework, effectuent finalement des étapes très similaires à celles présentées dans cet article.

Cet article montre un moyen simple d’extraire rapidement des données d’une base de données. Si votre application doit modifier des données de manière nontriviale et mettre à jour la base de données, vous devez envisager d’utiliser Entity Framework et d’utiliser la liaison de données pour synchroniser automatiquement les contrôles d’interface utilisateur pour modifier les données sous-jacentes.

Important

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

Remarque

Le code complet de ce didacticiel est accessible dans le référentiel GitHub de Visual Studio docs dans C# et Visual Basic.

Conditions préalables

Pour créer l’application, vous avez besoin des éléments suivants :

  • 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 (ou Plus>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 .

Cette rubrique suppose que vous connaissez les fonctionnalités de base de l’IDE Visual Studio et que vous pouvez créer une application Windows Forms, ajouter des formulaires au projet, placer des boutons et d’autres contrôles sur les formulaires, définir les propriétés des contrôles et coder des événements simples. Si vous n’êtes pas à l’aise avec ces tâches, nous vous suggérons de suivre les Créer une application Windows Forms dans Visual Studio avec Visual Basic didacticiel ou le didacticiel Créer une application Windows Forms dans Visual Studio avec C# tutoriel 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 :

  1. Dans Visual Studio, ouvrez la fenêtre de l’Explorateur de serveurs.

  2. Cliquez avec le bouton droit sur connexions de données, puis choisissez Créer une base de données SQL Server.

  3. Dans la zone de texte nom du serveur, entrez (localdb)\mssqllocaldb.

  4. Dans la zone de texte Nouveau nom de base de données, entrez Ventes, puis choisissez OK.

    La base de données Sales vide est créée et ajoutée au nœud Connexions de données dans l'Explorateur de serveur.

  5. Faites un clic droit sur la connexion de données Ventes et sélectionnez Nouvelle requête.

    Une fenêtre de l’éditeur de requête s’ouvre.

  6. Copiez le script Ventes Transact-SQL dans votre Presse-papiers.

  7. Collez le script T-SQL dans l’éditeur de requête, puis choisissez le bouton 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 quatre procédures stockées simples.

Créer les formulaires et ajouter des contrôles

  1. Créez un projet C# ou Visual Basic à l’aide du modèle application Windows Forms (.NET Framework), puis nommez-le SimpleDataApp.

    Visual Studio crée le projet et plusieurs fichiers, y compris un formulaire Windows vide nommé Form1.

  2. Ajoutez deux formulaires Windows à votre projet afin qu’il dispose de trois formulaires, puis donnez-leur les noms suivants :

    • Navigation

    • NouveauClient

    • FillOrCancel

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

    Remarque

    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

    boîte de dialogue navigation

Contrôles du formulaire de navigation Propriétés
Bouton Name = btnGoToAdd
Bouton Name = btnGoToFillOrCancel
Bouton Name = btnExit

Formulaire NewCustomer

Ajouter un nouveau client et passer une commande

Contrôles pour le formulaire NewCustomer Propriétés
Zone de texte Name = txtCustomerName
Zone de texte Name = txtCustomerID

Readonly = True
Bouton Name = btnCreateAccount
NumericUpdown DecimalPlaces = 0

Maximum = 5000

Name = numOrderAmount
DateTimePicker Format = Short

Name = dtpOrderDate
Bouton Name = btnPlaceOrder
Bouton Name = btnAddAnotherAccount
Bouton Name = btnAddFinish

Formulaire FillOrCancel

remplir ou annuler des commandes

Contrôles du formulaire FillOrCancel Propriétés
Zone de texte Name = txtOrderID
Bouton Name = btnFindByOrderID
DateTimePicker Format = Short

Name = dtpFillDate
DataGridView Name = dgvCustomerOrders

Readonly = True

RowHeadersVisible = False
Bouton Name = btnCancelOrder
Bouton Name = btnFillOrder
Bouton 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’entrer la chaîne manuellement sur chaque formulaire, stockez la chaîne dans le fichier App.config dans votre projet et créez une méthode qui retourne la chaîne lorsque la méthode est appelée à partir de n’importe quel formulaire de votre application.

Vous trouverez la chaîne de connexion en faisant un clic droit sur la connexion de données Ventes dans Explorateur de serveurs et en choisissant Propriétés. Recherchez la propriété ConnectionString, puis utilisez Ctrl+A, Ctrl+C pour sélectionner et copier la chaîne dans le Presse-papiers.

  1. Si vous utilisez C#, dans Explorateur de solutions, développez le nœud Propriétés sous le projet, puis ouvrez le fichier Settings.settings. Si vous utilisez Visual Basic, dans explorateur de solutions, cliquez sur Afficher tous les fichiers, développez le nœud Mon projet, puis ouvrez le fichier Settings.settings.

  2. Dans la colonne Nom, entrez connString.

  3. Dans la liste Type, sélectionnez (Chaîne de connexion).

  4. Dans la liste Étendue, sélectionnez Application.

  5. Dans la colonne Valeur, entrez votre chaîne de connexion (sans guillemets extérieurs), puis enregistrez vos modifications.

    capture d’écran Capture d’écran de la chaîne de connexion dans Settings.settings

Attention

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, telle que l’authentification Windows pour une base de données SQL Server locale. 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 lorsqu’un bouton sur le formulaire est cliqué.

Le formulaire de navigation s’ouvre lorsque vous exécutez l’application. Le bouton Ajouter un compte ouvre le formulaire NewCustomer. Le bouton Remplir ou annuler les commandes ouvre le formulaire FillOrCancel. Le bouton Quitter ferme l’application.

Faire du formulaire de navigation le formulaire de démarrage

Si vous utilisez C#, dans Explorateur de solutions, ouvrez Program.cs, puis remplacez la ligne Application.Run par celle-ci : Application.Run(new Navigation());

Si vous utilisez Visual Basic, dans Explorateur de solutions, ouvrez la fenêtre Propriétés, sélectionnez l’onglet Application, puis sélectionnez SimpleDataApp.Navigation dans la liste formulaire de démarrage.

Créer des gestionnaires d’événements générés automatiquement

Double-cliquez sur les trois boutons du formulaire de navigation pour créer des méthodes de gestionnaire d’événements vides. 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 cliquer pour déclencher un événement.

Remarque

Si vous passez l’action de double-clic dans l'interface de conception et que vous copiez simplement le code puis le collez dans vos fichiers de code, n’oubliez pas de définir le gestionnaire d’événements à la bonne méthode. Vous pouvez le faire dans la fenêtre Propriétés. Basculez vers l’onglet Événements (utilisez le bouton de barre d’outils éclair) et recherchez le gestionnaire Clic.

Ajouter du code pour la logique de formulaire de navigation

Dans la page de codes du formulaire de navigation, complétez les corps de méthode pour les trois gestionnaires d’événements button-click, 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();
}

Remarque

Le code de ce didacticiel est disponible en C# et En Visual Basic. Pour basculer la langue du code sur cette page entre C# et Visual Basic, utilisez le sélecteur de langage de code en haut de chaque exemple de code.

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 et en sélectionnant le bouton Passer une commande.

Créer des gestionnaires d’événements générés automatiquement

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

  1. Placez l’espace de noms System.Data.SqlClient dans l’étendue afin que vous n’ayez pas à qualifier pleinement les noms de ses membres.

    using System.Data.SqlClient;

  2. Ajoutez certaines variables et méthodes d’assistance à la classe, comme indiqué dans le code suivant.

    // Storage for IDENTITY values returned from database.
private int parsedCustomerID;
private int orderID;

/// <summary>
/// Verifies that the customer name text box is not empty.
/// </summary>
private bool IsCustomerNameValid()
{
    if (txtCustomerName.Text == "")
    {
        MessageBox.Show("Please enter a name.");
        return false;
    }
    else
    {
        return true;
    }
}

/// <summary>
/// Verifies that a customer ID and order amount have been provided.
/// </summary>
private bool IsOrderDataValid()
{
    // Verify that CustomerID is present.
    if (txtCustomerID.Text == "")
    {
        MessageBox.Show("Please create customer account before placing order.");
        return false;
    }
    // Verify that Amount isn't 0.
    else if ((numOrderAmount.Value < 1))
    {
        MessageBox.Show("Please specify an order amount.");
        return false;
    }
    else
    {
        // Order can be submitted.
        return true;
    }
}

/// <summary>
/// Clears the form data.
/// </summary>
private void ClearForm()
{
    txtCustomerName.Clear();
    txtCustomerID.Clear();
    dtpOrderDate.Value = DateTime.Now;
    numOrderAmount.Value = 0;
    this.parsedCustomerID = 0;
}

  3. Complétez les corps de méthode pour les quatre gestionnaires d’événements de clic sur le bouton, comme indiqué dans le code suivant.

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

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 la commande comme renseignée (F) si vous sélectionnez le bouton Commande 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

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

  1. Placez les deux espaces de noms suivants dans l’étendue afin que vous n’ayez pas à qualifier pleinement les noms de leurs membres.

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

  2. Ajoutez une variable et une méthode d’assistance à la classe, comme indiqué dans le code suivant.

    // Storage for the order ID value.
private int parsedOrderID;

/// <summary>
/// Verifies that an order ID is present and contains valid characters.
/// </summary>
private bool IsOrderIDValid()
{
    // Check for input in the Order ID text box.
    if (txtOrderID.Text == "")
    {
        MessageBox.Show("Please specify the Order ID.");
        return false;
    }

    // Check for characters other than integers.
    else if (Regex.IsMatch(txtOrderID.Text, @"^\D*$"))
    {
        // Show message and clear input.
        MessageBox.Show("Customer ID must contain only numbers.");
        txtOrderID.Clear();
        return false;
    }
    else
    {
        // Convert the text in the text box to an integer to send to the database.
        parsedOrderID = Int32.Parse(txtOrderID.Text);
        return true;
    }
}

  3. Complétez les corps de méthode pour les quatre gestionnaires d’événements de clic sur le bouton, comme indiqué dans le code suivant.

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

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 Explorateur de serveurs, cliquez avec le bouton droit sur les Clients et Commandes nœuds, puis choisissez Afficher les données de table.

Contenu connexe