Base de données d'exploitation de développement C # (15.6)

I. Aperçu

Dans la section précédente Connexion C #, nous avons expliqué la méthode du langage C # pour se connecter à la base de données. Après avoir établi une connexion avec la base de données, vous pouvez commencer à faire fonctionner les objets dans la base de données.
Pour faire fonctionner la base de données, vous devez utiliser les propriétés et les méthodes fournies dans la classe Command. Voici comment utiliser la classe Command pour manipuler les données dans la table de données

<! - plus ->

Vue d'ensemble de la classe de commande

Sous l'espace de noms System.Data.SqlClient, la classe Command correspondante est SqlCommand et la connexion à la base de données doit avoir été créée avant de créer l'instance SqlCommand.

2.1 Méthodes de construction courantes

Méthode de construction	La description
SqlCommand ()	Méthode de construction sans paramètre
SqlCommand (chaîne commandText, SqlConnection conn)	La méthode de construction avec paramètres, le premier paramètre est l'instruction SQL à exécuter et le second paramètre est l'objet de connexion de la base de données

2.2 Attributs et méthodes communs

Les opérations sur les objets de la base de données incluent non seulement les opérations sur les tables de données, mais également les opérations sur les objets de la base de données tels que les bases de données, les vues et les procédures stockées. Ensuite, nous introduirons principalement les opérations sur les tables de données et les procédures stockées.

Lorsqu'elle fonctionne sur différents objets de base de données, la classe SqlCommand fournit différentes propriétés et méthodes. Les propriétés et méthodes couramment utilisées sont indiquées dans le tableau suivant

Attribut ou méthode	La description
CommandText	Propriété, instruction SQL à exécuter dans l'objet Command
Lien	Propriétés, obtenir ou définir l'objet de connexion de la base de données
CommandType	Propriété, obtenir ou définir le type de commande
Paramètres	Propriétés, définissez les paramètres de l'instruction SQL dans l'objet Command
ExecuteReader ()	Méthode pour obtenir le résultat de l'exécution de l'instruction de requête
ExécuterScalaire ()	Méthode pour renvoyer la valeur de la première ligne et de la première colonne du résultat de la requête
ExecuteNonQuery ()	Méthode pour effectuer des opérations d'ajout, de suppression et de modification de tables de données

Trois utilisent la classe Command pour faire fonctionner la base de données

Trois types de commandes sont fournis dans la classe Command, à savoir Text, TableDirect et StoredProcedure, qui sont Text par défaut.
Le type appelé Texte fait référence à la forme d'utilisation des instructions SQL, y compris des instructions SQL pour l'ajout, la suppression, la modification et l'interrogation.
StoredProcedure est utilisé pour exécuter des procédures stockées; TableDirect n'est valide que dans les pilotes OLE DB
Vous devez effectuer les étapes suivantes lors de l'utilisation de la classe Command pour faire fonctionner la base de données

3.1 Créer une instance de la classe SqlCommand

Il existe deux situations pour créer une instance de la classe SqlCommand, l'une est le type de commande est Texte, l'autre est le type de commande est StoredProcedure.

3.1.1 Le type de commande est Texte

SqlCommand Nom de l'instance de la classe SqlCommand = new SqlCommand (instruction SQL, instance de la classe de connexion à la base de données);

parmi eux:

Instruction SQL: fait référence à l'instruction SQL à exécuter par l'instance de la classe SqlCommand
L'instance de la classe de connexion à la base de données: fait référence à l'instance créée à l'aide de la classe SqlConnection, généralement l'instance de la classe de connexion à la base de données est dans un état ouvert

3.1.2 Le type de commande est StoredProcedure

SqlCommand SqlCommand class instance name = new SqlCommand (nom de procédure stockée, instance de la classe de connexion à la base de données);

doit être conscient de:

La procédure stockée doit être une procédure stockée dans l'instance de base de données actuelle, et lors de l'appel d'une procédure stockée avec des paramètres, vous devez également ajouter les paramètres de procédure stockée correspondants dans l'instance de la classe SqlCommand

Pour ajouter des paramètres à la procédure stockée, vous devez utiliser la propriété Parameters de l'instance de classe SqlCommand pour définir le code spécifique comme suit

Instance de classe SqlCommand Parameters.Add (nom du paramètre, valeur du paramètre);

Ici, le nom du paramètre doit être cohérent avec le nom du paramètre défini dans la procédure stockée

3.2 Effectuer des opérations sur la table de données

Il existe généralement deux situations lors de l'exécution d'opérations sur des tables de données: l'une consiste à exécuter des instructions SQL sans requête, c'est-à-dire à ajouter, modifier et supprimer des opérations, et l'autre à exécuter des instructions SQL de requête.

3.2.1 Opérations qui exécutent des instructions SQL sans requête

Lors de l'exécution d'une instruction SQL sans requête, vous n'avez pas besoin de renvoyer les données de la table. Vous pouvez utiliser directement la méthode ExecuteNonQuery de la classe SqlCommand. La valeur de retour de cette méthode est un entier, qui est utilisé pour renvoyer les données de la table après l'exécution de l'instruction SQL par la classe SqlCommand. Nombre de lignes affectées

Lorsque la valeur de retour de cette méthode est -1, cela signifie que l'instruction SQL n'a pas pu s'exécuter. Lorsque la valeur de retour de cette méthode est 0, cela signifie que l'instruction SQL n'a aucun effet sur les données de la table de données actuelle.

Par exemple, si vous souhaitez supprimer les informations de l'étudiant dont l'ID étudiant est 1100 et les informations de l'étudiant dont l'ID étudiant n'existe pas dans la table, l'instruction SQL peut être exécutée normalement, mais le nombre de lignes affectées dans la table est 0

Une instance de la classe SqlCommand.ExecuteNonQuery ();

Il convient de noter que si l'instruction SQL exécutée est exécutée de manière incorrecte dans la base de données, une exception sera générée, donc cette partie nécessite la gestion des exceptions

3.2.2 Exécuter l'opération de l'instruction de requête

Le résultat de la requête est généralement renvoyé lorsque l'instruction de requête est exécutée. La méthode ExecuteReader fournie dans la classe SqlCommand renvoie une valeur de type SqlDataReader après l'exécution de l'instruction SQL de requête. La valeur de retour peut être obtenue en parcourant les résultats dans la classe SqlDataReader.

Le code spécifique est le suivant

SqlDataReader dr = instance de la classe SqlCommand.ExecuteReader ();

En outre, si vous n'avez pas besoin de renvoyer tous les résultats de la requête après l'exécution de l'instruction de requête, mais que vous devez uniquement renvoyer une valeur, telle que le nombre de lignes dans la table de requête, vous pouvez utiliser la méthode ExecuteScalar. Le code spécifique est le suivant.

int returnvalue = instance de la classe SqlCommand.ExecuteScalar ();

Cinq exemples (voir 15.5 pour la création de tableaux)

5.1 Exemple 1: créer une interface d'enregistrement utilisateur, utiliser la classe SqlCommand pour ajouter un enregistrement à la table d'informations utilisateur

5.1.1 Image d'effet

5.1.2 Code

  // Événement de clic sur le bouton "Enregistrer"
  private void button1_Click (expéditeur de l'objet, EventArgs e)
  {
      // Ecrire la chaîne de connexion à la base de données
      string connStr = "Source de données = .; Catalogue initial = test; ID utilisateur = sa; Mot de passe = racine";
      // Créer une instance de SqlConnection
      SqlConnection conn = null;
      essayer
      {
          conn = new SqlConnection (connStr);
          // Ouvre la connexion à la base de données
          conn.Open ();
          string sql = "insérer dans les valeurs userinfo (nom, mot de passe) ('{0}', '{1}')";
          // Remplissez l'instruction SQL
          sql = string.Format (sql, textBox1.Text, textBox2.Text);
          // Créer un objet SqlCommand
          SqlCommand cmd = new SqlCommand (sql, conn);
          // Exécuter une instruction SQL
          int returnvalue = cmd.ExecuteNonQuery ();
          // Détermine si l'instruction SQL est exécutée avec succès
          if (valeur de retour! = -1)
          {
              MessageBox.Show ("Enregistré avec succès!");
          }
      }
      catch (Exception ex)
      {
          MessageBox.Show ("L'enregistrement a échoué!" + Ex.Message);
      }
      enfin
      {
          si (conn! = null)
          {
              // Ferme la connexion à la base de données
              conn.Close ();
          }
      }
  }

5.2 Exemple 2 Créez une interface de connexion, utilisez la classe SqlCommand pour déterminer si l'utilisateur s'est connecté avec succès

5.2.1 Image d'effet

5.2.2 Code

  // Événement de clic sur le bouton "Connexion"
  private void button1_Click (expéditeur de l'objet, EventArgs e)
  {
      // Ecrire la chaîne de connexion à la base de données
      string connStr = "Source de données = .; Catalogue initial = test; ID utilisateur = sa; Mot de passe = racine";
      // Créer une instance de SQLConnection
      SqlConnection conn = null;
      essayer
      {
          conn = new SqlConnection (connStr);
          // Ouvre la connexion à la base de données
          conn.Open ();
          string sql = "Sélectionnez count (*) depuis userinfo où name = '{0}' et password = '{1}'";
          // Remplissez l'instruction SQL
          sql = string.Format (sql, textBox1.Text, textBox2.Text);
          // Créer un objet SqlCommand
          SqlCommand cmd = new SqlCommand (sql, conn);
          // Exécuter une instruction SQL
          int returnvalue = (int) cmd.ExecuteScalar ();
          // Détermine si l'instruction SQL est exécutée avec succès
          if (valeur de retour! = 0)
          {
              MessageBox.Show ("Connexion réussie!");
          }
          autre
          {
              MessageBox.Show ("La connexion a échoué!");
          }
      }
      catch (Exception ex)
      {
          MessageBox.Show ("L'enregistrement a échoué!" + Ex.Message);
      }
      enfin
      {
          si (conn! = null)
          {
              // Ferme la connexion à la base de données
              conn.Close ();
          }
      }
  }
  // Événement de clic sur le bouton "Annuler"
  private void button2_Click (expéditeur de l'objet, EventArgs e)
  {
      this.Close ();
  }

5.3 Exemple 3 Améliorer la fonction d'enregistrement de l'utilisateur pour rendre le nom d'utilisateur unique lors de l'enregistrement

5.3.1 Image d'effet

5.3.2 Code

  // Événement de clic sur le bouton "Enregistrer"
  private void button1_Click (expéditeur de l'objet, EventArgs e)
  {
      // Ecrire la chaîne de connexion à la base de données
      string connStr = "Source de données = .; Catalogue initial = test; ID utilisateur = sa; Mot de passe = racine";
      // Créer une instance de SqlConnection
      SqlConnection conn = null;
      essayer
      {
          conn = new SqlConnection (connStr);
          // Ouvre la connexion à la base de données
          conn.Open ();
          // Détermine si le nom d'utilisateur est répété
          string checkNameSql = "sélectionnez count (*) dans userinfo où name = '{0}'";
          checkNameSql = string.Format (checkNameSql, textBox1.Text);
          // Créer un objet SqlCommand
          SqlCommand cmdCheckName = new SqlCommand (checkNameSql, conn);
          // Exécuter une instruction SQL
          int isRepeatName = (int) cmdCheckName.ExecuteScalar ();
          if (isRepeatName! = 0)
          {
              // Si le nom d'utilisateur est dupliqué, l'opération d'enregistrement ne sera pas effectuée
              MessageBox.Show ("Le nom d'utilisateur existe déjà!");
              revenir;
          }
          string sql = "insérer dans les valeurs userinfo (nom, mot de passe) ('{0}', '{1}')";
          // Remplissez l'instruction SQL
          sql = string.Format (sql, textBox1.Text, textBox2.Text);
          // Créer un objet SqlCommand
          SqlCommand cmd = new SqlCommand (sql, conn);
          // Exécuter une instruction SQL
          int returnvalue = cmd.ExecuteNonQuery ();
          // Détermine si l'instruction SQL est exécutée avec succès
          if (valeur de retour! = -1)
          {
              MessageBox.Show ("Enregistré avec succès!");
          }
      }
      catch (Exception ex)
      {
          MessageBox.Show ("L'enregistrement a échoué!" + Ex.Message);
      }
      enfin
      {
          si (conn! = null)
          {
              // Ferme la connexion à la base de données
              conn.Close ();
          }
      }
  }

5.4 Exemple 4 Créer une procédure stockée pour réaliser la fonction d'enregistrement d'utilisateur et utiliser la classe SqlCommand pour appeler la procédure stockée

5.4.1 Analyse fonctionnelle

La procédure stockée de la fonction d'enregistrement utilisateur est relativement simple. Il vous suffit d'écrire une procédure stockée avec des paramètres pour transmettre le nom d'utilisateur et le mot de passe à la procédure stockée, et d'utiliser l'instruction insert pour ajouter le nom d'utilisateur et le mot de passe à la table d'informations utilisateur

5.4.2 Instruction pour créer une procédure stockée

存储过程Cliquez avec le bouton droit sur la base de données 添加存储过程, dans dbo.Procedure.sql, remplissez l'instruction de procédure stockée et mettez à jour

5.4.3 Code

// Ecrire la chaîne de connexion à la base de données
string connStr = "Source de données = .; Catalogue initial = test; ID utilisateur = sa; Mot de passe = racine";
// Créer une instance de SqlConnection
SqlConnection conn = null;
essayer
{
    conn = new SqlConnection (connStr);
    // Ouvre la connexion à la base de données
    conn.Open ();
    // Créer un objet SqlCommand
    SqlCommand cmd = new SqlCommand ("AddUser", conn);
    // Définit le type de commande (CommandType) de l'objet SQLCommand comme une procédure stockée
    cmd.CommandType = CommandType.StoredProcedure;
    // Définit les paramètres requis par la procédure stockée
    cmd.Parameters.AddWithValue ("nom", textBox1.Text);
    cmd.Parameters.AddWithValue ("mot de passe", textBox2.Text);
    // Exécute la procédure stockée
    int returnvalue = cmd.ExecuteNonQuery ();
    Console.WriteLine (valeur de retour);
    // Détermine si l'instruction SQL est exécutée avec succès
    if (valeur de retour! = -1)
    {
        MessageBox.Show ("Enregistré avec succès!");
    }
}
catch (Exception ex)
{
    MessageBox.Show ("L'enregistrement a échoué!" + Ex.Message);
}
enfin
{
    si (conn! = null)
    {
        // Ferme la connexion à la base de données
        conn.Close ();
    }
}

5.4.4 Description

Exécutez le formulaire, l'effet est cohérent avec l'exemple 1. Comme le montre le code ci-dessus, l'appel de la procédure stockée n'est pas compliqué, changez simplement la valeur de la propriété CommandType dans l'objet SqlCommand en StoredProcedure et ajoutez les paramètres nécessaires dans la procédure stockée.