Procédure pas à pas : création d'un contrôle Web ASP.NET lié aux données personnalisé pour ASP.NET 2.0

Article
10/22/2014

Mise à jour : novembre 2007

Cette procédure pas à pas illustre la création d'un contrôle serveur Web lié aux données simple dans ASP.NET version 2.0. Dans ASP.NET 2.0, le modèle de source de données vous permet de lier des contrôles liés aux données aux contrôles de source de données, ce qui permet de déplacer des opérations communes sur les données, telles que la pagination, le tri et la suppression, hors du contrôle lié aux données lui-même. Ce modèle de données génère un contrôle lié aux données plus flexible pour les développeurs de pages et augmente le niveau de réutilisabilité. Le modèle de source de données d'ASP.NET 2.0 prend également en charge la liaison directe à un objet de collecte de données. Pour plus d'informations sur le développement de contrôles liés aux données personnalisés pour le modèle de données ASP.NET 2.0, consultez Développement de contrôles serveur Web liés aux données personnalisés pour ASP.NET 2.0.

Dans cette procédure pas à pas, vous créerez un contrôle lié aux données qui peut créer une liaison à un contrôle de source de données ou tout objet qui implémente l'interface IEnumerable.

Cette procédure pas à pas illustre les tâches suivantes :

Création d'un site Web pour tester le contrôle lié aux données personnalisé avec une compilation dynamique.
Création d'une classe de contrôle lié aux données qui étend la classe de base DataBoundControl. Cette classe affiche une colonne de table qui représente les données liées. Les éléments suivants représentent une vue d'ensemble de ce que la classe de contrôle lié aux données doit fournir :
- Une substitution de la méthode PerformSelect de la classe de contrôle lié aux données de base. Dans cette méthode, les tâches sont effectuées pour lancer la récupération des données.
- Une méthode avec un seul paramètre de type IEnumerable pour recevoir les données retournées. Tout traitement de données qui peut être requis est exécuté dans cette méthode. En tant que dernière étape, la méthode PerformDataBinding est appelée pour lancer la liaison de données.
- Une substitution de la méthode PerformDataBinding. Dans cette méthode, les données récupérées sont énumérées et les contrôles enfants sont ajoutés pour représenter les données.
Inscription du contrôle dans le fichier Web.config.
Test du contrôle dans une page Web ASP.NET.
Compilation du contrôle afin de pouvoir le distribuer comme code binaire.
Test du contrôle serveur lié aux données personnalisé compilé.

Création d'un site Web pour tester le contrôle

Vous pouvez utiliser la compilation dynamique ASP.NET pour tester votre contrôle dans une page sans le compiler dans un assembly. ASP.NET compile de manière dynamique le code placé dans le répertoire App_Code sous la racine d'un site Web ASP.NET. Les classes des fichiers sources du répertoire App_Code sont ainsi accessibles depuis les pages sans être compilées dans des assemblys.

Remarque :
Le répertoire App_Code n'est pas disponible dans ASP.NET 1.0 et 1.1. L'utilisation du répertoire App_Code pour un premier test des contrôles est facultative. Les étapes principales de la génération d'un contrôle serveur sont les mêmes que dans les versions précédentes d'ASP.NET, comme décrit dans la section suivante « Compilation du contrôle dans un assembly ».

Pour créer un site Web pour tester les contrôles liés aux données personnalisés

Créez un site Web nommé ServerControlsTest.

Vous pouvez créer le site dans IIS en tant que répertoire virtuel nommé ServerControlsTest. Pour plus d'informations sur la création et la configuration d'un répertoire virtuel IIS, consultez Comment : créer et configurer des répertoires virtuels dans IIS 5.0 et 6.0.
Créez un répertoire App_Code directement sous le répertoire racine de votre site Web (la racine de l'application Web).

Création de la classe SimpleDataBoundColumn

Dans cette section, vous créerez la classe de contrôle liée aux données qui étend la classe DataBoundControl. Le nouveau contrôle affiche les données liées dans un tableau à une colonne.

Pour créer la classe SimpleDataBoundColumn

Dans le dossier App_Code, créez une classe nommée SimpleDataBoundColumn.cs ou SimpleDataBoundColumn.vb.

Ajoutez le code suivant à votre fichier de classe :

Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.Security.Permissions
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls

Namespace Samples.AspNet.Controls.VB

    <AspNetHostingPermission(SecurityAction.Demand, _
        Level:=AspNetHostingPermissionLevel.Minimal), _
        AspNetHostingPermission(SecurityAction.InheritanceDemand, _
        Level:=AspNetHostingPermissionLevel.Minimal)> _
    Public Class SimpleDataBoundColumn
        Inherits DataBoundControl

        Public Property DataTextField() As String
            Get
                Dim o As Object = ViewState("DataTextField")
                If o Is Nothing Then
                    Return String.Empty
                Else
                    Return CStr(o)
                End If
            End Get
            Set(ByVal value As String)
                ViewState("DataTextField") = value
                If (Initialized) Then
                    OnDataPropertyChanged()
                End If
            End Set
        End Property

        Protected Overrides Sub PerformSelect()
            ' Call OnDataBinding here if bound to a data source using the
            ' DataSource property (instead of a DataSourceID), because the
            ' databinding statement is evaluated before the call to GetData.       
            If Not IsBoundUsingDataSourceID Then
                OnDataBinding(EventArgs.Empty)
            End If

            ' The GetData method retrieves the DataSourceView object from  
            ' the IDataSource associated with the data-bound control.            
            GetData().Select(CreateDataSourceSelectArguments(), _
                AddressOf OnDataSourceViewSelectCallback)

            ' The PerformDataBinding method has completed.
            RequiresDataBinding = False
            MarkAsDataBound()

            ' Raise the DataBound event.
            OnDataBound(EventArgs.Empty)

        End Sub

        Private Sub OnDataSourceViewSelectCallback(ByVal retrievedData As IEnumerable)
            ' Call OnDataBinding only if it has not already been 
            ' called in the PerformSelect method.
            If IsBoundUsingDataSourceID Then
                OnDataBinding(EventArgs.Empty)
            End If
            ' The PerformDataBinding method binds the data in the  
            ' retrievedData collection to elements of the data-bound control.
            PerformDataBinding(retrievedData)

        End Sub

        Protected Overrides Sub PerformDataBinding(ByVal retrievedData As IEnumerable)
            MyBase.PerformDataBinding(retrievedData)

            ' Verify data exists.
            If Not (retrievedData Is Nothing) Then
                Dim tbl As New Table()
                Dim row As TableRow
                Dim cell As TableCell
                Dim dataStr As String = String.Empty

                Dim dataItem As Object
                For Each dataItem In retrievedData
                    ' If the DataTextField was specified get the data
                    ' from that field, otherwise get the data from the first field. 
                    If DataTextField.Length > 0 Then
                        dataStr = DataBinder.GetPropertyValue(dataItem, DataTextField, Nothing)
                    Else
                        Dim props As PropertyDescriptorCollection = TypeDescriptor.GetProperties(dataItem)
                        If props.Count >= 1 Then
                            If Nothing <> props(0).GetValue(dataItem) Then
                                dataStr = props(0).GetValue(dataItem).ToString()
                            End If
                        End If
                    End If

                    row = New TableRow()
                    tbl.Rows.Add(row)
                    cell = New TableCell()
                    cell.Text = dataStr
                    row.Cells.Add(cell)
                Next dataItem

                Controls.Add(tbl)
            End If

        End Sub
    End Class
End Namespace

using System;
using System.Collections;
using System.ComponentModel;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace Samples.AspNet.Controls.CS
{
    [AspNetHostingPermission(SecurityAction.Demand,
       Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand,
        Level = AspNetHostingPermissionLevel.Minimal)]
    public class SimpleDataBoundColumn : DataBoundControl
    {
        public string DataTextField
        {
            get
            {
                object o = ViewState["DataTextField"];
                return ((o == null) ? string.Empty : (string)o);
            }
            set
            {
                ViewState["DataTextField"] = value;
                if (Initialized)
                {
                    OnDataPropertyChanged();
                }
            }
        }

        protected override void PerformSelect()
        {
            // Call OnDataBinding here if bound to a data source using the
            // DataSource property (instead of a DataSourceID), because the
            // databinding statement is evaluated before the call to GetData.       
            if (!IsBoundUsingDataSourceID)
            {
                this.OnDataBinding(EventArgs.Empty);
            }

            // The GetData method retrieves the DataSourceView object from  
            // the IDataSource associated with the data-bound control.            
            GetData().Select(CreateDataSourceSelectArguments(),
                this.OnDataSourceViewSelectCallback);

            // The PerformDataBinding method has completed.
            RequiresDataBinding = false;
            MarkAsDataBound();

            // Raise the DataBound event.
            OnDataBound(EventArgs.Empty);
        }

        private void OnDataSourceViewSelectCallback(IEnumerable retrievedData)
        {
            // Call OnDataBinding only if it has not already been 
            // called in the PerformSelect method.
            if (IsBoundUsingDataSourceID)
            {
                OnDataBinding(EventArgs.Empty);
            }
            // The PerformDataBinding method binds the data in the  
            // retrievedData collection to elements of the data-bound control.
            PerformDataBinding(retrievedData);
        }

        protected override void PerformDataBinding(IEnumerable retrievedData)
        {
            base.PerformDataBinding(retrievedData);

            // Verify data exists.
            if (retrievedData != null)
            {
                Table tbl = new Table();
                TableRow row;
                TableCell cell;
                string dataStr = String.Empty;

                foreach (object dataItem in retrievedData)
                {
                    // If the DataTextField was specified get the data
                    // from that field, otherwise get the data from the first field. 
                    if (DataTextField.Length > 0)
                    {
                        dataStr = DataBinder.GetPropertyValue(dataItem,
                            DataTextField, null);
                    }
                    else
                    {
                        PropertyDescriptorCollection props =
                                TypeDescriptor.GetProperties(dataItem);
                        if (props.Count >= 1)
                        {
                            if (null != props[0].GetValue(dataItem))
                            {
                                dataStr = props[0].GetValue(dataItem).ToString();
                            }
                        }
                    }

                    row = new TableRow();
                    tbl.Rows.Add(row);
                    cell = new TableCell();
                    cell.Text = dataStr;
                    row.Cells.Add(cell);
                }

                this.Controls.Add(tbl); 
            }
        }
    }
}

Explication du code

La classe SimpleDataBoundColumn dérive de la classe de liaison de données de base DataBoundControl. La dérivation de cette classe de base fournit les propriétés de liaison de données exposées DataSourceID, DataSource et DataMember. Ces propriétés exposées permettent à un développeur de pages de spécifier la source de données et une donnée membre spécifique pour créer une liaison à ce contrôle personnalisé.

Pour illustrer l'ajout de propriétés de liaison de données personnalisées supplémentaires, une propriété DataTextField a été ajoutée à la classe SimpleDataBoundColumn. Lorsque le développeur de pages définit la propriété DataTextField, la nouvelle valeur est stockée dans l'état d'affichage. Il appelle également la méthode OnDataPropertyChanged si le contrôle a déjà été initialisé. Cela force le contrôle lié aux données à établir une nouvelle liaison aux données afin que le contrôle puisse utiliser le nouveau paramètre de propriété de liaison de données.

La méthode DataBind substituée est requise et elle inclue la logique pour énumérer l'objet dans la source de données associée et créer les contrôles enfants. Les tâches suivantes doivent être effectuées dans les contrôles liés aux données d'ASP.NET 2.0 dans la méthode DataBind substituée, comme indiqué dans la classe SimpleDataBoundColumn :

La valeur false est recherchée dans la propriété IsBoundUsingDataSourceID pour déterminer si la source de données est spécifiée dans la propriété DataSource.
Si les données à lier sont spécifiées dans la propriété DataSource, la méthode OnDataBinding est appelée pour lier la donnée membre qui est spécifiée dans la propriété DataSource.
La méthode GetData est appelée pour récupérer l'objet DataSourceView qui est associé au contrôle lié aux données.
La méthode Select de l'objet DataSourceView récupéré est appelée pour initier la récupération des données et spécifier la méthode de rappel OnDataSourceViewSelectCallback qui gérera les données récupérées.
Pour indiquer que les tâches de récupération des données de la méthode PerformSelect sont terminées, la propriété RequiresDataBinding a la valeur false, puis la méthode MarkAsDataBound est appelée.
L'événement OnDataBound est déclenché.

La méthode de rappel OnDataSourceViewSelectCallback reçoit les données récupérées. Cette méthode de rappel doit accepter un paramètre unique du type IEnumerable. Tout traitement de données doit avoir lieu ici si le contrôle personnalisé l'exige. Ce contrôle personnalisé utilise les données telles quelles. Par conséquent, aucun traitement de données supplémentaire n'est effectué dans cet exemple. Dans la dernière étape, la méthode PerformDataBinding est appelée pour démarrer le processus de liaison de données.

Dans la substitution de la méthode PerformDataBinding, tous les contrôles enfants qui représenteront les données sont créés. La collecte de données est énumérée et une nouvel objet TableCell est créé pour chaque élément de données. Si la propriété DataTextField est définie, elle est utilisée pour déterminer le champ de données lié à la propriété Text de la cellule. Sinon, le premier champ est utilisé.

Le contrôle Table parent est ajouté à la collection Controls du contrôle SimpleDataBoundColumn personnalisé. Tout contrôle qui est ajouté à la collection Controls du contrôle est restitué automatiquement pendant que la méthode Render héritée s'exécute.

Pour plus d'informations sur les implémentations requises d'un contrôle serveur Web lié aux données, consultez Développement de contrôles serveur Web liés aux données personnalisés pour ASP.NET 2.0.

Création d'un préfixe de balise

Un préfixe de balise est le préfixe, tel que "asp" dans <asp:Table />, qui apparaît avant le nom du type d'un contrôle lorsque le contrôle est créé de façon déclarative dans une page. Pour que votre contrôle puisse être utilisé de façon déclarative dans une page, ASP.NET a besoin d'un préfixe de balise, mappé à l'espace de noms de votre contrôle. Un développeur de pages peut fournir un mappage de préfixe de balise/espace de noms en ajoutant une directive @ Register à chaque page qui utilise le contrôle personnalisé, comme dans l'exemple suivant :

<%@ Register TagPrefix="aspSample" 
    Namespace="Samples.AspNet.Controls.CS"%>

<%@ Register TagPrefix="aspSample" 
    Namespace="Samples.AspNet.Controls.VB"%>

Remarque :
Notez qu'il n'y a aucun attribut assembly qui spécifie le nom de l'assembly de contrôle dans la directive @ Register. Lorsque l'attribut assembly manque, ASP.NET en déduit que l'assembly est compilé dynamiquement à partir de fichiers sources dans le répertoire App_Code.

Plutôt que d'utiliser la directive @ Register dans chaque page .aspx, le développeur de pages peut spécifier le mappage de préfixe de balise et d'espace de noms dans le fichier Web.config. Cela est utile si le contrôle personnalisé doit être utilisé sur plusieurs pages d'une application Web. La procédure suivante décrit comment spécifier le mappage de préfixe de balise dans le fichier Web.config.

Pour ajouter un mappage de préfixe de balise dans le fichier Web.config

Si votre site Web n'en possède pas déjà un, créez un fichier nommé Web.config dans le dossier racine du site.

Si vous avez créé un fichier Web.config, copiez-y le balisage XML suivant et enregistrez le fichier. Si votre site disposait déjà d'un fichier Web.config, ajoutez-y l'élément en surbrillance suivant.

Remarque :
L'entrée de préfixe de balise doit être un enfant de la section controls, qui doit se trouver sous la section pages, laquelle doit à son tour être un enfant de system.web.

<?xml version="1.0"?>
<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.CS" />
      </controls>
    </pages>
  </system.web>
</configuration>

<?xml version="1.0"?>
<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.VB" />
      </controls>
    </pages>
  </system.web>
</configuration>

La section en surbrillance montre une entrée de préfixe de balise qui mappe le préfixe de balise "aspSample" à l'espace de noms Samples.AspNet.Controls.CS ou Samples.AspNet.Controls.VB.

Après avoir spécifié le mappage de préfixe de balise dans le fichier de configuration, vous pouvez utiliser le contrôle SimpleDataBoundColumn de façon déclarative (sous la forme <aspSample:SimpleDataBoundColumn />) sur n'importe quelle page du site Web.

Remarque :
Dans ASP.NET 1.0 et 1.1, le mappage de préfixe de balise est spécifié dans la directive @ Register de chacune des pages qui utilisaient le contrôle personnalisé.

Création d'une page pour utiliser le contrôle lié aux données personnalisé

Dans cette section de la procédure pas à pas, vous créerez un balisage de la page qui vous permettra de tester le contrôle lié aux données personnalisé.

Pour créer une page qui utilise le contrôle lié aux données personnalisé

Dans votre site Web, créez un fichier nommé TestSimpleDataBoundColumn.aspx.

Copiez le balisage suivant dans le fichier TestSimpleDataBoundColumn.aspx et enregistrez le fichier.

<%@ Page Language="VB" Trace="true"%>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.Controls.VB" %>
<%@ Import Namespace="System.Data" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<script >
         Function CreateDataSource() As ICollection 

         ' Create sample data for the DataList control.
         Dim dt As DataTable = New DataTable()
         dim dr As DataRow

         ' Define the columns of the table.
         dt.Columns.Add(New DataColumn("IntegerValue", GetType(Int32)))
         dt.Columns.Add(New DataColumn("StringValue", GetType(String)))
         dt.Columns.Add(New DataColumn("CurrencyValue", GetType(Double)))
         dt.Columns.Add(New DataColumn("ImageValue", GetType(String)))

         ' Populate the table with sample values.
         Dim i As Integer

         For i = 0 To 8 

            dr = dt.NewRow()

            dr(0) = i
            dr(1) = "Description for item " & i.ToString()
            dr(2) = 1.23 * (i + 1)
            dr(3) = "Image" & i.ToString() & ".jpg"

            dt.Rows.Add(dr)

         Next i

         Dim dv As DataView = New DataView(dt)
         Return dv

      End Function

      Sub Page_Load(sender As Object, e As EventArgs) 

         ' Load sample data only once, when the page is first loaded.
         If Not IsPostBack Then 

            simpleDataBoundColumn1.DataSource = CreateDataSource()
            simpleDataBoundColumn1.DataBind()

         End If

      End Sub

</script>

<head >
    <title>SimpleDataBoundColumn test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundColumn  id="simpleDataBoundColumn1" DataTextField="CurrencyValue" BorderStyle="Solid"></aspSample:SimpleDataBoundColumn>
    </div>
    </form>
</body>
</html>

<%@ Page Language="C#" Trace="true"%>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.Controls.CS" %>
<%@ Import Namespace="System.Data" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<script >

      ICollection CreateDataSource() 
      {
         DataTable dt = new DataTable();
         DataRow dr;

         dt.Columns.Add(new DataColumn("IntegerValue", typeof(Int32)));
         dt.Columns.Add(new DataColumn("StringValue", typeof(string)));
         dt.Columns.Add(new DataColumn("CurrencyValue", typeof(double)));

         for (int i = 0; i < 9; i++) 
         {
            dr = dt.NewRow();

            dr[0] = i;
            dr[1] = "Item " + i.ToString();
            dr[2] = 1.23 * (i + 1);

            dt.Rows.Add(dr);
         }

         DataView dv = new DataView(dt);
         return dv;
      }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            simpleDataBoundColumn1.DataSource = CreateDataSource();
            simpleDataBoundColumn1.DataBind();
        }
    }
</script>

<head >
    <title>SimpleDataBoundColumn test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundColumn  id="simpleDataBoundColumn1" DataTextField="CurrencyValue" BorderStyle="Solid"></aspSample:SimpleDataBoundColumn>
    </div>
    </form>
</body>
</html>

Exécutez la page SimpleDataBoundColumnTest.aspx.
Apportez quelques modifications au code source du contrôle personnalisé. Par exemple, écrivez une chaîne supplémentaire en ajoutant cette ligne de code à la fin de la méthode RenderContents:
```
writer.Write("<br />Testing how the App_Code directory works.");
```
```
writer.Write("<br />Testing how the App_Code directory works.")
```
Actualisez la page SimpleDataBoundColumnTest.aspx dans votre navigateur.

Vous constaterez que les modifications apportées au contrôle se sont répercutées dans la page, bien que vous n'ayez pas compilé le contrôle.

Compilation du contrôle dans un assembly

Le répertoire App_Code vous permet de tester votre contrôle sans le compiler. Toutefois, si vous souhaitez distribuer votre contrôle en tant que code objet à d'autres développeurs, vous devez le compiler. De plus, un contrôle ne peut pas être ajouté à la boîte à outils d'un concepteur visuel s'il n'est pas compilé dans un assembly.

Pour compiler le contrôle dans un assembly

Paramétrez la variable d'environnement Windows PATH de votre ordinateur de façon à ce qu'elle intègre le chemin d'accès de votre installation .NET Framework en suivant ces étapes :
1. Dans Windows, cliquez avec le bouton droit sur Poste de travail, sélectionnez Propriétés, cliquez sur l'onglet Avancé, puis sur le bouton Variables d'environnement.
2. Dans la liste Variables système, double-cliquez sur la variable Path.
3. Dans la zone de texte Valeur de la variable, ajoutez un point-virgule (;) à la fin des valeurs existantes dans la zone de texte, puis saisissez le chemin d'accès de votre installation .NET Framework. Le .NET Framework est en général installé dans le répertoire d'installation de Windows à l'emplacement \Microsoft.NET\Framework\numéroVersion.
4. Cliquez sur OK pour fermer toutes les boîtes de dialogue.

Exécutez la commande suivante à partir du répertoire App_Code qui contient les fichiers sources créés dans une étape précédente de cette procédure pas à pas. Vous générez ainsi un assembly nommé Samples.AspNet.Controls.CS.dll ou Samples.AspNet.Controls.VB.dll dans le même répertoire App_Code.

csc /t:library /out:Samples.AspNet.Controls.CS.dll /r:System.dll /r:System.Web.dll *.cs

vbc /t:library /out:Samples.AspNet.Controls.VB.dll /r:System.dll /r:System.Web.dll *.vb

L'option /t:library du compilateur indique à ce dernier de créer une bibliothèque plutôt qu'un assembly exécutable. L'option /out fournit un nom à l'assembly et l'option /r liste les assemblys liés à votre assembly.

Remarque :
Pour que l'exemple reste indépendant, cette procédure pas à pas vous demande de créer un assembly avec un seul contrôle. En général, les règles de conception du .NET Framework vous recommandent de ne pas créer d'assemblys ne contenant que quelques classes. Pour faciliter le déploiement, vous devez créer aussi peu d'assemblys que possible.

Utilisation de TagPrefixAttribute pour fournir un mappage de préfixe de balise/espace de noms

Précédemment, vous avez vu comment un développeur de pages peut spécifier un préfixe de balise dans la page ou dans le fichier Web.config. Lorsque vous compilez un contrôle, vous pouvez suggérer facultativement un préfixe de balise qu'un concepteur visuel devra utiliser par défaut pour votre contrôle en incluant l'attribut System.Web.UI.TagPrefixAttribute de niveau assembly. L'attribut TagPrefixAttribute est utile parce qu'il fournit un préfixe de balise à utiliser par un concepteur visuel si celui-ci ne trouve pas de mappage de préfixe de balise dans le fichier Web.config ou dans une directive @ Register de la page. Le préfixe de balise est enregistré avec la page la première fois que l'on double-clique sur le contrôle dans la boîte à outils ou qu'on le fait glisser de la boîte à outils sur la page.

Si vous décidez d'utiliser l'attribut TagPrefixAttribute, vous pouvez le spécifier dans un fichier distinct compilé avec vos contrôles. Par convention, le fichier est nommé AssemblyInfo.extensionLangage, comme AssemblyInfo.cs ou AssembyInfo.vb. La procédure suivante décrit comment spécifier les métadonnées TagPrefixAttribute.

Remarque :
Si vous ne spécifiez pas TagPrefixAttribute dans l'assembly du contrôle et si le développeur de pages ne spécifie pas le mappage de préfixe de balise/espace de noms dans la page ou dans le fichier Web.config, le concepteur visuel peut créer un préfixe de balise par défaut. Par exemple, Visual Studio 2005 créera sa propre balise (telle que cc1) pour votre contrôle lorsque l'on fera glisser celui-ci depuis la boîte à outils.

Si vous ne spécifiez pas TagPrefixAttribute dans l'assembly du contrôle et si le développeur de pages ne spécifie pas le mappage de préfixe de balise/espace de noms dans la page ou dans le fichier Web.config, le concepteur visuel peut créer un préfixe de balise par défaut. Par exemple, Visual Studio 2005 créera sa propre balise (telle que cc1) pour votre contrôle lorsque l'on fera glisser celui-ci depuis la boîte à outils.

Pour ajouter un mappage de préfixe de balise à l'aide de TagPrefixAttribute

Créez un fichier a nommé AssemblyInfo.cs ou AssemblyInfo.vb dans le répertoire de votre code source et ajoutez le code suivant au fichier.
```
using System;
using System.Web.UI;
[assembly: TagPrefix("Samples.AspNet.Controls.CS", "aspSample")]
```
```
Imports System
Imports System.Web.UI
<Assembly: TagPrefix("Samples.AspNet.Controls.VB", "aspSample")> 
```
L'attribut de préfixe de balise crée un mappage entre l'espace de noms Samples.AspNet.Controls.CS ou Samples.AspNet.Controls.VB et le préfixe aspSample.
Recompilez tous les fichiers sources à l'aide de la commande de compilation que vous avez utilisée précédemment (avec ou sans la ressource incorporée).

Utilisation du contrôle serveur lié aux données personnalisé compilé dans une page ASP.NET

Pour tester la version compilée de votre contrôle personnalisé, vous devez rendre l'assembly de votre contrôle accessible aux pages du site Web.

Pour rendre l'assembly de votre contrôle accessible au site Web

Créez un répertoire Bin sous la racine du site Web.
Faites glisser l'assembly de contrôle (Samples.AspNet.Controls.CS.dll ou Samples.AspNet.Controls.VB.dll) du répertoire App_Code vers le répertoire Bin.
Supprimez le fichier source du contrôle du répertoire App_Code.

Si vous ne supprimez pas les fichiers sources, le type de votre contrôle existera à la fois dans l'assembly compilé et dans l'assembly généré dynamiquement créé par ASP.NET. Cela créera une référence ambiguë lors du chargement du contrôle, et toutes les pages dans lesquelles le contrôle est utilisé généreront une erreur du compilateur.

L'assembly que vous avez créé dans cette procédure pas à pas est appelé "assembly privé", parce qu'il doit être placé dans le répertoire Bin d'un site Web ASP.NET pour permettre aux pages du site Web d'utiliser votre contrôle. L'assembly ne peut pas être accessible à d'autres applications, à moins qu'une copie ne soit également installée avec ces applications. Si vous créez des contrôles pour des applications d'hébergement Web partagées, vous les intégrerez en général à un assembly privé. Cependant, si vous créez des contrôles devant être utilisés dans un environnement d'hébergement dédié, ou une suite de contrôles qu'un FAI rend disponible à tous ses abonnés, vous risquez de devoir intégrer ces contrôles à un assembly partagé (avec nom fort), installé dans le Global Assembly Cache. Pour plus d'informations, consultez Utilisation d'assemblys et du Global Assembly Cache.

Vous devez ensuite modifier le mappage de préfixe de balise que vous avez créé dans Web.config pour spécifier le nom de l'assembly de votre contrôle.

Pour modifier le mappage de préfixe de balise dans Web.config

Modifiez le fichier Web.config pour ajouter un attribut assembly à un élément addtagPrefix :

<controls>
  <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.CS" assembly="Samples.AspNet.Controls.CS" />
</controls>

<controls>
  <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.VB" assembly="Samples.AspNet.Controls.VB" />
</controls>

L'attribut assembly spécifie le nom de l'assembly dans lequel se trouve le contrôle. Un élément addtagPrefix mappe un préfixe de balise à une combinaison d'espace de noms et d'assembly. Lorsque l'assembly est généré dynamiquement par ASP.NET à partir des fichiers sources du répertoire App_Code, l'attribut d'assembly n'est pas nécessaire. Lorsque l'attribut d'assembly n'est pas utilisé, ASP.NET charge le type du contrôle à partir des assemblys générés dynamiquement depuis le répertoire App_Code.

Pour afficher la page qui utilise le contrôle personnalisé

Affichez la page SimpleDataBoundColumnTest.aspx dans votre navigateur en entrant l'URL suivante dans la barre d'adresses :
```
https://localhost/ServerControlsTest/SimpleDataBoundColumnTest.aspx
```

Si vous utilisez votre contrôle dans un concepteur visuel tel que Visual Studio 2005, vous serez en mesure de l'ajouter à la boîte à outils, de le faire glisser de la boîte à outils vers l'aire de conception et d'accéder aux propriétés et aux événements de l'Explorateur de propriétés. De plus, dans Visual Studio 2005, votre contrôle bénéficie de la prise en charge complète d'IntelliSense dans l'affichage en mode Source du concepteur de pages et dans l'éditeur de code. Cela inclut l'achèvement de l'instruction dans un bloc de script, ainsi que la prise en charge de l'Explorateur de propriétés lorsqu'un développeur de pages clique sur la balise du contrôle.

Remarque :
Dans de nombreux concepteurs visuels, vous pouvez ajouter des contrôles personnalisés à la boîte à outils du concepteur. Pour plus d'informations, consultez la documentation de votre concepteur.

Étapes suivantes

Ce contrôle serveur lié aux données personnalisé simple illustre les étapes fondamentales utilisées pour créer un contrôle personnalisé qui offre à un développeur de pages un moyen standard, efficace et souple de le lier à une source de données externe. À partir de là, vous pouvez commencer à explorer l'infrastructure fournie dans Visual Studio pour vous aider à créer des contrôles serveur personnalisés sophistiqués. Voici quelques suggestions pour une exploration plus approfondie :

Passez en revue la présentation de l'architecture générale et des implémentations qui sont spécifiques au développement d'un contrôle serveur lié aux données personnalisé. Pour plus d'informations, consultez Développement de contrôles serveur Web liés aux données personnalisés pour ASP.NET 2.0.
Recherchez les classes de contrôles serveur liés aux données existantes que vous pouvez étendre et personnaliser. Pour obtenir une vue d'ensemble des contrôles serveur Web liés aux données disponibles, consultez Vue d'ensemble des contrôles serveur Web liés aux données ASP.NET. Pour plus d'informations sur les classes de contrôles serveur Web liés aux données, consultez les rubriques de référence suivantes GridView, DetailsView, FormView, Repeater et DataList.
En savoir plus sur le rendu, la définition des propriétés, la gestion de l'état et l'implémentation des contrôles composites personnalisés. Pour plus d'informations, consultez Développement de contrôles serveur ASP.NET personnalisés, Comparaison entre états de contrôle et états d'affichage, exemple et Gestion de l'état personnalisée des contrôles serveur.
Découvrez les attributs de métadonnées que vous pouvez appliquer à votre contrôle serveur lié aux données personnalisé et à ses membres pour fournir des informations qui sont utilisées par les outils de conception. Pour plus d'informations, consultez Attributs de métadonnées pour des contrôles serveur personnalisés.
Créez un Concepteur de contrôles pour ajouter des fonctionnalités de design, des modèles ou des styles. Pour obtenir un exemple de Concepteur de contrôles lié aux données personnalisé, consultez HierarchicalDataBoundControlDesigner et Procédure pas à pas : création d'un Concepteur de contrôles de base pour un contrôle serveur Web. Pour obtenir une vue d'ensemble des Concepteurs de contrôles ASP.NET, consultez Vue d'ensemble des Concepteurs de contrôles ASP.NET.
Utilisez un exemple d'un Concepteur de contrôles lié aux données personnalisé. Pour plus d'informations, consultez la classe HierarchicalDataBoundControlDesigner.
Examinez une démonstration sur la définition des attributs de design appropriés pour rendre un contrôle serveur personnalisé disponible dans la boîte à outils Visual Studio. Pour plus d'informations, consultez Comment : utiliser des contrôles serveur ASP.NET personnalisés dans Visual Studio.

Voir aussi

Partager via