Share via

Configuration des paramètres de niveau connexion et commande de la couche d’accès aux données (C#)

  • Article

par Scott Mitchell

Télécharger le PDF

Les TableAdapters d’un DataSet typé se chargent automatiquement de se connecter à la base de données, d’émettre des commandes et de remplir un DataTable avec les résultats. Toutefois, il arrive que nous souhaitions nous-mêmes prendre en charge ces détails, et dans ce tutoriel, nous apprenons à accéder aux paramètres de connexion de base de données et de niveau commande dans TableAdapter.

Introduction

Tout au long de la série de tutoriels, nous avons utilisé des datasets typés pour implémenter la couche d’accès aux données et les objets métier de notre architecture en couches. Comme indiqué dans le premier tutoriel, les DataTables de DataSet typés servent de référentiels de données, tandis que les TableAdapters agissent comme des wrappers pour communiquer avec la base de données afin de récupérer et de modifier les données sous-jacentes. Les TableAdapters encapsulent la complexité de l’utilisation de la base de données et nous évitent d’avoir à écrire du code pour se connecter à la base de données, émettre une commande ou remplir les résultats dans un DataTable.

Toutefois, il arrive parfois que nous ayons besoin de creuser dans les profondeurs de TableAdapter et d’écrire du code qui fonctionne directement avec les objets ADO.NET. Par exemple, dans le didacticiel Wrapping Database Modifications in a Transaction , nous avons ajouté des méthodes à TableAdapter pour commencer, valider et restaurer ADO.NET transactions. Ces méthodes utilisent un objet interne créé SqlTransaction manuellement qui a été affecté aux objets TableAdapter SqlCommand .

Dans ce tutoriel, nous allons examiner comment accéder aux paramètres de connexion de base de données et de niveau commande dans TableAdapter. En particulier, nous allons ajouter des fonctionnalités au qui permet d’accéder ProductsTableAdapter aux paramètres de délai d’expiration de chaîne de connexion et de commande sous-jacents.

Utilisation des données à l’aide de ADO.NET

Microsoft .NET Framework contient une pléthore de classes conçues spécifiquement pour fonctionner avec des données. Ces classes, qui se trouvent dans l’espaceSystem.Data de noms, sont appelées classes ADO.NET. Certaines des classes sous l’égide ADO.NET sont liées à un fournisseur de données particulier. Vous pouvez considérer un fournisseur de données comme un canal de communication qui permet aux informations de circuler entre les classes ADO.NET et le magasin de données sous-jacent. Il existe des fournisseurs généralisés, comme OleDb et ODBC, ainsi que des fournisseurs spécialement conçus pour un système de base de données particulier. Par exemple, s’il est possible de se connecter à une base de données Microsoft SQL Server à l’aide du fournisseur OleDb, le fournisseur SqlClient est beaucoup plus efficace car il a été conçu et optimisé spécifiquement pour SQL Server.

Lors de l’accès aux données par programmation, le modèle suivant est couramment utilisé :

  • Établissez une connexion à la base de données.
  • Émettez une commande.
  • Pour SELECT les requêtes, utilisez les enregistrements résultants.

Il existe des classes ADO.NET distinctes pour effectuer chacune de ces étapes. Pour vous connecter à une base de données à l’aide du fournisseur SqlClient, par exemple, utilisez la SqlConnection classe . Pour émettre une INSERTcommande , UPDATE, DELETEou SELECT dans la base de données, utilisez la SqlCommand classe .

À l’exception du didacticiel Wrapping Database Modifications dans un transaction, nous n’avons pas eu à écrire nous-mêmes de code ADO.NET de bas niveau, car le code généré automatiquement tableAdapters inclut les fonctionnalités nécessaires pour se connecter à la base de données, émettre des commandes, récupérer des données et remplir ces données dans DataTables. Toutefois, il peut arriver que nous ayons besoin de personnaliser ces paramètres de bas niveau. Au cours des prochaines étapes, nous allons examiner comment exploiter les objets ADO.NET utilisés en interne par les TableAdapters.

Étape 1 : Examen avec la propriété Connection

Chaque classe TableAdapter a une Connection propriété qui spécifie les informations de connexion à la base de données. Le type de données et ConnectionString la valeur de cette propriété sont déterminés par les sélections effectuées dans l’Assistant Configuration de TableAdapter. Rappelez-vous que lorsque nous ajoutons un TableAdapter à un DataSet typé, cet Assistant nous demande la source de la base de données (voir la figure 1). La liste déroulante de cette première étape inclut les bases de données spécifiées dans le fichier de configuration, ainsi que toutes les autres bases de données dans le Connections de données de Server Explorer. Si la base de données que nous voulons utiliser n’existe pas dans la liste déroulante, vous pouvez spécifier une nouvelle connexion de base de données en cliquant sur le bouton Nouvelle connexion et en fournissant les informations de connexion nécessaires.

Première étape de l’Assistant Configuration de TableAdapter

Figure 1 : Première étape de l’Assistant Configuration de TableAdapter (cliquer pour afficher l’image en taille réelle)

Prenons un moment pour inspecter le code de la propriété TableAdapter Connection . Comme indiqué dans le didacticiel Création d’une couche d’accès aux données , nous pouvons afficher le code TableAdapter généré automatiquement en accédant à la fenêtre Affichage de classes, en effectuant une exploration jusqu’à la classe appropriée, puis en double-cliquant sur le nom du membre.

Accédez à la fenêtre Affichage de classe en accédant au menu Affichage et en choisissant Affichage de la classe (ou en tapant Ctrl+Maj+C). Dans la moitié supérieure de la fenêtre Affichage de classes, accédez à l’espace NorthwindTableAdapters de noms et sélectionnez la ProductsTableAdapter classe. Cela affiche les ProductsTableAdapter membres s dans la moitié inférieure de l’affichage de classes, comme illustré dans la figure 2. Double-cliquez sur la Connection propriété pour afficher son code.

Double-cliquez sur la propriété Connection dans l’affichage de classe pour afficher son code généré automatiquement

Figure 2 : Double-Click la propriété Connection dans l’affichage de classe pour afficher son code généré automatiquement

La propriété TableAdapter et d’autres Connection codes liés à la connexion sont les suivants :

private System.Data.SqlClient.SqlConnection _connection;
private void InitConnection() {
    this._connection = new System.Data.SqlClient.SqlConnection();
    this._connection.ConnectionString = 
        ConfigurationManager.ConnectionStrings["NORTHWNDConnectionString"].ConnectionString;
}
internal System.Data.SqlClient.SqlConnection Connection {
    get {
        if ((this._connection == null)) {
            this.InitConnection();
        }
        return this._connection;
    }
    set {
        this._connection = value;
        if ((this.Adapter.InsertCommand != null)) {
            this.Adapter.InsertCommand.Connection = value;
        }
        if ((this.Adapter.DeleteCommand != null)) {
            this.Adapter.DeleteCommand.Connection = value;
        }
        if ((this.Adapter.UpdateCommand != null)) {
            this.Adapter.UpdateCommand.Connection = value;
        }
        for (int i = 0; (i < this.CommandCollection.Length); i = (i + 1)) {
            if ((this.CommandCollection[i] != null)) {
                ((System.Data.SqlClient.SqlCommand)
                    (this.CommandCollection[i])).Connection = value;
            }
        }
    }
}

Lorsque la classe TableAdapter est instanciée, la variable _connection membre est égale à null. Lorsque la Connection propriété est accessible, elle vérifie d’abord si la _connection variable membre a été instanciée. Si ce n’est pas le cas, la InitConnection méthode est appelée, ce qui instancie _connection et définit sa ConnectionString propriété sur la valeur chaîne de connexion spécifiée à partir de la première étape de l’Assistant Configuration de TableAdapter.

La Connection propriété peut également être affectée à un SqlConnection objet . Cela permet d’associer le nouvel SqlConnection objet à chacun des objets de SqlCommand TableAdapter.

Étape 2 : Exposition des paramètres de Connection-Level

Les informations de connexion doivent rester encapsulées dans TableAdapter et ne doivent pas être accessibles aux autres couches de l’architecture de l’application. Toutefois, il peut exister des scénarios où les informations de niveau de connexion de TableAdapter doivent être accessibles ou personnalisables pour une requête, un utilisateur ou une page ASP.NET.

Étendons le ProductsTableAdapter dans le Northwind DataSet pour inclure une ConnectionString propriété qui peut être utilisée par la couche de logique métier pour lire ou modifier les chaîne de connexion utilisées par TableAdapter.

Notes

Une chaîne de connexion est une chaîne qui spécifie les informations de connexion à la base de données, telles que le fournisseur à utiliser, l’emplacement de la base de données, les informations d’identification d’authentification et d’autres paramètres liés à la base de données. Pour obtenir la liste des modèles chaîne de connexion utilisés par divers magasins de données et fournisseurs, consultez ConnectionStrings.com.

Comme indiqué dans le didacticiel Création d’une couche d’accès aux données , les classes générées automatiquement par le DataSet typé peuvent être étendues à l’aide de classes partielles. Tout d’abord, créez un sous-dossier dans le projet nommé ConnectionAndCommandSettings sous le ~/App_Code/DAL dossier .

Ajouter un sous-dossier nommé ConnectionAndCommandSettings

Figure 3 : Ajouter un sous-dossier nommé ConnectionAndCommandSettings

Ajoutez un nouveau fichier de classe nommé ProductsTableAdapter.ConnectionAndCommandSettings.cs et entrez le code suivant :

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
namespace NorthwindTableAdapters
{
    public partial class ProductsTableAdapter
    {
        public string ConnectionString
        {
            get
            {
                return this.Connection.ConnectionString;
            }
            set
            {
                this.Connection.ConnectionString = value;
            }
        }
    }
}

Cette classe partielle ajoute une public propriété nommée ConnectionString à la ProductsTableAdapter classe qui permet à n’importe quelle couche de lire ou de mettre à jour les chaîne de connexion pour la connexion sous-jacente de TableAdapter.

Une fois cette classe partielle créée (et enregistrée), ouvrez la ProductsBLL classe . Accédez à l’une des méthodes existantes, tapez Adapter , puis appuyez sur la touche point pour afficher IntelliSense. Vous devez voir la nouvelle ConnectionString propriété disponible dans IntelliSense, ce qui signifie que vous pouvez lire ou ajuster par programmation cette valeur à partir de la BLL.

Exposition de l’objet de connexion entier

Cette classe partielle expose une seule propriété de l’objet de connexion sous-jacent : ConnectionString. Si vous souhaitez rendre l’objet de connexion entier disponible au-delà des limites de TableAdapter, vous pouvez également modifier le niveau de protection de la Connection propriété. Le code généré automatiquement que nous avons examiné à l’étape 1 a montré que la propriété TableAdapter Connection est marquée comme internal, ce qui signifie qu’elle n’est accessible que par les classes du même assembly. Cela peut toutefois être modifié via la propriété TableAdapter ConnectionModifier .

Ouvrez le Northwind DataSet, cliquez sur dans le ProductsTableAdapter Designer, puis accédez au Fenêtre Propriétés. Vous verrez alors défini sur ConnectionModifier sa valeur par défaut, Assembly. Pour rendre la Connection propriété disponible en dehors de l’assembly de Typed DataSet, remplacez la propriété par ConnectionModifierPublic.

Le niveau d’accessibilité de la propriété de connexion peut être configuré via la propriété ConnectionModifier

Figure 4 : Le Connection niveau d’accessibilité de la propriété peut être configuré via la ConnectionModifier propriété (cliquez pour afficher l’image en taille réelle)

Enregistrez le DataSet, puis revenez à la ProductsBLL classe . Comme précédemment, accédez à l’une des méthodes existantes et tapez, Adapter puis appuyez sur la touche point pour afficher IntelliSense. La liste doit inclure une Connection propriété, ce qui signifie que vous pouvez désormais lire ou affecter par programmation tous les paramètres au niveau de la connexion à partir de la BLL.

Un TableAdapter se compose d’une requête main qui, par défaut, a des instructions , UPDATEet DELETE générées INSERTautomatiquement. Cette main instructions de INSERTrequête , UPDATEet DELETE sont implémentées dans le code de TableAdapter en tant qu’objet adaptateur de données ADO.NET via la Adapter propriété . Comme avec sa Connection propriété, le type de données de la Adapter propriété est déterminé par le fournisseur de données utilisé. Étant donné que ces didacticiels utilisent le fournisseur SqlClient, la Adapter propriété est de type SqlDataAdapter.

La propriété TableAdapter a Adapter trois propriétés de type SqlCommand qu’elle utilise pour émettre les INSERTinstructions , UPDATEet DELETE :

  • InsertCommand
  • UpdateCommand
  • DeleteCommand

Un SqlCommand objet est chargé d’envoyer une requête particulière à la base de données et possède des propriétés telles que : CommandText, qui contient l’instruction SQL ad hoc ou la procédure stockée à exécuter ; et Parameters, qui est une collection d’objets SqlParameter . Comme nous l’avons vu dans le didacticiel Création d’une couche d’accès aux données, ces objets de commande peuvent être personnalisés via le Fenêtre Propriétés.

En plus de sa requête main, l’objet TableAdapter peut inclure un nombre variable de méthodes qui, lorsqu’elles sont appelées, distribuent une commande spécifiée à la base de données. L’objet de commande main requête et les objets de commande pour toutes les méthodes supplémentaires sont stockés dans la propriété TableAdapter.CommandCollection

Prenons un moment pour examiner le code généré par dans le ProductsTableAdapterNorthwind DataSet pour ces deux propriétés et leurs variables membres et méthodes d’assistance de prise en charge :

private System.Data.SqlClient.SqlDataAdapter _adapter;
private void InitAdapter() {
    this._adapter = new System.Data.SqlClient.SqlDataAdapter();
    
    ... Code that creates the InsertCommand, UpdateCommand, ...
    ... and DeleteCommand instances - omitted for brevity ...
}
private System.Data.SqlClient.SqlDataAdapter Adapter {
    get {
        if ((this._adapter == null)) {
            this.InitAdapter();
        }
        return this._adapter;
    }
}
private System.Data.SqlClient.SqlCommand[] _commandCollection;
private void InitCommandCollection() {
    this._commandCollection = new System.Data.SqlClient.SqlCommand[9];
    ... Code that creates the command objects for the main query and the ...
    ... ProductsTableAdapter�s other eight methods - omitted for brevity ...
}
protected System.Data.SqlClient.SqlCommand[] CommandCollection {
    get {
        if ((this._commandCollection == null)) {
            this.InitCommandCollection();
        }
        return this._commandCollection;
    }
}

Le code des Adapter propriétés et CommandCollection imite étroitement celui de la Connection propriété . Il existe des variables membres qui contiennent les objets utilisés par les propriétés. Les accesseurs de propriétés get commencent par vérifier si la variable membre correspondante est null. Dans ce cas, une méthode d’initialisation est appelée qui crée une instance de la variable membre et affecte les propriétés principales liées à la commande.

Étape 4 : Exposition des paramètres de Command-Level

Dans l’idéal, les informations au niveau de la commande doivent rester encapsulées dans la couche d’accès aux données. Toutefois, si ces informations sont nécessaires dans d’autres couches de l’architecture, elles peuvent être exposées via une classe partielle, comme avec les paramètres au niveau de la connexion.

Étant donné que TableAdapter n’a qu’une seule Connection propriété, le code permettant d’exposer les paramètres au niveau de la connexion est assez simple. Les choses sont un peu plus compliquées lors de la modification des paramètres au niveau de la commande, car tableAdapter peut avoir plusieurs objets de commande - un InsertCommand, UpdateCommandet , ainsi DeleteCommandqu’un nombre variable d’objets de commande dans la CommandCollection propriété. Lors de la mise à jour des paramètres au niveau de la commande, ces paramètres doivent être propagés à tous les objets de commande.

Par exemple, imaginez que l’exécution de certaines requêtes dans TableAdapter a pris un temps extraordinaire. Lorsque vous utilisez TableAdapter pour exécuter l’une de ces requêtes, nous pouvons souhaiter augmenter la propriété s de l’objet de CommandTimeoutcommande. Cette propriété spécifie le nombre de secondes d’attente avant l’exécution de la commande et la valeur par défaut est 30.

Pour permettre à la CommandTimeout propriété d’être ajustée par le BLL, ajoutez la méthode suivante public à l’aide du fichier de classe partiel créé à l’étape ProductsDataTable 2 (ProductsTableAdapter.ConnectionAndCommandSettings.cs) :

public void SetCommandTimeout(int timeout)
{
    if (this.Adapter.InsertCommand != null)
        this.Adapter.InsertCommand.CommandTimeout = timeout;
    if (this.Adapter.DeleteCommand != null)
        this.Adapter.DeleteCommand.CommandTimeout = timeout;
    if (this.Adapter.UpdateCommand != null)
        this.Adapter.UpdateCommand.CommandTimeout = timeout;
    for (int i = 0; i < this.CommandCollection.Length; i++)
        if (this.CommandCollection[i] != null)
            this.CommandCollection[i].CommandTimeout = timeout;
}

Cette méthode peut être appelée à partir du BLL ou de la couche de présentation pour définir le délai d’expiration de la commande pour tous les problèmes de commandes par cette instance TableAdapter.

Notes

Les Adapter propriétés et CommandCollection sont marquées comme private, ce qui signifie qu’elles sont accessibles uniquement à partir du code dans TableAdapter. Contrairement à la Connection propriété, ces modificateurs d’accès ne sont pas configurables. Par conséquent, si vous devez exposer des propriétés au niveau de la commande à d’autres couches de l’architecture, vous devez utiliser l’approche de classe partielle décrite ci-dessus pour fournir une méthode ou une public propriété qui lit ou écrit dans les private objets de commande.

Résumé

Les TableAdapters dans un DataSet typé servent à encapsuler les détails et la complexité de l’accès aux données. À l’aide de TableAdapters, nous n’avons pas à nous soucier de l’écriture de ADO.NET code pour se connecter à la base de données, émettre une commande ou remplir les résultats dans un DataTable. Tout est géré automatiquement pour nous.

Toutefois, il peut arriver que nous ayons besoin de personnaliser les spécificités des ADO.NET de bas niveau, telles que la modification du chaîne de connexion ou des valeurs de délai d’expiration de connexion ou de commande par défaut. TableAdapter a des propriétés , Adapteret générées Connectionautomatiquement, mais celles-ci sont internal ou privateCommandCollection , par défaut. Ces informations internes peuvent être exposées en étendant TableAdapter à l’aide de classes partielles pour inclure des public méthodes ou des propriétés. Vous pouvez également configurer le modificateur d’accès à la Connection propriété TableAdapter via la propriété s ConnectionModifier TableAdapter.

Bonne programmation !

À propos de l’auteur

Scott Mitchell, auteur de sept livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille comme consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 in 24 Heures. Il est accessible à l’adressemitchell@4GuysFromRolla.com . ou via son blog, qui peut être trouvé à l’adresse http://ScottOnWriting.NET.

Un merci spécial à

Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. Les principaux réviseurs de ce tutoriel étaient Burnadette Leigh, S ren Jacob Lauritsen, Teresa Murphy et Hilton Geisenow. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com.

PrécédentSuivant