Post on 05-Jun-2020
Introduction à ADO.NET Version 1.0
Z
Gallianne Barranger
Dotnet France Association
2 Introduction à ADO.NET09
Sommaire
1 Introduction ..................................................................................................................................... 3
1.1 Qu’est ce que l’ADO.NET ? ...................................................................................................... 3
1.2 Quel sont les particularités du Compact Framework ? ........................................................... 3
2 Utilisations simples .......................................................................................................................... 4
2.1 Créations d’une interface ........................................................................................................ 4
2.2 Description de la référence « System.Data.SqlServerCe » .................................................... 10
2.3 Création d’une base de données (SqlCeEngine).................................................................... 11
2.3.1 Avec du code ................................................................................................................. 11
2.3.2 Avec l’interface graphique............................................................................................. 12
2.4 Connexion a une base de données (SqlCeConnection) ......................................................... 13
2.4.1 Un exemple général ...................................................................................................... 13
2.4.2 Cas particulier ................................................................................................................ 14
2.5 Création d’une table (SqlCeCommand & SqlCeDataReader) ................................................ 14
2.5.1 Avec du code ................................................................................................................. 14
2.5.2 Avec l’interface graphique............................................................................................. 15
2.6 Mise en pratique avec notre projet....................................................................................... 17
2.7 Ecrire dans une table ............................................................................................................. 19
2.7.1 Avec du code ................................................................................................................. 19
2.7.2 Avec l’interface graphique............................................................................................. 19
2.8 Lecture d’une table (SqlCeDataReader) ................................................................................ 20
2.8.1 Utilization de SqlCeDataReader .................................................................................... 20
2.8.2 Utilisation des tableau de données (DataGrid) ............................................................. 22
2.9 Mise en pratique de la lecture/écriture ................................................................................ 23
3 Conclusion ..................................................................................................................................... 29
Dotnet France Association
3 Introduction à ADO.NET09
1 Introduction
1.1 Qu’est ce que l’ADO.NET ? ADO.NET (ActiveX Data Objects.Net) est un ensemble de classes d’accès aux données compris
dans le Framework .NET 3.5. Il permet de gérer de façon simplifiée et organisée des données
stockées en base (relationnelle ou non), dans des fichiers XML (eXtensible Markup Language) et API
(Application Programming Interface).
ADO.NET permet au développeur de faciliter la manipulation des données en établissant la
liaison entre les données et l’application. Il existe 2 modes de connexion : connecté et déconnecté.
Le mode connecté donne un accès en permanence aux données donc une synchronisation quasi
immédiate mais demande une bonne prise en charge du réseau. Le mode déconnecté permet de
stocker temporairement le résultat de nos requêtes en se connectant juste le temps de la
récupération, de les modifier et de mettre à jour la base en se reconnectant.
ADO.NET nous offre 4 fournisseurs pour accéder aux données (SQL Server, Oracle, ODBC et
OLE DB ; que nous détaillerons dans le cours). Ceux-ci peuvent permettre de stocker dans un DataSet
les résultats de nos requêtes.
1.2 Quel sont les particularités du Compact Framework ? Comme vous le savez, le compact Framework est fait pour fonctionner sur des machines aux
performances limitées (téléphone portable, PDA…). Les méthodes et possibilités sont donc réduites
et ADO n’échappe pas à cette règle.
Une liste exhaustive de toutes les différences n’est guère intéressante, cependant, certaines
peuvent être importantes.
Nous noterons donc que :
Il est impossible d’utiliser son PDA pour créer un serveur.
Se connecter directement à une base hébergée sur un Ordinateur n’est pas envisageable. Il
faudra se connecter à un fichier .sdf sur le périphérique mobile.
On ne peut exécuter qu'une requête à la fois (il faudra oublier les fonctionnalités de type
Mars comme sur SQL Server par exemple).
Dotnet France Association
4 Introduction à ADO.NET09
2 Utilisations simples Tout au long de ce cours, nous développerons une même application ayant pour but de gérer une
Vidéothèque. Si ADO est au centre du projet, la connaissance des précédents chapitres est vivement
conseillée. Dans ce chapitre nous n’utiliserons pas Linq. Par conséquent, il n’est pas envisageable
d’entamer ce cours sans connaitre les basses du SQL.
NB : La partie 2.1 n’est pas indispensable, elle permet uniquement de mieux comprendre les
exemples.
2.1 Créations d’une interface Créez un nouveau projet : Fichier > nouveau > Projet
Comme ci-dessous, sélectionnez « Smart Device Project », donnez lui un nom puis cliquez sur
OK
Sélectionnez la plateforme de votre choix, choisissez « Device Application » puis cliquez sur OK
Dotnet France Association
5 Introduction à ADO.NET09
Votre projet est créé !
Placez ensuite un premier bouton « Créer
une table » et créez l’événement Click :
« CreerUneTable_Click »
Dotnet France Association
6 Introduction à ADO.NET09
Apres, ajoutez une nouvelle fenêtre comme ci-dessous : clic droit sur
monProjetADO > Add > Windows form…
Place au code maintenant !
Nous allons instancier Form2 et l’ouvrir lorsque nous cliquerons sur notre bouton.
Voici à quoi doit ressembler votre fichier Form1.cs :
C#
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace monProjetADO
{
public partial class Form1 : Form
{
//instanciation de Form2
private Form2 MonCreateurDeTable;
public Form1()
{
InitializeComponent();
}
private void CreerUneTable_Click(object sender, EventArgs e)
{
//ouverture de MonCreateurDeTable (un objet de Form2)
Dotnet France Association
7 Introduction à ADO.NET09
MonCreateurDeTable.ShowDialog();
}
}
} VB.NET Public Class Form1
Inherits Form
'instanciation de Form2
Private MonCreateurDeTable As Form2
Private Sub CreerUneTable_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles Button1.Click
'ouverture de MonCreateurDeTable (un objet de Form2)
MonCreateurDeTable.ShowDialog()
End Sub
End Class
Passons à Form2.
Pour ce dernier, nous irons beaucoup plus vite. Le contenu est simple, il nous faut :
- 2 TextBox, un pour le nom de la table et un pour le nom de la base.
- 2 Label pour informer l’utilisateur sur le rôle des TextBox.
- 2 boutons, un pour revenir en arrière, un pour créer la table et la base.
- 1 InputPanel .
Dotnet France Association
8 Introduction à ADO.NET09
Votre interface ressemblera alors à ceci :
Ensuite, il vous faut créer les événements « classique » de ces objets :
- GotFocus / LostFocus sur les TextBox pour afficher le clavier tactile.
- Click sur les boutons.
Avant d’attaquer les choses sérieuses et de voir ce que peut effectuer le bouton Valider, le code
devrait ressembler à cela :
C#
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace monProjetADO
{
public partial class Form2 : Form
{
public Form2()
Dotnet France Association
9 Introduction à ADO.NET09
{
InitializeComponent();
}
//apparition et disparition du clavier tactile
private void textBoxTable_GotFocus(object sender, EventArgs e)
{
inputPanel1.Enabled = true;
}
private void textBoxTable_LostFocus(object sender, EventArgs e)
{
inputPanel1.Enabled = false;
}
private void textBoxBase_GotFocus(object sender, EventArgs e)
{
inputPanel1.Enabled = true;
}
private void textBoxBase_LostFocus(object sender, EventArgs e)
{
inputPanel1.Enabled = false;
}
// gestions des boutons
private void buttonAnnuler_Click(object sender, EventArgs e)
{
this.Close();
}
private void buttonValider_Click(object sender, EventArgs e)
{
/*
...
nous verrons ce passage dans la partie suivante
...
*/
this.Close();
}
}
}
VB.NET
Public Class Form2
Inherits Form
Public Sub New()
InitializeComponent()
End Sub
'apparition et disparition du clavier tactile
Private Sub textBoxTable_GotFocus(ByVal sender As Object, ByVal e As
EventArgs)
inputPanel1.Enabled = True
End Sub
Private Sub textBoxTable_LostFocus(ByVal sender As Object, ByVal e As
EventArgs)
inputPanel1.Enabled = False
End Sub
Dotnet France Association
10 Introduction à ADO.NET09
Private Sub textBoxBase_GotFocus(ByVal sender As Object, ByVal e As
EventArgs)
inputPanel1.Enabled = True
End Sub
Private Sub textBoxBase_LostFocus(ByVal sender As Object, ByVal e As
EventArgs)
inputPanel1.Enabled = False
End Sub
' gestions des boutons
Private Sub buttonAnnuler_Click(ByVal sender As Object, ByVal e As
EventArgs)
Me.Close()
End Sub
Private Sub buttonValider_Click(ByVal sender As Object, ByVal e As
EventArgs)
'
' ...
' nous verrons ce passage dans la partie suivante
' ...
'
Me.Close()
End Sub
End Class
2.2 Description de la référence « System.Data.SqlServerCe » Pour utiliser une base de données Microsoft SQL Server 2005 Compact Edition, l’espace de nom
System.Data.SqlServerCe est indispensable.
Voici un tableau récapitulatif des principales classes de l’espace de nom
System.Data.SqlServerCe. Pour une liste complète, vous pouvez vous rendre sur
http://msdn.microsoft.com/fr-fr/library/ms174038(SQL.90).aspx
Quelques Classes Description Quelques méthodes Description
SqlCeCommand
Il permet d’effectuer une requête. Il prend en argument un objet
SqlCeConnection et un String
ExecuteReader Exécute une commande qui retourne des lignes
ExecuteNonQuery Exécute des commandes telles qu’INSERT UPDATE ou DELETE
ExecuteScalar Récupère une valeur unique (la première colonne de la première ligne retournée par la requête)
ExecuteResultSet Exécute des commandes et retourne un jeu de résultats.
SqlCeDataReader
Permet de lire un flux de ligne de donnée qui était initialement visible a partir d’une source de donnée
Read Lis la ligne suivante
Close Ferme l’objet
GetSqlDateTime Récupère la donnée au format SQL «date time»
GetInt32 Récupère la donnée au format int 32
SqlCeConnection Permet de vous souhaitez vous connecter à la base de donnée de votre choix
Open Ouvre une connexion
Close Clos une connexion
ChangeDatabase Change le nom de la base de donnée à
Dotnet France Association
11 Introduction à ADO.NET09
laquelle vous souhaitez vous connecter
SqlCeEngine permet de créer, modifier et supprimer une base de données SQL Server Compact Edition.
CreateDatabase Créer une nouvelle base de donnée
Dispose Supprime l’objet et ses données
Repair Répare une base de données corrompue
Shrink Recherche les emplacements vides dans la base de données, les déplace a la fin et tronque le fichier
2.3 Création d’une base de données (SqlCeEngine)
Avant tout, ajoutez la référence System.Data.SqlServerCe
(Attention la ligne « using System.Data.SqlServerCe; » n’est pas toujours suffisante, il faut
aussi être sur qu’elle soit également ajoutée a la liste des références du projet avec l’interface
graphique)
Deux possibilités s’offriront à vous lors de la création de vos bases de données.
La première est de créer les bases de données et les tables avec le code. Cette solution vous
permettra de créer des bases de données à l’emplacement de votre choix ou encore des tables
portant le nom choisi par l’utilisateur de votre application.
La seconde solution est d’utiliser l’interface graphique. Ainsi vous pourrez créer et modifier vos
tables directement depuis Visual Studio et gagnerez un temps précieux.
2.3.1 Avec du code
C#
using System.Data.SqlServerCe; // ajout de la référence
[…]
// Création du fichier base de données vide au format " sdf "
SqlCeEngine eng = null;
eng = new SqlCeEngine("Data Source=\\My Documents\\maBDD.sdf");
eng.CreateDatabase();
[…]
VB.NET Imports System.Data.SqlServerCe ' ajout de la référence
'[…]
' Création du fichier base de données vide au format " sdf " Dim eng As SqlCeEngine = Nothing eng = New SqlCeEngine("Data Source=\\My Documents\\maBDD.sdf")
eng.CreateDatabase()
'[…]
Dotnet France Association
12 Introduction à ADO.NET09
2.3.2 Avec l’interface graphique
Pour ajouter une base de donnée, comme ci-dessous, faites un clic droit sur le nom de votre projet
puis sélectionnez « Ajouter » et enfin « nouvel élément »
Une fois cela fait, choisissez « Database File » puis cliquez sur « Add »
Dotnet France Association
13 Introduction à ADO.NET09
Votre fichier sera automatiquement ajouté à votre projet :
2.4 Connexion a une base de données (SqlCeConnection)
2.4.1 Un exemple général
C#
SqlCeConnection myConn = null;
// on enregistre l’emplacement de la base de donnée
myConn = new SqlCeConnection("Data Source=\\My Documents\\maBase.sdf");
// Ouverture de la connexion à la base
myConn.Open();
// fermeture de la connexion à la base
myConn.Close();
VB.NET
Dim myConn As SqlCeConnection = Nothing
' on enregistre l’emplacement de la base de donnée
myConn = New SqlCeConnection("Data Source=\My Documents\maBase.sdf")
' Ouverture de la connexion à la base
myConn.Open()
' fermeture de la connexion à la base
myConn.Close()
Dotnet France Association
14 Introduction à ADO.NET09
2.4.2 Cas particulier
Lorsque vous créez la base de données avec l’interface graphique, vous ne connaissez pas forcément
l’endroit où Visual Studio la place lors de l’émulation. Une des solutions est donc d’utiliser la ligne
suivante :
C#
SqlCeConnection SqlCnx = new SqlCeConnection("Data Source=" +
System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAsse
mbly().GetName().CodeBase) + "\\maBase.sdf");
VB.NET
Dim SqlCnx As New SqlCeConnection("Data Source=" &
System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAsse
mbly().GetName().CodeBase) & "\maBase.sdf")
2.5 Création d’une table (SqlCeCommand & SqlCeDataReader)
2.5.1 Avec du code
C#
SqlCeDataReader myReader = null;
SqlCeConnection myConn = null;
SqlCeCommand myComm = null;
// Enregistrement de la requete SQL sous la forme d'une chaine de
caractères
String strSQL = "CREATE TABLE maTable (code int IDENTITY (1,1) PRIMARY
KEY, nom nvarchar (30) NOT NULL, prenom nvarchar (30) NULL, age int
NULL)";
// on enregistre l’emplacement de la base de donnée
myConn = new SqlCeConnection("Data Source=\\My Documents\\maBase.sdf");
// Création d'un objet SqlCeCommand permetant de passer des commandes SQL
MyComm = new SqlCeCommand(strSQL, myConn);
// Ouverture de la connexion à la base
myConn.Open();
// exécution de la commande
myComm.ExecuteNonQuery(); // fermeture de la connexion à la base
myConn.Close();
VB.NET
Dim myReader As SqlCeDataReader = Nothing
Dim myConn As SqlCeConnection = Nothing
Dim myComm As SqlCeCommand = Nothing
' Enregistrement de la requete SQL sous la forme d'une chaine de
caractères
Dim strSQL As [String] = "CREATE TABLE maTable (code int IDENTITY (1,1)
Dotnet France Association
15 Introduction à ADO.NET09
PRIMARY KEY, nom nvarchar (30) NOT NULL, prenom nvarchar (30) NULL, age
int NULL)"
' on enregistre l’emplacement de la base de donnée
myConn = New SqlCeConnection("Data Source=\My
Documents\maBase.sdf")
' Création d'un objet SqlCeCommand permetant de passer des commandes SQL
myComm = New SqlCeCommand(strSQL, myConn)
' Ouverture de la connexion à la base
myConn.Open()
' exécution de la commande
myComm.ExecuteNonQuery()
' fermeture de la connexion à la base
myConn.Close()
2.5.2 Avec l’interface graphique
Double-cliquez sur le nom de votre base pour faire apparaitre le Server Explorer
Dotnet France Association
16 Introduction à ADO.NET09
Faites ensuite un clic droit sur « Table » et choisissez « Create Table »
Créez ensuite la structure de votre table et validez :
Dotnet France Association
17 Introduction à ADO.NET09
2.6 Mise en pratique avec notre projet Voici donc une des possibilités pour la méthode « buttonValider_Click »
C#
private void buttonValider_Click(object sender, EventArgs e)
{
// création d'un bloque try/catch
try
{
//récupération des valeures de nos texteBox
String NomDeLaBase = textBoxBase.Text;
String NomDeLaTable = textBoxTable.Text;
// Création du fichier de la BDD vide au format "sdf"
SqlCeEngine eng = null;
eng = new SqlCeEngine("Data Source=\\My Documents\\" +
NomDeLaBase + ".sdf");
eng.CreateDatabase();
SqlCeConnection myConn = null;
SqlCeCommand myComm = null;
// Enregistrement de la requete SQL sous la forme d'une
chaine de caractères
String strSQL = "CREATE TABLE " + NomDeLaTable + " (id int
IDENTITY (1,1) PRIMARY KEY, nom nvarchar (30) NOT NULL,
genre nvarchar (30) NULL, annee int NULL)";
// emplacement du fichier .sdf
myConn = new SqlCeConnection("Data Source=\\My
Documents\\" + NomDeLaBase + ".sdf");
// Création d'un objet contenant la commande
myComm = new SqlCeCommand(strSQL, myConn);
// Ouverture de la connexion à la base
myConn.Open();
// execution de la commande StrSQL
myComm.ExecuteNonQuery();
// fermeture de la connexion à la base
if (myConn.State == ConnectionState.Open)
myConn.Close();
}
catch (SqlCeException Ex)
{
}
this.Close();
}
Dotnet France Association
18 Introduction à ADO.NET09
VB.NET
Private Sub buttonValider_Click(ByVal sender As Object, ByVal e As
EventArgs)
' création d'un bloque try/catch
Try
'récupération des valeures de nos texteBox
Dim NomDeLaBase As [String] = textBoxBase.Text
Dim NomDeLaTable As [String] = textBoxTable.Text
' Création du fichier de la BDD vide au format "sdf"
Dim eng As SqlCeEngine = Nothing
eng = New SqlCeEngine("Data Source=\My Documents\" &
NomDeLaBase & ".sdf")
eng.CreateDatabase()
Dim myConn As SqlCeConnection = Nothing
Dim myComm As SqlCeCommand = Nothing
' Enregistrement de la requete SQL sous la forme d'une
chaine de caractères
Dim strSQL As [String] = "CREATE TABLE " & NomDeLaTable &
" (id int IDENTITY (1,1) PRIMARY KEY, nom nvarchar (30) NOT NULL,
genre nvarchar (30) NULL, annee int NULL)"
' emplacement du fichier .sdf
myConn = New SqlCeConnection("Data Source=\My Documents\"
& NomDeLaBase & ".sdf")
' Création d'un objet contenant la commande
myComm = New SqlCeCommand(strSQL, myConn)
' Ouverture de la connexion à la base
myConn.Open()
' execution de la commande StrSQL
myComm.ExecuteNonQuery()
' fermeture de la connexion à la base
If myConn.State = ConnectionState.Open Then
myConn.Close()
End If
Catch Ex As SqlCeException
End Try
Me.Close()
End Sub
Pour simplifier la chose, nous allons donner une valeur par défaut à nos textBox et utiliserons celles
là pour le reste de notre projet. Ces valeurs seront « Videotheques » pour la base de données et
« mesFilms » pour le nom de la table
NB : Vous n’êtes pas obliger d’utiliser les mêmes noms.
A présent, passons à la lecture et à l’écriture.
Dotnet France Association
19 Introduction à ADO.NET09
2.7 Ecrire dans une table
2.7.1 Avec du code
C#
SqlCeConnection myConn = null;
SqlCeCommand myComm = null;
String strSQL = "INSERT INTO maTable (nom, prenom, age) VALUES
('Barranger', 'Gallianne', 21)";
myConn = new SqlCeConnection("Data Source=\\My Documents\\maBase.sdf");
myComm = new SqlCeCommand(strSQL, myConn);
myConn.Open();
myComm.ExecuteNonQuery();
if (myConn.State == ConnectionState.Open)
myConn.Close();
VB.NET
Dim myConn As SqlCeConnection = Nothing
Dim myComm As SqlCeCommand = Nothing
Dim strSQL As [String] = "INSERT INTO maTable (nom, prenom, age) VALUES
('Barranger', 'Gallianne', 21)"
myConn = New SqlCeConnection("Data Source=\My Documents\maBase.sdf")
myComm = New SqlCeCommand(strSQL, myConn)
myConn.Open()
myComm.ExecuteNonQuery()
If myConn.State = ConnectionState.Open Then
myConn.Close()
End If
2.7.2 Avec l’interface graphique
Faites un clic droit sur le nom de votre table puis choisissez « Show Table Data »
Dotnet France Association
20 Introduction à ADO.NET09
Une interface graphique vous permettra alors d’ajouter, de supprimer ou modifier les lignes de votre
choix :
2.8 Lecture d’une table (SqlCeDataReader)
2.8.1 Utilization de SqlCeDataReader
Dotnet France Association
21 Introduction à ADO.NET09
C#
// on enregistre l’emplacement de la base de donnée
SqlCeConnection SqlCnx = new SqlCeConnection("Data Source=\\My
Documents\\maBase.sdf");
// Enregistrement de la requete SQL sous la forme d'une chaine de
caractères
string sSQL = "SELECT * FROM maTable";
// Création d'un objet SqlCeCommand permetant de passer des commandes SQL
SqlCeCommand SqlCommand = new SqlCeCommand(sSQL, SqlCnx);
// Ouverture de la connexion à la base
SqlCnx.Open();
// Exécution de la commande
SqlCommand.ExecuteNonQuery();
// l’objet reader recoit les résultats de la commande
SqlCeDataReader reader = SqlCommand.ExecuteReader();
// lecture de reader ligne par ligne
while (reader.Read())
{
// lecture de la première colone et de celle ayant pour nom « prenom »
Label1.Text += "ID: "+ reader[0] +" prénom: " +reader["prenom"] + "\n ";
}
// Fermeture de la connexion
if (SqlCnx.State == ConnectionState.Open)
{
SqlCnx.Close();
}
VB.NET
' on enregistre l’emplacement de la base de donnée
Dim SqlCnx As New SqlCeConnection("Data Source=\My Documents\maBase.sdf")
' Enregistrement de la requete SQL sous la forme d'une chaine de
caractères
Dim sSQL As String = "SELECT * FROM maTable"
' Création d'un objet SqlCeCommand permetant de passer des commandes SQL
Dim SqlCommand As New SqlCeCommand(sSQL, SqlCnx)
' Ouverture de la connexion à la base
SqlCnx.Open()
' Exécution de la commande
SqlCommand.ExecuteNonQuery()
' l’objet reader recoit les résultats de la commande
Dim reader As SqlCeDataReader = SqlCommand.ExecuteReader()
' lecture de reader ligne par ligne
While reader.Read()
' lecture de la première colone et de celle ayant pour nom « prenom »
Label1.Text += ("ID: " & reader(0) & " prénom: ") + reader("prenom") &
Dotnet France Association
22 Introduction à ADO.NET09
vbLf & " "
End While
' Fermeture de la connexion
If SqlCnx.State = ConnectionState.Open Then
SqlCnx.Close()
End If
2.8.2 Utilisation des tableau de données (DataGrid)
Le DataGrid peut afficher le contenu d’une table. Il est donc très pratique et utilisé. A noté que
dans la version CE, il est très limité. Il ne permet, ni d’ajouter, ni de supprimer, ni de modifier des
valeurs. Il s’agit donc d’un simple tableau de texte avec des cases facilement extensibles.
Pour l’utiliser il suffit d’un glissé déposé classique
Une fois que c’est chose faite, il va falloir le lier à une table. Comme ci-dessous, modifiez la propriété
« DataSource » à l’aide de l’interface graphique.
Clique droit sur la flèche de la comboBox choisissez « Add Project Data Sources »
Dotnet France Association
23 Introduction à ADO.NET09
Ensuite, pour le lier à la table que nous avions ajoutée graphiquement, choisissez « Database »
puis cliquez sur suivant.
Vérifiez que votre fichier « AppDatabase1.sdf » est bien sélectionné puis cliquez sur « Next »
Enfin, cochez votre Table et cliquez sur « Finish ».
2.9 Mise en pratique de la lecture/écriture
Dotnet France Association
24 Introduction à ADO.NET09
Nous allons donc créer une nouvelle Windows Form accessible depuis Form1.
Cette dernière comprendra :
- 5 labels (4 qui indiqueront l’information demandée et un affichant le film ajouté)
- 3 TextBox (pour l’id, le Nom et l’année)
- 1 ComboBox pour le genre
- 2 buttons (Ajouter et Quitter)
Voici donc à quoi votre application doit ressembler
Les plus motivés pourront créer une méthode qui recherche elle-même l’id. Les habitués auront
déclaré id comme « IDENTITY » lors de la création de la table et n’auront donc pas à s’en soucier.
Pour les autres, le code suivant suffira.
C#
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
Dotnet France Association
25 Introduction à ADO.NET09
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlServerCe;
namespace monProjetADO
{
public partial class Form4 : Form
{
public Form4()
{
InitializeComponent();
}
//faire apparaitre le clavier tactile quand on selectionne une textBox
private void textBox1_GotFocus(object sender, EventArgs e)
{
inputPanel1.Enabled = true;
}
private void textBox1_LostFocus(object sender, EventArgs e)
{
inputPanel1.Enabled = false;
}
//[...]
// le bouton valider
private void button1_Click(object sender, EventArgs e)
{
//ajout d'une ligne (écriture)
try
{
SqlCeConnection myConn = null;
SqlCeCommand myComm = null;
//requête SQL
String strSQL = "INSERT INTO mesFilms (id, nom, genre,
annee) VALUES (" + System.Convert.ToInt32(textBox1.Text) +
", '" + textBox2.Text + "', '" + comboBox1.Text + "', " +
System.Convert.ToInt32(textBox3.Text) + ")";
//instenciation d’une connexion
myConn = new SqlCeConnection("Data Source=\\My
Documents\\Videotheques.sdf");
//création de la commande
myComm = new SqlCeCommand(strSQL, myConn);
myConn.Open(); //ouverture de la connexion
myComm.ExecuteNonQuery(); //exécution de la commande
if (myConn.State == ConnectionState.Open)
myConn.Close(); //fermeture de la connexion
}
catch{ }
// on regarde si le texte a bien était ajouté (lecture)
try
{
SqlCeCommand myComm2 = null;
Dotnet France Association
26 Introduction à ADO.NET09
SqlCeConnection myConn2 = null;
//requête SQL
String strSQL2 = "SELECT nom FROM mesFilms WHERE id = " +
System.Convert.ToInt32(textBox1.Text);
//instenciation d’une connexion
myConn2 = new SqlCeConnection("Data Source=\\My
Documents\\Videotheques.sdf");
//création de la commande
myComm2 = new SqlCeCommand(strSQL2, myConn2);
//ouverture de la connexion
myConn2.Open();
// enregistrement des résultat de la commande dans
l’objet reader
SqlCeDataReader reader = myComm2.ExecuteReader();
reader.Read();// lecture de la ligne
//affiche si la requete s’est bien passée
if ((String)reader["nom"] == textBox2.Text) //si oui …
label5.Text = textBox2.Text + " à bien été ajouté à
votre liste de films";
else //si non …
{
label5.Text = "Erreur ! \n" +textBox2.Text + " n'à
pas été ajouté à votre liste de films !!!";
}
if (myConn2.State == ConnectionState.Open) //si non …
myConn2.Close(); //fermeture de la connexion
}
catch { }
}
private void button2_Click(object sender, EventArgs e)
{
this.Close();
}
}
}
VB.NET
Namespace monProjetADO
Partial Public Class Form4
Inherits Form
Public Sub New()
InitializeComponent()
End Sub
'faire apparaitre le clavier tactile quand on selectionne une
textBox
Private Sub textBox1_GotFocus(ByVal sender As Object, ByVal e As
Dotnet France Association
27 Introduction à ADO.NET09
EventArgs)
inputPanel1.Enabled = True
End Sub
Private Sub textBox1_LostFocus(ByVal sender As Object, ByVal e As
EventArgs)
inputPanel1.Enabled = False
End Sub
'[...]
' le bouton valider
Private Sub button1_Click(ByVal sender As Object, ByVal e
As EventArgs)
'ajout d'une ligne (écriture)
Try
Dim myConn As SqlCeConnection = Nothing
Dim myComm As SqlCeCommand = Nothing
'requête SQL
Dim strSQL As [String] = ((("INSERT INTO mesFilms (id,
nom, genre, annee) VALUES (" &
System.Convert.ToInt32(textBox1.Text) & ", '") +
textBox2.Text & "', '") + comboBox1.Text & "', ") +
System.Convert.ToInt32(textBox3.Text) & ")"
'instenciation d’une connexion
myConn = New SqlCeConnection("Data Source=\My
Documents\Videotheques.sdf")
'création de la commande
myComm = New SqlCeCommand(strSQL, myConn)
myConn.Open()
'ouverture de la connexion
myComm.ExecuteNonQuery()
'exécution de la commande
If myConn.State = ConnectionState.Open Then
myConn.Close()
'fermeture de la connexion
End If
Catch
End Try
' on regarde si le texte a bien était ajouté (lecture)
Try
Dim myComm2 As SqlCeCommand = Nothing
Dim myConn2 As SqlCeConnection = Nothing
'requête SQL
Dim strSQL2 As [String] = "SELECT nom FROM mesFilms WHERE
id = " & System.Convert.ToInt32(textBox1.Text)
'instenciation d’une connexion
myConn2 = New SqlCeConnection("Data Source=\My
Documents\Videotheques.sdf")
'création de la commande
myComm2 = New SqlCeCommand(strSQL2, myConn2)
'ouverture de la connexion
myConn2.Open()
Dotnet France Association
28 Introduction à ADO.NET09
' enregistrement des résultat de la commande dans l’objet
reader
Dim reader As SqlCeDataReader = myComm2.ExecuteReader()
reader.Read()
' lecture de la ligne
'affiche si la requete s’est bien passée
If DirectCast(reader("nom"), [String]) = textBox2.Text
Then
'si oui …
label5.Text = textBox2.Text & " à bien été ajouté à
votre liste de films"
Else
'si non …
label5.Text = "Erreur ! " & vbLf & textBox2.Text & "
n'à pas été ajouté à votre liste de films !!!"
End If
If myConn2.State = ConnectionState.Open Then
'si non …
myConn2.Close()
'fermeture de la connexion
End If
Catch
End Try
End Sub
Private Sub button2_Click(ByVal sender As Object, ByVal e As
EventArgs)
Me.Close()
End Sub
End Class
End Namespace
Dotnet France Association
29 Introduction à ADO.NET09
3 Conclusion
Vous savez à présent utiliser les principales méthodes de SqlServerCe. Maintenant vous êtes à
même de créer une base de données ou des tables. Vous savez également lire le contenu d’une base
et y ajouter du contenu. A présent vous pouvez effectuer toutes sortes d’opérations sur votre base
de données .sdf. Une simple modification de la requête SQL vous permettra d’effectuer l’opération
de votre choix.