Accueil     Commander     Clients     Téléchargements     Contacts     I-mode        Offre spéciale
   Hébergement ASP-PHP
      Pack PRO I
      Pack PRO II
      Pack PRO III
   Hébergement .NET
      Pack .NET I
      Pack .NET II
      Pack .NET III
   Revendeurs
      SEMI-DEDIE I
      SEMI-DEDIE II
      SERVEURS DEDIES
   Services
      NOM DE DOMAINE
      HTTPS & SSL
      E-COMMERCE
      SQL SERVEUR
      WEBMAIL
      REFERENCEMENT
   Les + Prosygma
      NOS TARIFS
      LE RESEAU
      ASSISTANCE
   Outils
      WHOIS
      FAQ
      Aide IIS
      Ressource KIT FP
      Composants ASP
     PARTENAIRES
     
     
     

Solutions hébergement
Support Dot NET.
  
  Source : Les laboratoires Microsoft

 

Création de contrôles personnalisés


Cette section du didacticiel Démarrage rapide décrit la manière dont les développeurs expérimentés peuvent écrire leurs propres contrôles serveur ASP.NET qui fonctionnent dans l'infrastructure de page ASP.NET. En écrivant vos propres contrôles serveur ASP.NET personnalisés, vous pouvez encapsuler une interface utilisateur personnalisée et d'autres fonctionnalités dans des contrôles qui peuvent être réutilisés sur les pages ASP.NET. Le didacticiel Démarrage rapide contient une présentation de la création des contrôles personnalisés par l'intermédiaire d'exemples pratiques. Pour plus d'informations sur la création de contrôles, consultez « Développement de contrôles serveur ASP.NET » dans la documentation du SDK Microsoft .NET Framework.

Remarque : Il se peut que les contrôles décrits dans cette section ne fonctionnent pas correctement au moment du design, dans un concepteur de formulaires, tel que Microsoft Visual Studio.NET, même s'ils fonctionnent correctement au moment de l'exécution sur des pages ASP.NET. Pour fonctionner dans un concepteur, un contrôle doit appliquer des attributs de design qui ne sont pas décrits ici. Pour plus d'informations sur les attributs de design à appliquer, consultez « Attributs de design pour les composants » dans la documentation du SDK.

Développement d'un contrôle personnalisé simple

Il est aisé de commencer à créer vos propres contrôles serveur ASP.NET. Pour créer un contrôle personnalisé simple, il vous suffit de définir une classe qui dérive de System.Web.UI.Control et de substituer sa méthode Render. La méthode Render prend un argument de type System.Web.UI.HtmlTextWriter. Le code HTML que votre contrôle souhaite envoyer au client est passé en tant qu'argument de chaîne à la méthode Write de HtmlTextWriter.

L'exemple suivant illustre un contrôle simple qui restitue une chaîne de message.

 
VB Simple.aspx


Définition de propriétés simples

Les propriétés correspondent à des champs « intelligents » possédant des méthodes d'accesseurs. Exposez des propriétés plutôt que des champs publics à partir de vos contrôles, car les propriétés permettent le masquage de données, la gestion de leur version et sont prises en charge par des concepteurs virtuels. Les propriétés possèdent des méthodes d'accesseurs get/set qui définissent et extraient des propriétés. Elles permettent en outre l'exécution d'une logique de programme supplémentaire, si cela s'avère nécessaire.

L'exemple suivant illustre l'ajout de propriétés simples correspondant à des types de données primitifs, tels que integer, Boolean et string. L'exemple définit trois propriétés  : Message est de type string, MessageSize est de type enumeration et Iterations est de type integer. Remarquez la syntaxe de la page pour la définition de propriétés simples et d'énumération.

 
VB SimpleProperty.aspx


Définition de propriétés de classe

Si une classe A possède une propriété de type de classe B, les propriétés (éventuelles) de B sont appelées sous-propriétés de A. L'exemple suivant définit un contrôle personnalisé SimpleSubProperty possédant une propriété de type Format. Format est une classe possédant deux propriétés primitives, Color et Size, qui deviennent à leur tour des sous-propriétés de SimpleSubProperty.

 
VB SimpleSubProperty.aspx

Remarquez que ASP.NET possède une syntaxe spéciale pour la définition des sous-propriétés. L'exemple de code suivant décrit comment définir par déclaration les sous-propriétés Format.Color et Format.Size sur SimpleSubProperty. La syntaxe "-" indique une sous-propriété.

<SimpleControlSamples:SimpleSubProperty
Message="Hello There" Format-Color
="red" Format-Size="3" runat=server/>


Récupération de contenu interne

Chaque contrôle possède une propriété Controls dont il hérite de System.Web.UI.Control. Il s'agit d'une propriété de collection indiquant les contrôles enfants (éventuels) d'un contrôle. Si un contrôle n'est pas marqué de ParseChildrenAttribute ou de ParseChildrenAttribute(ChildrenAsProperties = false), l'infrastructure de page ASP.NET applique la logique d'analyse suivante lorsque le contrôle est utilisé par déclaration sur une page. Si l'analyseur rencontre des contrôles imbriqués dans les balises du contrôle, il crée des instances de ceux-ci et les ajoute à la propriété Controls du contrôle. Le texte littéral entre deux balises est ajouté en tant que LiteralControl. Tous les autres éléments imbriqués génèrent une erreur d'analyse.

L'exemple suivant illustre un contrôle personnalisé, SimpleInnerContent, qui restitue le texte ajouté entre ses balises en vérifiant si un LiteralControl a été ajouté à sa collection Controls. Dans ce cas, il extrait la propriété Text du LiteralControl et l'ajoute à sa chaîne de sortie.

 
VB SimpleInnerContent.aspx

Remarque : Si votre contrôle personnalisé dérive de WebControl, il ne possède pas la logique d'analyse décrite dans l'exemple, car WebControl est marqué de ParseChildrenAttribute(ChildrenAsProperties = true), ce qui génère une autre logique d'analyse. Pour plus d'informations sur ParseChildrenAttribute, consultez la documentation du Kit de développement.


Développement d'un contrôle composite

Vous pouvez créer de nouveaux contrôles en combinant des contrôles existants à l'aide d'une composition de classe. Les contrôles composites équivalent aux contrôles utilisateur créés à l'aide de la syntaxe de page ASP.NET. La principale différence entre les contrôles utilisateur et les contrôles composites réside dans le fait que les contrôles utilisateur sont enregistrés en tant que fichiers texte .ascx, alors que les contrôles composites sont compilés et enregistrés dans des assemblys.

Les étapes essentielles du développement d'un contrôle composite sont les suivantes :

Vous ne devez pas substituer la méthode Render, car les contrôles enfants fournissent une logique de restitution. Vous pouvez exposer des propriétés qui synthétisent des propriétés de contrôles enfants.

L'exemple suivant définit un contrôle composite, Composition1, qui combine un System.Web.UI.LiteralControl et un System.Web.UI WebControls.TextBox. Composition1 expose une propriété personnalisée, Value, de type integer, mappée à la propriété Text de TextBox.

 
VB Composition1.aspx


Gestion des événements dans un contrôle composite

Un contrôle composite peut gérer les événements déclenchés par ses contrôles enfants. Cette opération est réalisée en fournissant des méthodes de gestion des événements et en associant des délégués aux événements déclenchés par les contrôles enfants.

L'exemple suivant illustre un contrôle composite, Composition2, qui ajoute deux contrôles boutons (appelés Ajouter et Soustraire) au contrôle composite de l'exemple précédent et fournit des méthodes de gestion des événements pour les événements Click des boutons. Ces méthodes incrémentent et décrémentent la propriété Value de Composition2. La méthode CreateChildControls de Composition2 crée des instances de gestionnaires d'événements (délégués) qui référencent ces méthodes, et associe les délégués aux événements Click des instances de Button. Le résultat final est un contrôle qui effectue sa propre gestion des événements. Lorsque vous cliquez sur le bouton Ajouter, la valeur de la zone de texte est incrémentée et lorsque vous cliquez sur le bouton Soustraire, elle est décrémentée.

 
VB Composition2.aspx


Déclenchement d'événements personnalisés à partir d'un contrôle composite

Un contrôle composite peut définir des événements personnalisés qu'il déclenche en réponse à des événements déclenchés par ses contrôles enfants.

L'exemple suivant illustre un contrôle composite, Composition3, qui déclenche un événement personnalisé, Change, en réponse à l'événement TextChanged du contrôle enfant TextBox.

Cette opération s'effectue de la manière suivante :

L'événement Change peut être géré par une page qui héberge le contrôle, de la manière décrite dans l'exemple suivant. Dans l'exemple, la page fournit une méthode de gestion des événements pour l'événement Change qui affecte à la propriété Value la valeur zéro si le nombre entré par l'utilisateur est négatif.

 
VB Composition3.aspx


Conservation de l'état

Tous les contrôles Web Forms possèdent une propriété State (héritée de Control) qui leur permet de participer à la gestion de State. Le type de State est Sytem.Web.UI.StateBag, structure de données équivalant à une table de hachage. Un contrôle peut enregistrer des données dans State en tant que paires clé/valeur. State est enregistré sous la forme d'une variable de chaîne par l'infrastructure de page ASP.NET et effectue un aller retour au client en tant que variable masquée. Lors de la publication, l'infrastructure de page analyse la chaîne d'entrée de la variable masquée et remplit la propriété State de chaque contrôle de la hiérarchie des contrôles d'une page. Un contrôle peut restaurer son état (affecter aux propriétés et champs leurs valeurs antérieures à la publication) à l'aide de la propriété State. Les développeurs de contrôles doivent garder à l'esprit que l'envoi de données par un aller-retour au client entraîne une diminution des performances, et être attentifs aux éléments qu'ils enregistrent dans State.

L'exemple de code suivant illustre une propriété enregistrée dans State.


Public Property Text As String
  Get
    Return CType(State("Text"), String))
  End Get
  Set
    State("Text") = Value
  End Set
End Property
C# VB JScript  

L'exemple suivant illustre un contrôle personnalisé, Label, possédant deux propriétés, Text et FontSize, enregistrées dans State. La page ASP.NET qui utilise Label contient des boutons possédant des gestionnaires d'événements qui augmentent la taille de la police du texte dans Label lorsque vous cliquez sur un bouton. Par conséquent, la taille de la police augmente chaque fois que vous cliquez sur un bouton. Cette opération n'est possible qu'à l'aide de la gestion d'état (Label doit connaître la taille de la police avant la publication afin de restituer la taille de police immédiatement supérieure après la publication).

 
VB Label.aspx


Développement d'un contrôle personnalisé (non composite) qui gère les données de publication

Au début de ce didacticiel Démarrage rapide, vous avez créé un contrôle personnalisé simple. L'exemple suivant illustre un contrôle personnalisé qui effectue une opération plus significative : il restitue une zone de texte et lit les données entrées par l'utilisateur. Un contrôle qui examine les données de publication (entrée) doit implémenter l'interface System.Web.UI.IPostBackDataHandler. Cela avertit l'infrastructure de page ASP.NET qu'un contrôle doit participer à la gestion des données de publication. L'infrastructure de page passe les données d'entrée à la méthode LoadPostData de cette interface en tant que paires clé/valeur. Lorsqu'il implémente cette méthode, le contrôle peut examiner les données d'entrée et mettre à jour ses propriétés de la manière illustrée.


Private _value As Integer = 0
Public Function LoadPostData
(postDataKey As
String, values As NameValueCollection)
As Boolean _value = Int32.Parse(values
(Me.UniqueID)) Return(False) End Function
C# VB JScript  

L'exemple suivant définit un contrôle personnalisé, NonComposition1, qui implémente IPostBackDataHandler et possède une propriété, Value. Le contrôle restitue une zone de texte HTML dont l'attribut de texte est la chaîne représentant Value. La propriété est définie en examinant les données d'entrée de publication. La page qui utilise NonComposition1 possède également deux boutons disposant de gestionnaires d'événements pour incrémenter et décrémenter la propriété Value de NonComposition1.

 
VB NonComposition1.aspx


Génération de code JavaScript côté client pour une publication personnalisée

Si un contrôle souhaite capturer des événements de publication (envoi de formulaires provenant d'un client), il doit implémenter l'interface System.Web.UI.IPostBackEventHandler. Cela avertit l'infrastructure de page ASP.NET qu'un contrôle souhaite être informé de la présence d'un événement de publication. La méthode RaisePostBackEvent permet au contrôle de gérer l'événement et d'en déclencher d'autres. En outre, l'infrastructure de page ASP.NET possède une architecture d'événement personnalisée qui permet à un contrôle de générer du code JavaScript côté client lançant une publication personnalisée. Normalement, la publication n'est lancée que par quelques éléments, tels qu'un bouton Envoyer ou un bouton Image. Cependant, en émettant du code JavaScript côté client, un contrôle peut également lancer la publication à partir d'autres éléments HTML.

L'exemple suivant définit un contrôle personnalisé, NonComposition2, basé sur l'exemple précédent, NonComposition1. Outre l'interface fournie par NonComposition1, il restitue deux HtmlButtons qui génèrent du code JavaScript côté client afin de lancer la publication lorsque vous cliquez dessus. Les attributs de nom de ces boutons sont Ajouter et Soustraire. L'attribut de nom est passé sous la forme d'un argument de chaîne à RaisePostBackEvent par l'infrastructure de page. NonComposition2 implémente RaisePostBackEvent pour incrémenter la propriété Value si vous cliquez sur Ajouter ou pour, au contraire, décrémenter la propriété Value si vous cliquez sur Soustraire, de la manière illustrée ci-dessous.


Public Sub RaisePostBackEvent
(eventArgument As String) If eventArgument = "Add" Then Me.Value = Me.Value + 1 Else Me.Value = Me.Value - 1 End If End Sub
C# VB JScript  

L'interface utilisateur présentée au client est identique à celle de l'exemple précédent. Cependant, la totalité de l'interface utilisateur est restituée par un contrôle personnalisé qui traite également les événements de publication. Le développeur de pages peut se contenter d'ajouter NonComposition2 à la page, sans fournir de logique de gestion des événements. L'exemple suivant illustre ce code en action.

 
VB NonComposition2.aspx


Développement d'un contrôle basé sur un modèle

L'infrastructure de page ASP.NET permet aux développeurs de contrôles de créer des contrôles séparant l'interface utilisateur de la logique du contrôle à l'aide de modèles. Les développeurs de pages peuvent personnaliser leur présentation du contrôle en fournissant l'interface utilisateur sous la forme de paramètres insérés entre les balises du modèle.

Les contrôles basés sur un modèle possèdent une ou plusieurs propriétés de type System.Web.UI.ITemplate, comme le montre l'exemple suivant.


Public Property <TemplateContainer(GetType
(Template1VB))> MessageTemplate As ITemplate
C# VB JScript  

L'attribut (entre crochets droits ci-dessus) spécifie le type du contrôle conteneur (parent).

L'interface ITemplate possède une méthode, InstantiateIn, qui crée une instance de contrôle de manière dynamique. Elle est appelée sur la propriété ITemplate de la méthode CreateChildControls, comme le montre l'exemple suivant.


Protected Overrides Sub CreateChildControls()
    If MessageTemplate <> Null Then
        MessageTemplate.InstantiateIn(Me)
    End if
    ...
End Sub
C# VB JScript  

L'exemple suivant illustre un contrôle basé sur un modèle simple et son utilisation dans une page ASP.NET.

 
VB Template1.aspx


Développement d'un contrôle basé sur un modèle lié aux données

L'exemple suivant illustre une utilisation plus complexe des modèles en vue de créer un contrôle lié aux données. Le contrôle Repeater défini dans cet exemple est similaire au contrôle System.Web.UI.WebControls.Repeater.

 
VB Repeater1.aspx

L'exemple suivant modifie l'exemple précédent afin qu'un consommateur de page puisse parcourir sa collection Items pendant la publication pour en extraire des valeurs.

 
VB Repeater2.aspx


Remplacement de l'analyse du contrôle

Comme décrit à la section Récupération de contenu interne, si un contrôle A possède des contrôles imbriqués dans ses balises de contrôle sur une page, l'analyseur de page ajoute des instances de ces contrôles à la collection Controls de A. Cette opération s'effectue en appelant la méthode AddSubParsedObject de A. Chaque contrôle hérite de cette méthode de Control. L'implémentation par défaut insère simplement un contrôle enfant dans l'arborescence de la hiérarchie des contrôles. Un contrôle peut substituer la logique d'analyse par défaut en écrasant la méthode AddSubParsedObject. Remarquez que ces explications sont quelque peu simplifiées. Pour plus de détails, consultez l'exemple suivant.

L'exemple suivant définit un contrôle personnalisé, CustomParse1, qui substitue la logique d'analyse par défaut. Lorsqu'un contrôle enfant d'un certain type est analysé, il est ajouté à une collection. La logique de restitution de CustomParse1 se base sur le nombre d'éléments de cette collection. Un contrôle personnalisé simple, Item, est également défini dans l'exemple.

 
VB CustomParse1.aspx

Remarque : Si votre contrôle personnalisé dérive de WebControl, il ne possède pas la logique d'analyse décrite dans l'exemple, car WebControl est marqué de ParseChildrenAttribute(ChildrenAsProperties = true), ce qui génère une autre logique d'analyse. Pour plus d'informations sur ParseChildrenAttribute, consultez la documentation du Kit de développement. La rubrique Récupération de contenu interne décrit également ce problème en détail.


Définition d'un générateur de contrôle personnalisé

L'infrastructure de page ASP.NET utilise des classes appelées générateurs de contrôle pour traiter les déclarations au sein des balises de contrôle d'une page. Chaque contrôle Web Forms est associé à une classe de générateur de contrôle par défaut, System.Web.UI.ControlBuilder. Le générateur de contrôle par défaut ajoute un contrôle enfant à la collection Controls pour chaque contrôle imbriqué qu'il rencontre au sein des balises de contrôle. En outre, il ajoute des contrôles Literal pour le texte situé entre les balises de contrôle imbriquées. Vous pouvez substituer ce comportement par défaut en associant une classe de générateur de contrôle personnalisé à votre contrôle. Dans ce but, appliquez à votre contrôle un attribut de générateur de contrôle, comme le montre l'exemple suivant.


Public Class <ControlBuilderAttribute
(GetType(CustomParse2ControlBuilderVB))> _ CustomParse2VB : Inherits Control
C# VB JScript  

L'élément entre crochets droits ci-dessus est un attribut du Common Language Runtime qui associe la classe CustomParse2ControlBuilder au contrôle CustomParse2. Vous pouvez définir votre propre générateur de contrôle personnalisé en le dérivant de ControlBuilder et en remplaçant ses méthodes.

L'exemple suivant définit un générateur de contrôle personnalisé qui substitue la méthode GetChildControlType héritée de ControlBuilder. Cette méthode retourne le type du contrôle à ajouter et peut être utilisée pour décider des contrôles à inclure. Dans l'exemple, le générateur de contrôle n'ajoute un contrôle enfant que si la balise porte le nom « customitem ». Le code du contrôle ressemble considérablement à celui de l'exemple précédent, à l'exception de l'ajout de l'attribut personnalisé.

 
VB CustomParse2.aspx



Nos serveurs sont désormais des serveurs
Pentium 3 Ghz, 1 Go Ram

 La formule de base est à 10 Euros TTC / mois
Si vous avez des besoins plus spécifiques (composants, espace disque...), nous sommes la pour répondre à vos questions.
Rappel : les frais d'installation sont gratuits


Prosygma élu meilleur site.
 
Trois nouveaux composants ASP sont désormais en place sur toutes nos formules.Il s'agit de ASPIMAGE, ASPPOP3 et ASPMAIL.


La dernière version de Microsoft® .NET Framework contient tout ce qu'il vous faut pour faire fonctionner des applications .NET Framework est disponible sur nos serveurs

Cliquez içi pour commander votre hébergement .Net

Votre nom de domaine en .com, .net ou .org au prix unique : 20 Euros

  Vérifiez la disponibilité d'un nom de domaine