Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
Exporter (0) Imprimer
Développer tout
Important Il est possible que le présent document ne corresponde pas aux pratiques recommandées pour le développement actuel. Par ailleurs, il se peut que des liens de téléchargement et d'autres ressources ne soient plus valides. La version recommandée actuelle est disponible ici.

Vue d'ensemble de l'architecture du comportement des contrôles adaptables

Mise à jour : novembre 2007

Cette rubrique fournit une vue d'ensemble de l'architecture du comportement de la commande auto-adaptative d'ASP.NET. Cet architecture vous permet d'étendre le rendu de contrôle pour accommoder de nombreux types de navigateurs différents, y compris ceux des appareils mobiles.

Le comportement des contrôles adaptable est le comportement des contrôles qui est personnalisé pour les appareils cibles. ASP.NET 2.0 fournit une architecture adaptable qui permet que des étapes clés du cycle de vie d'un contrôle soient interceptées et substituées par un comportement personnalisé. Par défaut, l'infrastructure de page ASP.NET mappe une seule instance d'un adaptateur à chaque contrôle de chaque demande. Dans la plupart des cas, ce mappage par défaut est assez flexible pour satisfaire la plupart des besoins des développeurs. Dans certains cas, un adaptateur personnalisé peut être dérivé et mappé à un contrôle afin de satisfaire une autre configuration requise pour le comportement des contrôles sur une famille d'appareils ou un appareil donné.

Un exemple courant de comportement adaptable des contrôles est le rendu adaptable au cours duquel une page Web ASP.NET est restituée de façon spécifique dans le navigateur ou le balisage. Cela est particulièrement utile lors de l'écriture d'applications qui prennent en charge des navigateurs qui utilisent des langages de balisage différents. Il existe plusieurs façons de contrôler le rendu adaptable d'une page Web dans ASP.NET, depuis la spécification du rendu XHTML par défaut de votre application jusqu'à la fourniture d'un objet ControlAdapter personnalisé. La fourniture d'un objet ControlAdapter personnalisé est une tâche avancée et n'est pas requise dans la plupart des scénarios utilisateur.

Il est possible de contrôler le rendu adaptable de plusieurs façons :

  • Configurez votre application afin de restituer plusieurs balisages.

  • Utilisez la classe XhtmlTextWriter ou ChtmlTextWriter pour personnaliser les balises et les attributs des contrôles.

  • Créez une classe TextWriter personnalisée afin de restituer la sortie.

  • Utilisez le balisage déclaratif de périphérique ou le filtrage de navigateur pour affecter le mode de définition des propriétés de contrôle en fonction des définitions de filtres de périphérique.

  • Fournissez un adaptateur de contrôles personnalisé qui vous permet de substituer une méthode du cycle de vie de l'adaptateur à la méthode du cycle de vie par défaut d'un contrôle.

En plus du rendu adaptable, un autre comportement des contrôles qui peut être adapté ou spécifié en fonction d'un appareil cible comporte les étapes suivantes :

  • Traitement des données de publication (postback)

  • Gestion de l'état d'affichage

  • Empêchement de l'adaptation d'un contrôle personnalisé

Rendu par défaut

Lors du rendu par défaut de page Web ASP.NET, une instance de la classe HtmlTextWriter est créée et la méthode RenderControl est appelée de manière récursive à l'aide du paramètre qui a pour valeur l'instance de la classe HtmlTextWriter. Chaque contrôle dans la hiérarchie des contrôles de la page ajoute son balisage à la fin de l'objet HtmlTextWriter. Le contenu du HtmlTextWriter résultant est ce qui est restitué sur le navigateur résultant.

Lors du rendu du contenu HTML 3.2 aux clients, ASP.NET utilise automatiquement la classe Html32TextWriter. Pour déterminer le type d'objet TextWriter à utiliser, l'infrastructure de page ASP.NET interroge la propriété TagWriter de l'objet Browser.

Par défaut, lorsque vous utilisez des navigateurs qui prennent en charge le code HTML 4.0 ou versions ultérieures, les pages et les contrôles ASP.NET restituent le balisage qui est conforme à la norme XHTML 1.0 Transitional. Pour spécifier si ASP.NET restitue un balisage qui est conforme aux normes XHTML, configurez xhtmlConformance, élément (Schéma des paramètres ASP.NET) dans le fichier Web.config de votre application. Pour plus d'informations sur ASP.NET et XHTML, consultez ASP.NET et XHTML. Pour plus d'informations sur le cycle de vie de la page, consultez Vue d'ensemble du cycle de vie des pages ASP.NET.

Utilisation d'un objet TextWriter personnalisé

Par défaut, ASP.NET utilise l'objet TextWriter approprié à l'appareil demandeur. Lorsque vous avez besoin de plus de contrôle sur TextWriter, vous pouvez utiliser une classe existante qui hérite de la classe HtmlTextWriter ou vous pouvez créer un writer de texte personnalisé.

Les classes XhtmlTextWriter et ChtmlTextWriter sont deux classes de l'infrastructure de page ASP.NET qui héritent des classes HtmlTextWriter et Html32TextWriter, respectivement. Les classes XhtmlTextWriter et ChtmlTextWriter fournissent d'autres fonctions de rendu adaptable. Par exemple :

  • La classe XhtmlTextWriter est utile pour restituer le balisage XHTML sur des appareils mobiles et fournit des méthodes pour personnaliser des attributs des éléments XHTML rendus.

  • La classe ChtmlTextWriter sert à restituer le langage cHTML ou HTML compact sur des appareils dotés d'une mémoire et d'une unité centrale de capacité limitée, de petits écrans de visualisation, de fonctions de mise en forme limitées et d'un nombre limité d'options d'entrée, tels qu'une tablette tactile de téléphone cellulaire.

Si vous créez un writer de texte personnalisé ou si vous souhaitez spécifier un writer de texte particulier afin de restituer la sortie d'un appareil spécifique, vous devez mapper le writer de texte au périphérique qui utilise l'attribut markupTextWriterType de l'élément controlAdapters dans un fichier browser de l'application.

Filtrage des périphériques/appareils

Les filtres de périphérique vous permettent de personnaliser de manière déclarative les aspects du rendu de sortie d'une propriété du contrôle serveur Web. Vous pouvez appliquer le filtrage aux propriétés de contrôle, aux attributs personnalisés et aux modèles. Vous pouvez également utiliser les filtres de périphérique sur certains attributs pour les directives @ Page et directives @ Control. Si plusieurs filtres de périphérique sont spécifiés pour une propriété ou un attribut, le filtre le plus spécifique est prioritaire.

  1. Les définitions de filtres de périphérique qui sont utilisées pour filtrer la sortie dépendent de la définition des types de navigateur, comme défini dans votre application. Les fichiers de définition de navigateur par défaut se trouvent dans le répertoire %SystemRoot%\Microsoft.NET\Framework\versionNumber\CONFIG\Browsers. Les fichiers de définition de navigateur qui sont spécifiés dans le dossier App_Browsers de l'application sont fusionnés avec les fichiers de définition par défaut.

Pour plus d'informations sur les filtres de périphérique, consultez Vue d'ensemble des filtres de périphérique ASP.NET. Pour plus d'informations sur le format de fichier browser, consultez Schéma du fichier de définition de navigateur (élément browsers).

Vue d'ensemble

Pour personnaliser le comportement d'une page ou d'un contrôle, ASP.NET vous permet de spécifier un objet ControlAdapter qui adapte ou modifie le comportement à des points importants dans le cycle de vie du contrôle. À chaque étape du cycle de vie, au cours de laquelle un appel à une méthode du cycle de vie se produit, l'infrastructure de page ASP.NET vérifie s'il y a un adaptateur associé pour le contrôle et effectue l'appel sur la méthode associée de l'adaptateur plutôt que sur la méthode du contrôle. Dans de nombreux cas, la méthode de l'adaptateur peut simplement renvoyer à la méthode du contrôle. Les adaptateurs pour la gestion d'état sont une exception à ce comportement dans la mesure où le comportement adaptable est un complément de l'état du contrôle.

Les situations dans lesquelles il est possible que vous souhaitiez substituer le comportement d"un contrôle par un adaptateur de contrôle sont les suivantes :

  • Pour fournir le traitement spécifique à la cible pendant une étape spécifique du cycle de vie du contrôle.

    Par exemple, vous pouvez utiliser la méthode OnInit de la classe ControlAdapter pour effectuer des tâches d'initialisation qui sont spécifiques au contrôle auquel l'adaptateur est joint et spécifiques à l'appareil cible sur lequel le contrôle est restitué.

  • Pour personnaliser le rendu spécifique à la cible.

    Par exemple, vous pouvez utiliser les méthodes Render et RenderChildren pour générer un balisage spécifique à la cible.

Les contrôles WebControlAdapter et PageAdapter

La classe ControlAdapter est une classe abstraite qui définit les fonctionnalités de base de tous les adaptateurs. Elle sert de classe de base aux classes WebControlAdapter et PageAdapter.

La classe WebControlAdapter est le point de début du rendu des contrôles qui héritent de façon adaptable de la classe WebControl. En plus des méthodes de la classe ControlAdapter, la classe WebControlAdapter ajoute plusieurs méthodes qui sont spécifiques au rendu des balises.

La classe PageAdapter abstraite est le point de début du rendu adaptable d'une page Web.

De plus, la classe PageAdapter définit les propriétés et méthodes qui activent le rendu adaptable dans le contexte des tâches au niveau de la page par défaut, telles que la mise en cache ou la gestion de la persistance des états de page. Par exemple, vous devrez peut-être mettre en cache en fonction du type du navigateur cible en plus de mettre en cache des pages en fonction des paramètres indépendants de la cible. Dans ce scénario, vous substituerez la propriété CacheVaryByParams de la classe PageAdapter afin de retourner une liste des autres paramètres GET ou POST pour contrôler la mise en cache spécifique à la cible.

De même que pour les writers de texte personnalisés, pour que les adaptateurs de contrôle personnalisés soient reconnus par l'infrastructure de page ASP.NET, ils doivent être définis dans l'élément controlAdapters du fichier browser de l'application. Pour plus d'informations sur le format de fichier browser, consultez Schéma du fichier de définition de navigateur (élément browsers).

Les modèles de design permettant de créer des adaptateurs incluent les indications suivantes :

  • Un contrôle qui hérite de la classe Control doit avoir un adaptateur qui hérite de la classe ControlAdapter.

  • Un contrôle qui hérite de la classe WebControl doit avoir un adaptateur qui hérite de la classe WebControlAdapter.

  • Les développeurs qui créent des contrôles personnalisés qui nécessitent que les fonctionnalités de l'adaptateur soient étendues doivent créer des adaptateurs de classe de base pour leurs contrôles.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft