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

Article
10/22/2014

Mise à jour : novembre 2007

Cette procédure pas à pas illustre la création d'un contrôle serveur lié aux données simple qui expose une source de données pouvant être liée.

Un contrôle serveur lié aux données ASP.NET fournit une interface utilisateur pour une source de données qui représente une collection d'enregistrements ou d'éléments. Les contrôles serveur DataList et Repeater sont des exemples de contrôles serveur Web liés aux données. Pour plus d'informations sur les contrôles liés aux données fournis avec ASP.NET, consultez Vue d'ensemble des contrôles serveur Web liés aux données ASP.NET.

Remarque :
Le contrôle illustré dans cette procédure pas à pas est compatible avec ASP.NET version 1.1. For more information creating custom data-bound Web controls for ASP.NET 2.0, see Développement de contrôles serveur Web liés aux données personnalisés pour ASP.NET 2.0.

Un contrôle serveur lié aux données ASP.NET 1.1 peut être lié à chacun des types suivants :

IEnumerable (such as an Array, an ArrayList, or a Hashtable object).
IListSource (tel qu'un objet DataSet).

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

Tasks illustrated in this walkthrough include:

Création du site Web pour tester le contrôle lié aux données personnalisé.
Création d'une classe de contrôles liés aux données. La classe doit exposer une propriété de type IListSource ou IEnumerable, ce qui permet à un développeur de pages de spécifier l'emplacement des données à lier. Elle doit également substituer les méthodes DataBind et CreateChildControls de la classe de base.
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 à la racine du site Web. Les classes des fichiers sources du répertoire App_Code sont ainsi accessibles depuis les pages sans être compilées manuellement dans des assemblys.

Remarque :
Le répertoire App_Code est une nouvelle fonctionnalité dont ne disposaient pas les versions 1.0 et 1.1 d'ASP.NET. 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, comme décrit dans la section « Compilation du contrôle dans un assembly ».

Le répertoire App_Code est une nouvelle fonctionnalité dont ne disposaient pas les versions 1.0 et 1.1 d'ASP.NET. 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, comme décrit dans la section « 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.

Création de la classe SimpleDataBoundControl

L'étape suivante consiste à créer la classe de contrôles.

Pour créer la classe SimpleDataBoundControl

Dans le dossier App_Code créé au cours de la procédure antérieure, créez une classe nommée SimpleDataBoundControl.cs ou SimpleDataBoundControl.vb, selon le langage de programmation que vous souhaitez utiliser.

Ajoutez le code suivant à votre fichier de classe.

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

Namespace Samples.ASPNet.VB.Controls
    <DefaultProperty("DataSource")> _
        Public Class SimpleDataBoundControl
        Inherits WebControl

        Private _dataSource As IEnumerable
        Private _label As Label
        Private _button As Button
        Private _table As Table

        <Category("Data"), DefaultValue(""), Description("An exposed data source: A public member of type IEnumerable to bind to such as an Array, ArrayList or Hashtable.")> _
        Public Overridable Property DataSource() As IEnumerable
            Get
                Return _dataSource
            End Get
            Set(ByVal value As IEnumerable)
                If TypeOf value Is IEnumerable OrElse value Is Nothing Then
                    _dataSource = value
                Else
                    Throw New ArgumentException()
                End If
            End Set
        End Property

        Protected Overridable Function GetDataSource() As IEnumerable
            If _dataSource Is Nothing Then
                Return Nothing
            End If

            Dim resolvedDataSource As IEnumerable
            resolvedDataSource = _dataSource

            Return resolvedDataSource

        End Function 'GetDataSource

        Protected Overridable Sub CreateMyControlHeirarchy(ByVal useViewState As Boolean)
            Dim resolvedDataSource As IEnumerable = Nothing
            If useViewState Then
                If Not (ViewState("RowCount") Is Nothing) Then
                    resolvedDataSource = New Object(Fix(ViewState("RowCount"))) {}
                Else
                    Throw New Exception("Unable to retrieve expected data from ViewState")
                End If
            Else
                resolvedDataSource = GetDataSource()
            End If

            If Not (resolvedDataSource Is Nothing) Then
                ' Create a label that will indicate form which source the data has been provided.
                Dim s As String
                If useViewState Then
                    s = "Data collection retrieved from ViewState:"
                Else
                    s = "Data collection retrieved from bound data source:"
                End If
                _label = New Label()
                Me.Controls.Add(Me._label)
                _label.Text = s

                _button = New Button()
                Me.Controls.Add(Me._button)
                _button.Text = "Test re-binding of ViewState"

                _table = New Table()
                Me.Controls.Add(Me._table)

                Dim dataItem As Object
                For Each dataItem In resolvedDataSource
                    Dim row As New TableRow()
                    _table.Rows.Add(row)
                    Dim cell As New TableCell()
                    If Not useViewState Then
                        cell.Text = dataItem.ToString()
                    End If
                    row.Cells.Add(cell)
                Next dataItem

                ViewState("RowCount") = _table.Rows.Count
            End If

        End Sub 'CreateMyControlHeirarchy

        Protected Overrides Sub CreateChildControls()
            Controls.Clear()

            If Not (ViewState("RowCount") Is Nothing) Then
                Dim useViewState As Boolean = True
                CreateMyControlHeirarchy(useViewState)
            End If

        End Sub 'CreateChildControls

        Public Overrides Sub DataBind()
            MyBase.OnDataBinding(EventArgs.Empty)

            Controls.Clear()
            ClearChildViewState()
            TrackViewState()

            Dim useViewState As Boolean = False
            CreateMyControlHeirarchy(useViewState)

            ChildControlsCreated = True
        End Sub 'DataBind

        Protected Overrides Sub RenderContents(ByVal writer As HtmlTextWriter)
            Me._label.RenderControl(writer)
            Me._table.RenderControl(writer)
            Me._button.RenderControl(writer)
        End Sub 'RenderContents
    End Class 'SimpleDataBoundControl
End Namespace

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

namespace Samples.AspNet.CS.Controls
{
    [
        DefaultProperty("DataSource")
    ]
    public class SimpleDataBoundControl : WebControl
    {
        private IEnumerable _dataSource;
        private Label _label;
        private Button _button;
        private Table _table;

        [
        Category("Data"),
        DefaultValue(""),
        Description("An exposed data source: A public member of type IEnumerable to bind to such as an Array, ArrayList or Hashtable.")
        ]
        public virtual IEnumerable DataSource
        {
            get
            {
                return _dataSource;
            }
            set
            {
                if ((value is IEnumerable) || (value == null))
                {
                    _dataSource = value;
                }
                else
                {
                    throw new ArgumentException();
                }
            }
        }

        protected virtual IEnumerable GetDataSource()
        {
            if (_dataSource == null)
            {
                return null;
            }

            IEnumerable resolvedDataSource;
            resolvedDataSource = _dataSource as IEnumerable;

            return resolvedDataSource;
        }

        protected virtual void CreateMyControlHeirarchy(bool useViewState)
        {
            IEnumerable resolvedDataSource = null;
            if (useViewState)
            {
                if (ViewState["RowCount"] != null)
                {
                    resolvedDataSource = new object[(int)ViewState["RowCount"]];
                }
                else
                {
                    throw new Exception("Unable to retrieve expected data from ViewState");
                }
            }
            else
            {
                resolvedDataSource = GetDataSource();
            }

            if (resolvedDataSource != null)
            {
                // Create a label that will indicate form which source the data has been provided.
                String s;
                if (useViewState)
                {
                    s = "Data collection retrieved from ViewState:";
                }
                else
                {
                    s = "Data collection retrieved from bound data source:";
                }
                _label = new Label();
                this.Controls.Add(this._label);
                _label.Text = s;

                _button = new Button();
                this.Controls.Add(this._button);
                _button.Text = "Test re-binding of ViewState";

                _table = new Table();
                this.Controls.Add(this._table);

                foreach (object dataItem in resolvedDataSource)
                {
                    TableRow row = new TableRow();
                    _table.Rows.Add(row);
                    TableCell cell = new TableCell();
                    if (!useViewState)
                    {
                        cell.Text = dataItem.ToString();
                    }
                    row.Cells.Add(cell);
                }

                ViewState["RowCount"] = _table.Rows.Count;
            }
        }

        protected override void CreateChildControls()
        {
            Controls.Clear();

            if (ViewState["RowCount"] != null)
            {
                bool useViewState = true;
                CreateMyControlHeirarchy(useViewState);
            }
        }

        public override void DataBind()
        {
            base.OnDataBinding(EventArgs.Empty);

            Controls.Clear();

            ClearChildViewState();

            TrackViewState();

            bool useViewState = false;
            CreateMyControlHeirarchy(useViewState);

            ChildControlsCreated = true;
        }

        protected override void RenderContents(HtmlTextWriter writer)
        {
            this._label.RenderControl(writer);
            this._table.RenderControl(writer);
            this._button.RenderControl(writer);
        }
    }
}

Explication du code

La classe SimpleDataBoundControl restitue un tableau HTML basé sur la collecte de données spécifiée dans sa propriété DataSource. Les contrôles serveur Web liés aux données ASP.NET 1.1 doivent exposer une propriété DataSource pouvant être liée qui peut avoir pour valeur le type IEnumerable ou IListSource.

Dans l'exemple de code, l'accesseur set pour la propriété DataSource vérifie que la valeur à définir est null ou un objet de type IEnumerable. Par conséquent, dans cet exemple, le développeur de pages peut lier des données à tout type IEnumerable, tel qu'un Array, une ArrayList ou un objet Hashtable. Le développeur peut laisser initialement la valeur par défaut null affectée à la propriété DataSource et définir la propriété dans le code.

Les attributs de métadonnées Category, DefaultValue et Description fournissent les informations utilisées par les outils de conception, l'analyseur de pages ASP.NET et le Common Language Runtime (CLR).

La méthode d'assistance CreateMyControlHeirarchy conserve la création de la hiérarchie des contrôles enfants du contrôle sur un chemin de code commun. Elle est appelée à la fois par la méthode DataBind substituée et la méthode CreateChildControls substituée. La méthode DataBind substituée est obligatoire. Elle énumère l'objet dans la source de données associée et crée les contrôles enfants. La méthode CreateChildControls substituée est requise et recrée la hiérarchie des contrôles enfants selon les données enregistrées dans l'état d'affichage.

Le contrôle est rendu en substituant la méthode RenderContents héritée. Cela permet de restituer le contrôle dans ses propres balises. Le paramètre passé dans la méthode RenderContents est un objet de type HtmlTextWriter, qui est une classe utilitaire possédant des méthodes pour rendre des balises et autre balisage HTML (ou une variante de HTML).

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 1.1.

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.CS.Controls"%>

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

Remarque :
La directive @ Register dans ASP.NET 2.0 est la même que dans ASP.NET 1.0 et ASP.NET 1.1. Si vous connaissiez déjà la directive @ Register dans les versions précédentes d'ASP.NET, notez que l'attribut assembly qui spécifie le nom de l'assembly du contrôle est absent dans la directive @ Register précédente. 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.

La directive @ Register dans ASP.NET 2.0 est la même que dans ASP.NET 1.0 et ASP.NET 1.1. Si vous connaissiez déjà la directive @ Register dans les versions précédentes d'ASP.NET, notez que l'attribut assembly qui spécifie le nom de l'assembly du contrôle est absent dans la directive @ Register précédente. 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.

Remarque :
L'entrée de configuration pour le préfixe de balise est une nouvelle fonctionnalité d'ASP.NET 2.0. Dans ASP.NET 1.0 et 1.1, le mappage de préfixe de balise était spécifié dans la directive @ Register de chacune des pages qui utilisaient le contrôle personnalisé.

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 (vide), 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 l'élément <controls>, qui doit être sous la section <pages> sous <system.web>.
```
<?xml version="1.0"?>
<configuration>
  <system.web>    
   <pages>
     <controls>
       <add tagPrefix="aspSample"            namespace="Samples.AspNet.CS.Controls">       </add>
     </controls>
   </pages>
  </system.web>
</configuration>
```
```
<?xml version="1.0"?>
<configuration>
  <system.web>    
   <pages>
     <controls>
       <add tagPrefix="aspSample"            namespace="Samples.AspNet.VB.Controls">       </add>
     </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.CS.Controls ou Samples.AspNet.VB.Controls.

Remarque :
L'entrée de préfixe de balise doit être un enfant de l'élément <controls>, qui doit être sous la section <pages> sous <system.web>.

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

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é

Créez un fichier nommé TestSimpleDataBoundControl.aspx dans votre site Web.

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

<%@ Page Language="VB" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.VB.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script >
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
        If Not IsPostBack Then
            Dim a As New ArrayList()
            a.Add("One")
            a.Add("Two")
            a.Add("Three")
            a.Add("Four")

            simpleDataBoundControl1.DataSource = a
            simpleDataBoundControl1.DataBind()
        End If
    End Sub 'Page_Load
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" >
    <title>SimpleDataBoundControl test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundControl  id="simpleDataBoundControl1" BorderStyle="Solid" ></aspSample:SimpleDataBoundControl>
    </div>
    </form>
</body>
</html>

<%@ Page Language="C#" Trace="true" EnableViewState="true" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.CS.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script >
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            ArrayList a = new ArrayList();
            a.Add("One");
            a.Add("Two");
            a.Add("Three");
            a.Add("Four");

            simpleDataBoundControl1.DataSource = a;
            simpleDataBoundControl1.DataBind();
        }
    }
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
    <title>SimpleDataBoundControl test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundControl  id="simpleDataBoundControl1" BorderStyle="Solid" ></aspSample:SimpleDataBoundControl>
    </div>
    </form>
</body>
</html>

Exécutez la page TestSimpleDataBoundControl.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 TestSimpleDataBoundControl.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

Bien que le répertoire App_Code vous permette de tester votre contrôle sans le compiler, si vous souhaitez le distribuer comme code objet à d'autres développeurs, vous devrez 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 contenant les fichiers sources que vous avez créés précédemment dans cette procédure pas à pas.

Vous générez ainsi un assembly nommé Samples.AspNet.CS.Controls.dll ou Samples.AspNet.VB.Controls.dll dans le répertoire App_Code.

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

vbc /t:library /out:Samples.AspNet.VB.Controls.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 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 inclure facultativement l'attribut System.Web.UI.TagPrefixAttribute de niveau assembly qui suggère un préfixe de balise par défaut qu'un concepteur visuel doit utiliser pour votre contrôle. 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. For example, Visual Studio 2005 will create its own tag (such as cc1) for your control when the control is dragged from the toolbox.

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. For example, Visual Studio 2005 will create its own tag (such as cc1) for your control when the control is dragged from the toolbox.

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.CS.Controls", "aspSample")]
```
```
Imports System
Imports System.Web.UI
<Assembly: TagPrefix("Samples.AspNet.VB.Controls", "aspSample")> 
```
L'attribut de préfixe de balise crée un mappage entre l'espace de noms Samples.AspNet.CS.Controls ou Samples.AspNet.VB.Controls 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

Si votre site n'en possède pas déjà un, créez un répertoire Bin sous la racine du site Web.
Faites glisser (déplacez) l'assembly de contrôle (Samples.AspNet.CS.Controls.dll ou Samples.AspNet.VB.Controls.dll) du répertoire App_Code vers le répertoire Bin.
Déplacez le fichier source du contrôle du répertoire App_Code vers un autre répertoire de votre site Web.

Si vous ne sortez pas les fichiers sources du répertoire App_Code, 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 un 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 le fichier Web.config pour spécifier le nom de l'assembly de votre contrôle.

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

Modifiez le fichier Web.config pour ajouter un attribut assembly à l'élément <add tagPrefix=name> :

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

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

L'attribut assembly spécifie le nom de l'assembly dans lequel se trouve le contrôle. Un élément <add tagPrefix=name> 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 de l'assembly généré dynamiquement depuis le répertoire App_Code.

Vous pouvez maintenant tester le contrôle en l'affichant dans une page.

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

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

If you use your control in a visual designer such as Visual Studio 2005, you will be able to add your control to the toolbox, drag it from the toolbox to the design surface, and access properties and events in the property browser. In addition, in Visual Studio 2005, your control has full IntelliSense support in Source view of the page designer and in the code editor.

É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 de le lier à une source de données externe. À partir de là, vous pouvez commencer à découvrir la façon dont Visual Studio vous aide à créer des contrôles serveur personnalisés sophistiqués. Voici quelques suggestions pour une exploration plus approfondie :

Examinez la présentation de l'architecture générale du 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 1.1.
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, 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 rubrique 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