Cours VB NET Obtention d’une valeur unique à partir d’une base de données, tutoriel & guide de travaux pratiques structure des programmes Visual Basic en pdf.

Obtention d’une valeur unique à partir d’une base de données

Vous aurez peut-être besoin de retourner des informations de base de données qui sont simplement une valeur unique plutôt qu’une table ou un flux de données. Par exemple, vous souhaitez éventuellement retourner le résultat d’une fonction d’agrégation telle que Count(*), Sum(Price) ou Avg(Quantity). L’objet Command fournit la fonctionnalité permettant de retourner des valeurs uniques à l’aide de la méthode ExecuteScalar. La méthode ExecuteScalar retourne comme valeur scalaire la valeur de la première colonne de la première ligne du jeu de résultats.
L’exemple de code suivant retourne le nombre d’enregistrements dans une table utilisant la fonction d’agrégation Count.
Dim ordersCMD As SqlCommand = New SqlCommand(« SELECT Count(*)
FROM Orders », nwindConn)
Dim count As Int32 = CInt(ordersCMD.ExecuteScalar())

Exécution d’opérations de catalogue

Pour exécuter une commande permettant de modifier une base de données ou un catalogue, comme l’instruction CREATE TABLE ou CREATE PROCEDURE, créez Command à l’aide de la ou des instructions TransactVB NET Accès aux données SQL appropriées et de Connection. Exécutez la commande avec la méthode ExecuteNonQuery de l’objet Command.
L’exemple de code suivant crée une procédure stockée dans une base de données Microsoft SQL Server.
Dim createStr As String = « CREATE PROCEDURE InsertCategory  » & _
 » @CategoryName nchar(15),  » & _
 » @Identity int OUT  » & _
« AS  » & _
« INSERT INTO Categories (CategoryName)  » & _
« VALUES (@CategoryName)  » & _
« SET @Identity = @@Identity  » & _
« RETURN @@ROWCOUNT »
Dim createCMD As SqlCommand = New SqlCommand(createStr, nwindConn)
createCMD.ExecuteNonQuery()

Modification de données dans une base de données

Les instructions SQL qui modifient les données (comme INSERT, UPDATE ou DELETE) ne retournent pas de lignes. De même, de nombreuses procédures stockées effectuent une action mais ne retournent pas de lignes. Pour exécuter des commandes qui ne retournent pas de lignes, créez un objet Command avec la commande SQL appropriée et Connection (et les Parameters requis) puis utilisez la méthode ExecuteNonQuery de l’objet Command.
La méthode ExecuteNonQuery retourne un entier qui représente le nombre de lignes affectées par l’instruction ou la procédure stockée exécutée. Si plusieurs instructions sont exécutées, la valeur retournée est la somme des enregistrements affectés par toutes ces instructions.
L’exemple de code suivant exécute une instruction INSERT pour insérer un enregistrement dans une base de données à l’aide de ExecuteNonQuery.
Dim nwindConn As SqlConnection = New SqlConnection(« Data
Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind »)
nwindConn.Open()
Dim insertStr As String = « INSERT INTO Customers (CustomerID, CompanyName)
Values(‘NWIND’, ‘Northwind Traders’) »
Dim insertCMD As SqlCommand = New SqlCommand(insertStr, nwindConn)
Dim recordsAffected As Int32 = insertCMD.ExecuteNonQuery()
L’exemple de code suivant exécute la procédure stockée créée par l’exemple de code dans Exécution d’opérations de catalogue. Aucune ligne n’est retournée par la procédure stockée, la méthode ExecuteNonQuery est donc utilisée mais la procédure stockée reçoit un paramètre d’entrée et retourne un paramètre de sortie et une valeur de retour.
Pour l’objet OleDbCommand, le paramètre ReturnValue doit être d’abord ajouté à la collection Parameters.
Dim insertCatCMD As SqlCommand = New SqlCommand(« InsertCategory » , nwindConn)
insertCatCMD.CommandType = CommandType.StoredProcedure
Dim workParm As SqlParameter
workParm = insertCatCMD.Parameters.Add(« @RowCount », SqlDbType.Int)
workParm.Direction = ParameterDirection.ReturnValue
workParm = insertCatCMD.Parameters.Add(« @CategoryName », SqlDbType.NChar, 15)
workParm = insertCatCMD.Parameters.Add(« @Identity », SqlDbType.Int)
workParm.Direction = ParameterDirection.Output
insertCatCMD.Parameters(« @CategoryName »).Value = « New Category »
insertCatCMD.ExecuteNonQuery()
Dim catID As Int32 = CInt(insertCatCMD.Parameters(« @Identity »).Value)
Dim rowCount As Int32 = CInt(insertCatCMD.Parameters(« @RowCount »).Value)

UTILISATION DE DATAREADER

Vous pouvez utiliser le DataReader ADO.NET pour extraire d’une base de données un flux de données en lecture seule et avant uniquement. Les résultats sont retournés pendant que la requête s’exécute et stockés dans la mémoire tampon de réseau sur le client jusqu’à ce que vous les
demandiez au moyen de la méthode Read de DataReader. L’utilisation de DataReader peut augmenter les performances de l’application d’abord en extrayant les données dès qu’elles sont disponibles, plutôt que d’attendre que tous les résultats de la requête aient été retournés, et ensuite en ne stockant (par défaut) qu’une seule ligne à la fois dans la mémoire, ce qui réduit la charge du système.
Après avoir créé une instance de l’objet Command, vous créez un DataReader en appelant Command.ExecuteReader pour extraire les lignes d’une source de données, comme le montre l’exemple suivant.
Dim myReader As SqlDataReader = myCommand.ExecuteReader()
Vous utilisez la méthode Read de l’objet DataReader pour obtenir une ligne des résultats de la requête. Vous pouvez accéder à chaque colonne de la ligne retournée en passant le nom ou la référence ordinale de la colonne au DataReader. Cependant, pour une meilleure performance, le
DataReader fournit une série de méthodes qui vous permettent d’accéder aux valeurs de colonnes dans leurs types de données natifs (GetDateTime, GetDouble, GetGuid, GetInt32, etc.).
Remarque La version 1.1 du .NET Framework inclut une propriété supplémentaire pour le DataReader, HasRows, laquelle vous permet de déterminer si le DataReader a retourné des résultats avant de le lire.
L’exemple de code suivant itère dans un objet DataReader et retourne une colonne à partir de chaque ligne.
Module Module1
Sub Main()
Dim cn As New OleDb.OleDbConnection()
cn.ConnectionString = »Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\bd.mdb; »
cn.Open()
Dim CMD As New OleDb.OleDbCommand(« select * from Article », cn)
Dim RDR As OleDb.OleDbDataReader = CMD.ExecuteReader()
While (RDR.Read())
Console.WriteLine(RDR.GetString(1))
End While
Console.ReadLine()
RDR.Close()
cn.Close()
End Sub
End Module
Le DataReader fournit un flux de données non mis en tampon qui permet à la logique procédurale de traiter efficacement les résultats provenant d’une source de données de façon séquentielle. Le DataReader se révèle être un bon choix lors de l’extraction de grandes quantités de données car celles-ci ne sont pas mises en cache dans la mémoire.

Fermeture du DataReader

Vous devez toujours appeler la méthode Close lorsque vous avez fini d’utiliser l’objet DataReader.
Si Command contient des paramètres de sortie ou des valeurs de retour, ils ne seront pas disponibles avant la fermeture du DataReader.
Notez que pendant l’ouverture d’un DataReader, Connection est utilisé en mode exclusif par ce DataReader. Vous ne pourrez pas exécuter les commandes pour Connection, y compris la création d’un autre DataReader, jusqu’à la fermeture du DataReader d’origine.

 UTILISATION DES PROCEDURES

STOCKEES AVEC UNE COMMANDE
Exécution d’une procédure stockée
Les procédures stockées offrent de nombreux avantages dans les applications pilotées par des données. En utilisant les procédures stockées, les opérations de base de données peuvent être encapsulées dans une commande unique, optimisées pour une meilleure performance et améliorées grâce à une sécurité supplémentaire. Tandis qu’une procédure stockée peut être appelée en passant simplement son nom suivi des arguments de paramètre comme instruction SQL, l’utilisation de la collection Parameters de l’objet Command ADO.NET vous permet de définir plus explicitement les paramètres de procédure stockée et d’accéder aux paramètres de sortie et aux valeurs de retour.
Pour appeler une procédure stockée, affectez StoredProcedure au CommandType de l’objet Command. Une fois StoredProcedure affecté à CommandType, vous pouvez utiliser la collection Parameters pour définir les paramètres, comme dans l’exemple suivant.
Ce code appelle la procédure stockée « VentesParCatégorie » qui accepte un paramètre en entrée.
Dim nwindConn As SqlConnection = New SqlConnection(« Data
Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind »)
Dim salesCMD As SqlCommand = New SqlCommand(« VentesParCatégorie »,
nwindConn)
salesCMD.CommandType = CommandType.StoredProcedure
Dim myParm As SqlParameter = salesCMD.Parameters.Add(« @Categorie »,
SqlDbType.NVarChar, 15)
myParm.Value = « Condiments »
nwindConn.Open()
Dim myReader As SqlDataReader = salesCMD.ExecuteReader()
Console.WriteLine(myReader.GetName(0), myReader.GetName(1))
Do While myReader.Read()
Console.WriteLine(myReader.GetString(0), myReader.GetDecimal(1))
Loop
myReader.Close()
nwindConn.Close()

Utilisation des paramètres

Un objet Parameter peut être créé à l’aide du constructeur Parameter ou en appelant la méthode Add de la collection Parameters de Command. Parameters.Add prendra comme entrée les arguments de constructeur ou un objet Parameter existant. Lorsque vous affectez une référence null au Value d’un Parameter, utilisez DBNull.Value.
Pour les paramètres autres que Input, vous devez définir la propriété ParameterDirection pour spécifier si le type de paramètre est InputOutput, Output ou ReturnValue. L’exemple suivant illustre la différence entre la création des paramètres Input, Output et ReturnValue.
Dim sampleCMD As SqlCommand = New SqlCommand(« SampleProc », nwindConn)
sampleCMD.CommandType = CommandType.StoredProcedure
Dim sampParm As SqlParameter = sampleCMD.Parameters.Add(« RETURN_VALUE »,
SqlDbType.Int)
sampParm.Direction = ParameterDirection.ReturnValue
sampParm = sampleCMD.Parameters.Add(« @InputParm », SqlDbType.NVarChar, 12)
sampParm.Value = « Sample Value »
sampParm = sampleCMD.Parameters.Add(« @OutputParm », SqlDbType.NVarChar, 28)
sampParm.Direction = ParameterDirection.Output
nwindConn.Open()
Dim sampReader As SqlDataReader = sampleCMD.ExecuteReader()
Console.WriteLine(sampReader.GetName(0), sampReader.GetName(1))
Do While sampReader.Read()
Console.WriteLine(sampReader.GetInt32(0), sampReader.GetString(1))
Loop
sampReader.Close()
nwindConn.Close()
Console.WriteLine( » @OutputParm: « , sampleCMD.Parameters(« @OutputParm »).Value)
Console.WriteLine(« RETURN_VALUE: « , sampleCMD.Parameters(« RETURN_VALUE »).Value)

Utilisation des paramètres avec SqlCommand

Lorsque des paramètres sont utilisés avec SqlCommand, les noms des paramètres ajoutés à SqlParameterCollection doivent correspondre à ceux des marqueurs de paramètre de votre procédure stockée. Le fournisseur de données .NET Framework pour SQL Server traite les paramètres de la procédure stockée comme des paramètres nommés et recherche les marqueurs de paramètre correspondants.
Le fournisseur de données .NET Framework pour SQL Server ne prend pas en charge l’espace réservé de point d’interrogation (?) pour le passage des paramètres à une instruction SQL ou une procédure stockée. Dans ce cas, vous devez utiliser des paramètres nommés, comme dans l’exemple suivant.

………..