Utilisation de colonnes calculées (VB)

par Scott Mitchell

Télécharger le PDF

Lors de la création d’une table de base de données, Microsoft SQL Server vous permet de définir une colonne calculée dont la valeur est calculée à partir d’une expression qui référence généralement d’autres valeurs dans le même enregistrement de base de données. Ces valeurs sont en lecture seule sur la base de données, ce qui nécessite des considérations particulières lors de l’utilisation de TableAdapters. Dans ce tutoriel, nous apprenons à relever les défis posés par les colonnes calculées.

Introduction

Microsoft SQL Server permet des colonnes calculées, qui sont des colonnes dont les valeurs sont calculées à partir d’une expression qui référence généralement les valeurs d’autres colonnes dans la même table. Par exemple, un modèle de données de suivi du temps peut avoir une table nommée ServiceLog avec des colonnes, notamment ServicePerformed, EmployeeIDRateet Duration, entre autres. Même si le montant dû par élément de service (étant le taux multiplié par la durée) peut être calculé par le biais d’une page web ou d’une autre interface programmatique, il peut être utile d’inclure une colonne dans la ServiceLog table nommée AmountDue qui a signalé ces informations. Cette colonne peut être créée en tant que colonne normale, mais elle doit être mise à jour chaque fois que les Rate valeurs de colonne ont Duration changé. Une meilleure approche consisterait à faire de la AmountDue colonne une colonne calculée à l’aide de l’expression Rate * Duration. Cela entraînerait le calcul automatique de la valeur de la AmountDue colonne par SQL Server chaque fois qu’elle a été référencée dans une requête.

Étant donné qu’une valeur de colonne calculée est déterminée par une expression, ces colonnes sont en lecture seule et ne peuvent donc pas avoir de valeurs affectées dans ou UPDATE instructionsINSERT. Toutefois, lorsque les colonnes calculées font partie de la requête principale d’une TableAdapter qui utilise des instructions SQL ad hoc, elles sont automatiquement incluses dans les instructions générées et UPDATE générées automatiquementINSERT. Par conséquent, les requêtes InsertCommand UpdateCommand et UPDATE propriétés tableAdapter INSERT doivent être mises à jour pour supprimer les références à toutes les colonnes calculées.

L’un des défis liés à l’utilisation de colonnes calculées avec un TableAdapter qui utilise des instructions SQL ad hoc est que les requêtes et UPDATE les s INSERT TableAdapter sont régénérées automatiquement chaque fois que l’Assistant Configuration de TableAdapter est terminé. Par conséquent, les colonnes calculées supprimées manuellement des INSERT requêtes réapparaîtront UPDATE si l’Assistant est réexécuté. Même si TableAdapters qui utilisent des procédures stockées ne souffrent pas de cette fragilité, ils ont leurs propres bizarreries que nous traiterons à l’étape 3.

Dans ce tutoriel, nous allons ajouter une colonne calculée à la Suppliers table dans la base de données Northwind, puis créer un TableAdapter correspondant pour travailler avec cette table et sa colonne calculée. Nous aurons notre TableAdapter à utiliser des procédures stockées au lieu d’instructions SQL ad hoc afin que nos personnalisations ne soient pas perdues lorsque l’Assistant Configuration de TableAdapter est utilisé.

Commençons !

Étape 1 : Ajout d’une colonne calculée à laSupplierstable

La base de données Northwind n’a pas de colonnes calculées. Nous devons donc en ajouter une. Pour ce tutoriel, nous allons ajouter une colonne calculée à la Suppliers table appelée FullContactName qui retourne le nom, le titre et la société pour laquelle ils travaillent au format suivant : ContactName (ContactTitle, CompanyName). Cette colonne calculée peut être utilisée dans les rapports lors de l’affichage d’informations sur les fournisseurs.

Commencez par ouvrir la définition de Suppliers table en cliquant avec le bouton droit sur la Suppliers table dans l’Explorateur de serveurs et en choisissant Ouvrir la définition de table dans le menu contextuel. Cela affiche les colonnes de la table et leurs propriétés, telles que leur type de données, s’ils autorisent NULL s, etc. Pour ajouter une colonne calculée, commencez par taper le nom de la colonne dans la définition de table. Ensuite, entrez son expression dans la zone de texte (Formule) sous la section Spécification de colonne calculée dans la colonne Fenêtre Propriétés (voir la figure 1). Nommez la colonne FullContactName calculée et utilisez l’expression suivante :

ContactName + ' (' + CASE WHEN ContactTitle IS NOT NULL THEN 
    ContactTitle + ', ' ELSE '' END + CompanyName + ')'

Notez que les chaînes peuvent être concaténées dans SQL à l’aide de l’opérateur + . L’instruction CASE peut être utilisée comme un conditionnel dans un langage de programmation traditionnel. Dans l’expression ci-dessus, l’instruction CASE peut être lue comme suit : Si ContactTitle ce n’est pas NULL le cas, la ContactTitle valeur concaténée avec une virgule, sinon émettre rien. Pour plus d’informations sur l’utilité de l’instructionCASE, consultez Instructions SQLCASE.

Remarque

Au lieu d’utiliser une CASE instruction ici, nous aurions pu également utiliser ISNULL(ContactTitle, ''). ISNULL(checkExpression, replacementValue)retourne checkExpression s’il n’est pas NULL, sinon il retourne replacementValue. Bien que l’une ou CASE l’autre ISNULL fonctionne dans cette instance, il existe des scénarios plus complexes où la flexibilité de l’instruction CASE ne peut pas être mise en correspondance .ISNULL

Après avoir ajouté cette colonne calculée, votre écran doit ressembler à la capture d’écran dans la figure 1.

Figure 1 : Ajouter une colonne calculée nommée FullContactName à la Suppliers table (cliquez pour afficher l’image de taille complète)

Après avoir nommé la colonne calculée et entré son expression, enregistrez les modifications apportées à la table en cliquant sur l’icône Enregistrer dans la barre d’outils, en appuyant sur Ctrl+S, ou en accédant au menu Fichier et en choisissant Enregistrer Suppliers.

L’enregistrement de la table doit actualiser l’Explorateur de serveurs, y compris la colonne juste ajoutée dans la liste des colonnes de la Suppliers table. En outre, l’expression entrée dans la zone de texte (Formule) s’ajuste automatiquement à une expression équivalente qui supprime les espaces blancs inutiles, entoure les noms de colonnes entre crochets ([]) et inclut des parenthèses pour afficher plus explicitement l’ordre des opérations :

(((([ContactName]+' (')+case when [ContactTitle] IS NOT NULL 
    then [ContactTitle]+', ' else '' end)+[CompanyName])+')')

Pour plus d’informations sur les colonnes calculées dans Microsoft SQL Server, consultez la documentation technique. Consultez également la procédure à suivre pour spécifier des colonnes calculées pour une procédure pas à pas de création de colonnes calculées.

Remarque

Par défaut, les colonnes calculées ne sont pas stockées physiquement dans la table, mais sont recalculées chaque fois qu’elles sont référencées dans une requête. En cochant la case à cocher Conserver, vous pouvez toutefois indiquer à SQL Server de stocker physiquement la colonne calculée dans la table. Cela permet de créer un index sur la colonne calculée, ce qui peut améliorer les performances des requêtes qui utilisent la valeur de colonne calculée dans leurs WHERE clauses. Pour plus d’informations, consultez Création d’index sur des colonnes calculées.

Étape 2 : affichage des valeurs des colonnes calculées

Avant de commencer à travailler sur la couche d’accès aux données, prenons une minute pour afficher les FullContactName valeurs. Dans l’Explorateur de serveurs, cliquez avec le bouton droit sur le nom de la Suppliers table et choisissez Nouvelle requête dans le menu contextuel. Cette opération affiche une fenêtre de requête qui nous invite à choisir les tables à inclure dans la requête. Ajoutez la Suppliers table, puis cliquez sur Fermer. Ensuite, vérifiez les colonnes et ContactTitleFullContactName les CompanyNameContactNamecolonnes de la table Fournisseurs. Enfin, cliquez sur l’icône de point d’exclamation rouge dans la barre d’outils pour exécuter la requête et afficher les résultats.

Comme le montre la figure 2, les résultats incluent FullContactName, qui répertorient les colonnes ContactNameet ContactTitle le CompanyNameformat ContactName (ContactTitle, CompanyName) .

Figure 2 : Utilisation FullContactName du format ContactName (, CompanyName) (ContactTitleCliquez pour afficher l’image de taille complète)

Étape 3 : Ajout deSuppliersTableAdapterla couche d’accès aux données

Pour travailler avec les informations du fournisseur dans notre application, nous devons d’abord créer un TableAdapter et DataTable dans notre DAL. Dans l’idéal, cela serait effectué à l’aide des mêmes étapes simples examinées dans les didacticiels précédents. Toutefois, l’utilisation de colonnes calculées introduit quelques rides qui méritent une discussion.

Si vous utilisez un TableAdapter qui utilise des instructions SQL ad hoc, vous pouvez simplement inclure la colonne calculée dans la requête principale de TableAdapter via l’Assistant Configuration de TableAdapter. Cela, toutefois, génère et génère INSERT automatiquement des UPDATE instructions qui incluent la colonne calculée. Si vous tentez d’exécuter l’une de ces méthodes, un SqlException message avec la colonne ColumnName ne peut pas être modifié, car il s’agit d’une colonne calculée ou est le résultat d’un opérateur UNION sera levée. Bien que l’instruction et l’instruction INSERT puissent être ajustées manuellement par le biais des propriétés et UpdateCommand des s InsertCommand TableAdapter, ces personnalisations seront perdues chaque fois que l’Assistant Configuration de TableAdapter est réexécuté.UPDATE

En raison de la fragilité des TableAdapters qui utilisent des instructions SQL ad hoc, il est recommandé d’utiliser des procédures stockées lors de l’utilisation de colonnes calculées. Si vous utilisez des procédures stockées existantes, configurez simplement TableAdapter comme indiqué dans le didacticiel Utilisation des procédures stockées existantes pour le didacticiel TableAdapters de Typed DataSet. Si vous disposez de l’Assistant TableAdapter, créez les procédures stockées pour vous, mais il est important d’omettre initialement toutes les colonnes calculées de la requête principale. Si vous incluez une colonne calculée dans la requête principale, l’Assistant Configuration de TableAdapter vous informe, à la fin, qu’il ne peut pas créer les procédures stockées correspondantes. En bref, nous devons initialement configurer TableAdapter à l’aide d’une requête principale sans colonne calculée, puis mettre à jour manuellement la procédure stockée correspondante et les tablesAdapter SelectCommand pour inclure la colonne calculée. Cette approche est similaire à celle utilisée dans le didacticiel De mise à jour de TableAdapter pour utiliserJOINs.

Pour ce tutoriel, nous allons ajouter un nouveau TableAdapter et créer automatiquement les procédures stockées pour nous. Par conséquent, nous devons initialement omettre la FullContactName colonne calculée de la requête principale.

Commencez par ouvrir le NorthwindWithSprocs DataSet dans le ~/App_Code/DAL dossier. Cliquez avec le bouton droit dans le Concepteur et, dans le menu contextuel, choisissez d’ajouter un nouveau TableAdapter. Cette opération lance l’Assistant Configuration de TableAdapter. Spécifiez la base de données à partir de (NORTHWNDConnectionString à partir de Web.config) et cliquez sur Suivant. Étant donné que nous n’avons pas encore créé de procédures stockées pour interroger ou modifier la Suppliers table, sélectionnez l’option Créer de nouvelles procédures stockées afin que l’Assistant les crée pour nous, puis cliquez sur Suivant.

Figure 3 : Choisir l’option Créer de nouvelles procédures stockées (cliquez pour afficher l’image de taille complète)

L’étape suivante nous invite à entrer la requête principale. Entrez la requête suivante, qui retourne les colonnes , CompanyNameContactNameet ContactTitle les SupplierIDcolonnes pour chaque fournisseur. Notez que cette requête omet délibérément la colonne calculée (FullContactName) ; nous allons mettre à jour la procédure stockée correspondante pour inclure cette colonne à l’étape 4.

SELECT SupplierID, CompanyName, ContactName, ContactTitle
FROM Suppliers

Après avoir entré la requête principale et cliqué sur Suivant, l’Assistant nous permet de nommer les quatre procédures stockées qu’il génère. Nommez ces procédures Suppliers_Selectstockées, Suppliers_InsertetSuppliers_UpdateSuppliers_Delete, comme l’illustre la figure 4.

Figure 4 : Personnaliser les noms des procédures stockées générées automatiquement (cliquez pour afficher l’image de taille complète)

L’étape suivante de l’Assistant nous permet de nommer les méthodes de TableAdapter et de spécifier les modèles utilisés pour accéder aux données et les mettre à jour. Laissez les trois cases à cocher cochées, mais renommez la GetData méthode GetSuppliersen . Cliquez sur Terminer pour terminer l’Assistant.

Figure 5 : Renommer la méthode en GetSuppliers (Cliquer pour afficher l’image GetDatade taille complète)

Lorsque vous cliquez sur Terminer, l’Assistant crée les quatre procédures stockées et ajoute TableAdapter et DataTable correspondant au DataSet typé.

Étape 4 : Inclusion de la colonne calculée dans la requête principale de TableAdapter

Nous devons maintenant mettre à jour TableAdapter et DataTable créés à l’étape 3 pour inclure la FullContactName colonne calculée. Cela implique deux étapes :

1. Mise à jour de la Suppliers_Select procédure stockée pour retourner la FullContactName colonne calculée et
2. Mise à jour de DataTable pour inclure une colonne correspondante FullContactName .

Commencez par accéder à l’Explorateur de serveurs et explorer le dossier Procédures stockées. Ouvrez la Suppliers_Select procédure stockée et mettez à jour la SELECT requête pour inclure la FullContactName colonne calculée :

SELECT SupplierID, CompanyName, ContactName, ContactTitle, FullContactName
FROM Suppliers

Enregistrez les modifications apportées à la procédure stockée en cliquant sur l’icône Enregistrer dans la barre d’outils, en appuyant sur Ctrl+S ou en choisissant l’option Enregistrer Suppliers_Select dans le menu Fichier.

Ensuite, revenez au Concepteur DataSet, cliquez avec le bouton droit sur le SuppliersTableAdapterbouton droit, puis choisissez Configurer dans le menu contextuel. Notez que la Suppliers_Select colonne inclut désormais la FullContactName colonne dans sa collection Colonnes de données.

Figure 6 : Exécuter l’Assistant Configuration de TableAdapter pour mettre à jour les colonnes de DataTable (cliquez pour afficher l’image de taille complète)

Cliquez sur Terminer pour terminer l’Assistant. Cela ajoute automatiquement une colonne correspondante au SuppliersDataTable. L’Assistant TableAdapter est suffisamment intelligent pour détecter que la FullContactName colonne est une colonne calculée et par conséquent en lecture seule. Par conséquent, elle définit la propriété de la ReadOnly colonne sur true. Pour vérifier cela, sélectionnez la colonne à partir de la SuppliersDataTable Fenêtre Propriétés, puis accédez à la Fenêtre Propriétés (voir la figure 7). Notez que les FullContactName propriétés et MaxLength les colonnes DataType sont également définies en conséquence.

Figure 7 : La FullContactName colonne est marquée en lecture seule (cliquez pour afficher l’image de taille complète)

Étape 5 : Ajout d’uneGetSupplierBySupplierIDméthode à TableAdapter

Pour ce tutoriel, nous allons créer une page ASP.NET qui affiche les fournisseurs dans une grille modifiable. Dans les didacticiels précédents, nous avons mis à jour un enregistrement unique à partir de la couche logique métier en récupérant cet enregistrement particulier à partir de la base de données en tant que DataTable fortement typé, en mettant à jour ses propriétés, puis en envoyant le DataTable mis à jour au DAL pour propager les modifications apportées à la base de données. Pour effectuer cette première étape : récupération de l’enregistrement mis à jour à partir de la dal , nous devons d’abord ajouter une GetSupplierBySupplierID(supplierID) méthode au dal.

Cliquez avec le SuppliersTableAdapter bouton droit sur la conception du Jeu de données et choisissez l’option Ajouter une requête dans le menu contextuel. Comme nous l’avons fait à l’étape 3, laissez l’Assistant générer une nouvelle procédure stockée pour nous en sélectionnant l’option Créer une procédure stockée (reportez-vous à la figure 3 pour obtenir une capture d’écran de cette étape de l’Assistant). Étant donné que cette méthode retourne un enregistrement avec plusieurs colonnes, indiquez que nous voulons utiliser une requête SQL qui est une requête SELECT qui retourne des lignes, puis cliquez sur Suivant.

Figure 8 : Choisissez l’option SELECT qui retourne l’option lignes (cliquez pour afficher l’image de taille complète)

L’étape suivante nous invite à utiliser la requête pour cette méthode. Entrez ce qui suit, qui retourne les mêmes champs de données que la requête principale, mais pour un fournisseur particulier.

SELECT SupplierID, CompanyName, ContactName, ContactTitle, FullContactName
FROM Suppliers
WHERE SupplierID = @SupplierID

L’écran suivant nous demande de nommer la procédure stockée qui sera générée automatiquement. Nommez cette procédure Suppliers_SelectBySupplierID stockée, puis cliquez sur Suivant.

Figure 9 : Nommer la procédure Suppliers_SelectBySupplierID stockée (cliquez pour afficher l’image de taille complète)

Enfin, l’Assistant nous invite à entrer les modèles d’accès aux données et les noms de méthodes à utiliser pour TableAdapter. Laissez les deux cases cochées, mais renommez respectivement les méthodes et GetSupplierBySupplierIDGetDataBy les FillBy méthodesFillBySupplierID.

Figure 10 : Nommez les méthodes FillBySupplierID TableAdapter et GetSupplierBySupplierID (Cliquez pour afficher l’image de taille complète)

Cliquez sur Terminer pour terminer l’Assistant.

Étape 6 : Création de la couche logique métier

Avant de créer une page ASP.NET qui utilise la colonne calculée créée à l’étape 1, nous devons d’abord ajouter les méthodes correspondantes dans la BLL. Notre page ASP.NET, que nous allons créer à l’étape 7, permettra aux utilisateurs d’afficher et de modifier les fournisseurs. Par conséquent, nous avons besoin de notre BLL pour fournir, au minimum, une méthode pour obtenir tous les fournisseurs et une autre pour mettre à jour un fournisseur particulier.

Créez un fichier de classe nommé SuppliersBLLWithSprocs dans le ~/App_Code/BLL dossier et ajoutez le code suivant :

Imports NorthwindWithSprocsTableAdapters
<System.ComponentModel.DataObject()> _
Public Class SuppliersBLLWithSprocs
    Private _suppliersAdapter As SuppliersTableAdapter = Nothing
    Protected ReadOnly Property Adapter() As SuppliersTableAdapter
        Get
            If _suppliersAdapter Is Nothing Then
                _suppliersAdapter = New SuppliersTableAdapter()
            End If
            Return _suppliersAdapter
        End Get
    End Property
    <System.ComponentModel.DataObjectMethodAttribute _
        (System.ComponentModel.DataObjectMethodType.Select, True)> _
    Public Function GetSuppliers() As NorthwindWithSprocs.SuppliersDataTable
        Return Adapter.GetSuppliers()
    End Function
    <System.ComponentModel.DataObjectMethodAttribute _
        (System.ComponentModel.DataObjectMethodType.Update, True)> _
    Public Function UpdateSupplier(companyName As String, contactName As String, _
        contactTitle As String, supplierID As Integer) As Boolean
        Dim suppliers As NorthwindWithSprocs.SuppliersDataTable = _
            Adapter.GetSupplierBySupplierID(supplierID)
        If suppliers.Count = 0 Then
            ' no matching record found, return false
            Return False
        End If
        Dim supplier As NorthwindWithSprocs.SuppliersRow = suppliers(0)
        supplier.CompanyName = companyName
        If contactName Is Nothing Then 
            supplier.SetContactNameNull() 
        Else 
            supplier.ContactName = contactName
        End If
        If contactTitle Is Nothing Then 
            supplier.SetContactTitleNull() 
        Else 
            supplier.ContactTitle = contactTitle
        End If
        ' Update the product record
        Dim rowsAffected As Integer = Adapter.Update(supplier)
        ' Return true if precisely one row was updated, otherwise false
        Return rowsAffected = 1
    End Function
End Class

Comme les autres classes BLL, SuppliersBLLWithSprocs a une Protected Adapter propriété qui retourne une instance de la SuppliersTableAdapter classe avec deux Public méthodes : GetSuppliers et UpdateSupplier. La GetSuppliers méthode appelle et retourne la SuppliersDataTable méthode retournée par la méthode correspondante GetSupplier dans la couche d’accès aux données. La UpdateSupplier méthode récupère des informations sur le fournisseur particulier mis à jour via un appel à la méthode DAL.GetSupplierBySupplierID(supplierID) Il met ensuite à jour les CategoryNamepropriétés , ContactNameet ContactTitle valide ces modifications dans la base de données en appelant la méthode Data Access Layer, Update en passant l’objet modifié SuppliersRow .

Remarque

SupplierID À l’exception et CompanyName, toutes les colonnes de la table Fournisseurs autorisent NULL les valeurs. Par conséquent, si les paramètres passés ou contactTitle les contactName paramètres doivent Nothing définir les propriétés et ContactTitle les correspondantes ContactName sur une NULL valeur de base de données à l’aide des méthodes et SetContactTitleNull des SetContactNameNull méthodes, respectivement.

Étape 7 : Utilisation de la colonne calculée à partir de la couche Présentation

Avec la colonne calculée ajoutée à la Suppliers table et la dal et BLL mises à jour en conséquence, nous sommes prêts à créer une page ASP.NET qui fonctionne avec la FullContactName colonne calculée. Commencez par ouvrir la ComputedColumns.aspx page dans le AdvancedDAL dossier et faites glisser un GridView à partir de la boîte à outils sur le Concepteur. Définissez la propriété GridView ID sur Suppliers et, à partir de sa balise active, liez-la à un nouvel ObjectDataSource nommé SuppliersDataSource. Configurez ObjectDataSource pour utiliser la classe que nous avons ajoutée à l’étape SuppliersBLLWithSprocs 6, puis cliquez sur Suivant.

Figure 11 : Configurer ObjectDataSource pour utiliser la classe (Cliquez pour afficher l’image SuppliersBLLWithSprocsde taille complète)

Il n’existe que deux méthodes définies dans la SuppliersBLLWithSprocs classe : GetSuppliers et UpdateSupplier. Vérifiez que ces deux méthodes sont spécifiées dans les onglets SELECT et UPDATE, respectivement, puis cliquez sur Terminer pour terminer la configuration de ObjectDataSource.

Une fois l’Assistant Configuration de source de données terminée, Visual Studio ajoute un Objet BoundField pour chacun des champs de données retournés. SupplierID Supprimez BoundField et modifiez les HeaderText propriétés de l’objet CompanyName, et ContactNameContactTitleFullContactName BoundFields en nom d’entreprise, nom du contact, titre et nom du contact complet, respectivement. À partir de la balise active, cochez la case Activer la modification pour activer les fonctionnalités d’édition intégrées de GridView.

Outre l’ajout de BoundFields à GridView, l’achèvement de l’Assistant Source de données entraîne également la définition de la propriété ObjectDataSource par OldValuesParameterFormatString Visual Studio sur original_{0}. Rétablissez cette valeur par défaut. {0}

Après avoir apporté ces modifications à GridView et ObjectDataSource, leur balisage déclaratif doit ressembler à ce qui suit :

<asp:GridView ID="Suppliers" runat="server" AutoGenerateColumns="False" 
    DataKeyNames="SupplierID" DataSourceID="SuppliersDataSource">
    <Columns>
        <asp:CommandField ShowEditButton="True" />
        <asp:BoundField DataField="CompanyName" 
            HeaderText="Company" 
            SortExpression="CompanyName" />
        <asp:BoundField DataField="ContactName" 
            HeaderText="Contact Name" 
            SortExpression="ContactName" />
        <asp:BoundField DataField="ContactTitle" 
            HeaderText="Title" 
            SortExpression="ContactTitle" />
        <asp:BoundField DataField="FullContactName" 
            HeaderText="Full Contact Name"
            SortExpression="FullContactName" 
            ReadOnly="True" />
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="SuppliersDataSource" runat="server"
    SelectMethod="GetSuppliers" TypeName="SuppliersBLLWithSprocs" 
        UpdateMethod="UpdateSupplier">
    <UpdateParameters>
        <asp:Parameter Name="companyName" Type="String" />
        <asp:Parameter Name="contactName" Type="String" />
        <asp:Parameter Name="contactTitle" Type="String" />
        <asp:Parameter Name="supplierID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

Ensuite, visitez cette page via un navigateur. Comme le montre la figure 12, chaque fournisseur est répertorié dans une grille qui inclut la colonne, dont la FullContactName valeur est simplement la concaténation des trois autres colonnes mises en forme comme ContactName (ContactTitle, CompanyName) .

Figure 12 : Chaque fournisseur est répertorié dans la grille (cliquez pour afficher l’image de taille complète)

Le fait de cliquer sur le bouton Modifier pour un fournisseur particulier provoque une publication différée et affiche cette ligne dans son interface d’édition (voir la figure 13). Les trois premières colonnes s’affichent dans leur interface d’édition par défaut : un contrôle TextBox dont Text la propriété est définie sur la valeur du champ de données. Toutefois, la FullContactName colonne reste en tant que texte. Lorsque les boundFields ont été ajoutés à GridView à l’achèvement de l’Assistant Configuration de la source de données, la FullContactName propriété BoundField a ReadOnly été définie True sur car la colonne correspondante FullContactName dans la SuppliersDataTable propriété a ReadOnly la valeur True. Comme indiqué à l’étape 4, la FullContactName propriété s’est ReadOnly définie True sur car TableAdapter a détecté que la colonne était une colonne calculée.

Figure 13 : La FullContactName colonne n’est pas modifiable (cliquez pour afficher l’image de taille complète)

Passez en avant et mettez à jour la valeur d’une ou plusieurs colonnes modifiables, puis cliquez sur Mettre à jour. Notez comment la FullContactName valeur de s est automatiquement mise à jour pour refléter la modification.

Remarque

GridView utilise actuellement BoundFields pour les champs modifiables, ce qui entraîne l’interface d’édition par défaut. Étant donné que le CompanyName champ est requis, il doit être converti en modèleField qui inclut un RequiredFieldValidator. Je laisse cela comme un exercice pour le lecteur intéressé. Consultez le didacticiel Ajout de contrôles de validation au didacticiel d’édition et d’insertion d’interfaces pour obtenir des instructions pas à pas sur la conversion d’un objet BoundField en modèleField et l’ajout de contrôles de validation.

Résumé

Lors de la définition du schéma d’une table, Microsoft SQL Server permet l’inclusion de colonnes calculées. Il s’agit de colonnes dont les valeurs sont calculées à partir d’une expression qui référence généralement les valeurs d’autres colonnes du même enregistrement. Étant donné que les valeurs des colonnes calculées sont basées sur une expression, elles sont en lecture seule et ne peuvent pas être affectées à une valeur dans une INSERT ou UPDATE une instruction. Cela pose des défis lors de l’utilisation d’une colonne calculée dans la requête principale d’un TableAdapter qui tente de générer automatiquement des instructions et des DELETE instructions correspondantes.INSERTUPDATE

Dans ce tutoriel, nous avons abordé les techniques de contournement des défis posés par les colonnes calculées. En particulier, nous avons utilisé des procédures stockées dans notre TableAdapter pour surmonter la fragilité inhérente à TableAdapters qui utilisent des instructions SQL ad hoc. Lorsque l’Assistant TableAdapter crée de nouvelles procédures stockées, il est important que la requête principale omet initialement toutes les colonnes calculées, car leur présence empêche la génération des procédures stockées de modification des données. Une fois que TableAdapter a été initialement configuré, sa SelectCommand procédure stockée peut être retooled pour inclure toutes les colonnes calculées.

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 en tant que consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 en 24 heures. Il peut être accessible à mitchell@4GuysFromRolla.com. ou via son blog, qui peut être trouvé à http://ScottOnWriting.NET.

Merci spécial à

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

PrécédentSuivant