Connexion à une base de données en C # – Serveur d’impression

se connecter

La première étape est donc la connexion. Cela nécessite deux choses:

• Le pilote de la base de données
• La chaîne de connexion

Les deux peuvent être trouvés sur ce site: www.connectionstrings.com. Cependant, si par exemple vous utilisez une base de données SQL Server, les pilotes sont inclus. Voici également la chaîne de connexion de base pour une telle base de données:

"Data Source = ServerAddress; Initial Catalog = DatabaseName; User Id = UserName; Password = Password;"
// Vous devez évidemment remplacer ServerAddress, DatabaseName, etc. par la valeur correspondante

Pour créer la connexion, nous utilisons la classe SqlConnection (dont l'espace de noms (et peut-être le préfixe) changera en fonction de votre pilote). Pour SQL Server, l'espace de noms est System.Data.SqlClient.

SqlConnection myConnection = new SqlConnection ("Source de données = 127.0.0.1,1433; Catalogue initial = MaBase; ID utilisateur = Krimog; Mot de passe = myPass;");

Une fois la connexion créée, vous pouvez l'ouvrir:

myConnection.Open ();

Cette dernière ligne peut évidemment générer une exception si, par exemple, la chaîne de connexion est mauvaise. Vous devrez également fermer la connexion en utilisant l'instruction:

myConnection.Close ();

Créer la requête

Pour cela, nous allons utiliser la classe SqlCommand, indiquer la connexion et la requête:

SqlCommand myCommand = new SqlCommand ();
myOrder.Connection = myConnection;
myOrder.CommandText = "INSÉRER DANS LES VALEURS myTable (myControl1, myControl2) ("
                       + myInt + ", & # 39;" + monstring + "& # 39;);";

Voici un moyen simple de créer et d'initialiser un objet SqlCommand.

Exécuter une requête (sauf SELECT)

La première question à vous poser est: ma requête renverra-t-elle une valeur? C'est très simple, tout dépend de la requête: une requête SELECT renvoie des données, mais pas les autres requêtes (INSERT, UPDATE, DELETE).
Commençons par quelque chose de simple: SUPPRIMER. Nous utiliserons donc la méthode ExecuteNonQuery (). Cela renvoie le nombre d'enregistrements affectés par la demande:

myOrder.CommandText = "SUPPRIMER DE maTable O id < " + monInt;
int nbEnregistrementsAffectes = maCommande.ExecuteNonQuery();
if (nbEnregistrementsAffectes > 0)

    Console.WriteLine (nbAffectsRecords + "enregistrements supprimés");

autre

    Console.WriteLine ("Aucun enregistrement supprimé");

Là encore, la méthode ExecuteNonQuery () peut générer une exception, par exemple si la requête n'est pas valide ou si la connexion n'est pas ouverte.

Exécuter une requête SELECT

Là, les choses se compliquent un peu. Tout simplement parce que vous devez gérer le contenu de la demande. Il existe cependant une méthode simple pour récupérer 1 résultat (donc 1 colonne de 1 ligne): ExecuteScalar ().

myOrder.CommandText = "SELECT CustomerName FROM Clients WHERE CustomerID =" + myInt;
chaîne CustomerName = myOrder.ExecuteScalar (). ToString ();
Console.WriteLine ("Mon client s'appelle" + clientName);

Pour être précis, la méthode ExecuteScalar () retourne un objet, d'où l'intérêt du ToString () derrière.

Imaginez maintenant que vous disposez de nombreux champs et de nombreux enregistrements. Vous devrez alors utiliser un SqlDataReader:

myOrder.CommandText = "SELECT CustomerName, CustomerName FROM Clients";
SqlDataReader myReader = myOrder.ExecuteReader ();
while (myReader.Read ()) // Tant qu'il y a des résultats, je lis le suivant

    Console.WriteLine (myReader["PrenomClient"].ToString () + "" + myReader["NomClient"].ToString ());
    // ou
    Console.WriteLine (myReader[1].ToString () + "" + myReader[0].ToString ());
    // ou
    Console.WriteLine (myReader.GetString (1) + "" + myReader.GetString (0));

myReader.Close (); // Nous n'oublions pas de fermer le lecteur

Il existe une dernière solution qui consiste à insérer le résultat de la requête dans un DataSet grâce à un SqlDataAdapter. Cependant, n'ayant pas beaucoup testé ce système, je ne m'y attarderai pas longtemps.

DataSet myClients = new DataSet ();
myOrder.CommandText = "SELECT CustomerName, CustomerName FROM Customers";
SqlDataAdapter monAdapter = nouveau SqlDataAdapter ();
myAdapter.SelectCommand = myOrder;
myAdapter.Fill (myCustomers);
// L'ensemble de données myCustomers est ensuite renseigné

Requêtes paramétrées

Voici donc quelque chose de très simple, mais pas assez utilisé. En général, une requête n'a d'intérêt que si certaines valeurs sont des variables. Mais dans l'exemple précédent d'INSERT, on voit tout de suite que ce n'est pas simple. De plus, il est possible de faire une injection SQL dans cette requête. Voici 2 problèmes qui sont résolus simplement en utilisant des requêtes paramétrées: simplicité et sécurité.
La première étape consiste à définir où intégrer les variables dans la requête, et la seconde donne les valeurs aux variables.

// On remplace les valeurs par @aNom, sans jamais mettre & # 39; autour
myCommand.CommandText = "INSÉRER DANS maTable (myControl1, myControl2) VALUES (@ myValue1, @ myValue2);";
// Puis on définit les valeurs
myCommand.Parameters.Add (nouveau SqlParameter ("@ myValue1", myInt));
myOrder.Parameters.Add (nouveau SqlParameter ("@ myValue2", monstring));

Donc, nous n'avons même pas à nous soucier de mettre des guillemets autour des chaînes ou non, en utilisant un point ou une virgule pour les doubles … Tout est directement géré à partir du type d'objets (dans ce cas myInt et monstring).

Procédures stockées

Voici un moyen d'améliorer les performances et la maintenabilité de votre application: utilisez des procédures stockées. Le principe est que votre demande est directement enregistrée et compilée dans la base de données. Donc pas besoin de recompiler l'application pour modifier une requête. Il vous suffit de modifier la procédure stockée directement dans votre base de données.

myOrder.CommandText = "NameOfMyProcedure";
myOrder.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.Add (new SqlParameter ("@ MyParameter", myValue));

Quant à l'exécution elle-même, nous utilisons ExecuteNonQuery (), ExecuteScalar () ou ExecuteReader () dans les mêmes conditions qu'une requête manuelle.

résumé

Interroger une base de données est très simple, mais il est essentiel de s'habituer à l'utilisation de requêtes paramétrées, et si possible de procédures stockées.
Voici également un code pour résumer l'ensemble:

public void getListeClientsDansUneVille (string ville)

    SqlConnection myConnection = null;
    essayer
    
        myConnection = new SqlConnection ("Source de données = 127.0.0.1,1433; Catalogue initial = MaBase; ID utilisateur = Krimog; Mot de passe = myPass;");
        SqlCommand myCommand = new SqlCommand ();
        myOrder.Connection = maConnexion;
        myOrder.CommandText = "SELECT CustomerName, CustomerName FROM Clients WHERE CustomerCity = @City;";
        myOrder.Parameters.Add (nouveau SqlParameter ("@ City", city));
        myConnection.Open ();
        SqlDataReader myReader = myOrder.ExecuteReader ();
        if (! myReader.HasRows)
        
            Console.WriteLine ("Aucun client ne vit dans" + ville);
        
        autre
        
            while (myReader.Read ())
            
                Console.WriteLine (myReader["PrenomClient"].ToString () + "" + myReader["NomClient"].ToString () + "habite" + ville);
            
        
    
    capture
    
        Console.WriteLine ("Erreur de connexion ou d'exécution de la demande");
    
    enfin
    
        if (myConnection! = null && myConnection.State == ConnectionState.Open)
        
            myConnection.Close ();