Vue d'ensemble des contrôles utilisateur et des contrôles personnalisés

Traductions disponibles Traductions disponibles
Numéro d'article: 893667 - Voir les produits auxquels s'applique cet article
ASP.NET Support Voice colonne

Vue d'ensemble des contrôles utilisateur et des contrôles personnalisés

pour personnaliser cette colonne à vos besoins, nous souhaitons à inviter vous permet de soumettre vos idées sur les sujets qui vous intéressent et problèmes que vous souhaitez voir traités articles avenir de la base de connaissances et des colonnes Support Voice. Vous pouvez soumettre vos idées et vos commentaires à l'aide de l'écran Ask For It. Il existe également un lien vers le formulaire au bas de cette colonne.
Agrandir tout | Réduire tout

Sommaire

Introduction

Hi ! Il s'agit Parag, et je suis un technicien Utilisation le groupe de support Microsoft ASP.NET pour plus d'une année maintenant. Antérieures à rejoindre Microsoft, J'AI travaillé sur projets basés sur le Web et applications de bureau à l'aide des technologies Microsoft. Tout en offrant prise en charge de qualité à des clients, j'ai vu cas où certains confusion autour des contrôles personnalisés est survenu, et je souhaite simplement prendre un certain temps explique quelques concepts autour des contrôles personnalisés. Incorrecte en tant que telle qu'elle apparaît, pensez moi, une fois que vous obtenez le blocage de celui-ci, vous serez une meilleure position pour apprécier ASP.NET.

Vue d'ensemble

Dans mois-ci ce, j'aborderai les rubriques suivantes :
  • Que sont les contrôles utilisateur ?
  • Que sont les contrôles personnalisés ?
  • Quelles sont les différences base entre les contrôles utilisateur et les contrôles personnalisés ?
Je vais également introduire quelques les rubriques avancées concernant les contrôles personnalisés, tels que Gestion de l'état et le rendu de contrôles personnalisés.

Que sont les contrôles utilisateur ?

Contrôles utilisateur sont des contrôles personnalisés et réutilisables et ils utilisent les mêmes techniques qui sont salariés par les contrôles serveur HTML et Web. Elles offrent un moyen facile pour partitionner et de réutiliser des interfaces utilisateur communes entre des applications Web ASP.NET. Qu'ils utiliser le même modèle programmation Web Forms sur lequel une page Web Forms fonctionne. Pour plus d'informations sur les formulaires Web modèle de programmation, reportez-vous aux Web MSDN (Microsoft Developer Network) sites adresses suivantes :
Introduction aux pages Web Forms
http://msdn2.microsoft.com/en-us/library/65tcbxz3(vs.71).aspx

Web Forms le modèle de code
http://msdn2.microsoft.com/en-us/library/015103yb(vs.71).aspx

Comment faire pour créer un contrôle utilisateur

La syntaxe que vous utilisez pour créer un contrôle utilisateur est semblable à la syntaxe que vous utilisez pour créer une page de formulaires Web (.aspx). La seule différence est qu'un contrôle utilisateur n'inclut pas le <html> <body>, et <form> des éléments depuis une page Web Forms héberge le contrôle utilisateur. Pour créer un contrôle utilisateur, procédez comme suit :
  1. Ouvre un texte ou l'éditeur HTML et crée un bloc de code côté serveur exposition toutes les propriétés, méthodes et événements.
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. Créer une interface utilisateur pour le contrôle utilisateur.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

Comment faire pour utiliser un contrôle utilisateur dans une page Web Forms

  1. Créer une nouvelle page formulaires Web (.aspx) dans Visual Studio .NET 2002, Visual Studio .NET 2003, Microsoft Visual Studio 2005 ou n'importe quel éditeur de texte.
  2. Déclarer la directive @ Register . Par exemple, utiliser le code suivant.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    Remarque supposé que le contrôle utilisateur et la page Web Forms doivent dans le même emplacement.
  3. Pour utiliser le contrôle utilisateur dans la page Web Forms, utiliser le code suivant après la directive @ Register .
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Comment créer une instance d'un contrôle utilisateur par programmation dans le code de fichier d'une page Web Forms

L'exemple précédent instancier un contrôle utilisateur déclarative dans une page Web Forms à l'aide de la directive @ Register . Toutefois, vous pouvez instancier dynamiquement un contrôle utilisateur et l'ajouter à la page. Voici les étapes pour y parvenir :
  1. Créer une nouvelle page Web Forms dans Visual Studio.
  2. Accédez au fichier généré pour cette page Web Forms le code.
  3. Dans l'événement Page_Load de la classe page , écriture la code.
    // Load the control by calling LoadControl on the page class.
    Control c1 = LoadControl("test.ascx");
                
    // Add the loaded control in the page controls collection.	
    Page.Controls.Add(c1);
    
    Page.Controls.Add(C1) ; Remarque vous pouvez ajouter dynamiquement un contrôle utilisateur à certains événements du cycle de vie de page.

    Pour plus d'informations, reportez-vous aux sites Web adresses suivantes :
    Ajouter des contrôles à une page Web Forms par programmation
    http://msdn2.microsoft.com/en-us/library/kyt0fzt1(vs.71).aspx

    Cycle de vie de l'exécution de contrôle
    http://msdn2.microsoft.com/en-us/library/aa719775(vs.71).aspx

    Contrôles Web dynamiques, publications et état d'affichage, par Scott Mitchell
    http://aspnet.4guysfromrolla.com/articles/092904-1.aspx

Comment un contrôle utilisateur est traité

Lorsqu'une page avec un contrôle utilisateur est demandée, celui-ci se produit :
  • L'analyseur de page analyse le fichier .ascx spécifié dans l'attribut src dans la directive @ Register et génère une classe qui dérive de la classe System.Web.UI.UserControl .
  • L'analyseur compile puis dynamiquement la classe dans un assembly.
  • Si vous utilisez Visual Studio, puis au moment de la conception seulement, Visual Studio crée un code de fichier pour le contrôle utilisateur et le fichier est précompilée par le concepteur de lui-même.
  • Enfin, la classe pour le contrôle utilisateur, qui est généré dans le processus de génération de code dynamique et de compilation, inclut le code pour le code derrière le fichier (. ascx.cs) ainsi que du code écrit dans le fichier .ascx.

Que sont les contrôles personnalisés ?

Contrôles personnalisés sont des composants code compilé qui exécuter sur le serveur, exposer le modèle objet et le rendu du texte marques de révision, tels que HTML ou XML, comme un contrôle de formulaire Web ou d'utilisateur normal.

Comment choisir la classe de base de votre contrôle personnalisé

Pour écrire un contrôle personnalisé, vous devez directement ou indirectement dériver la nouvelle classe à partir de la classe System.Web.UI.Control ou de la classe System.Web.UI.WebControls.WebControl :
  • Vous devez dériver de System.Web.UI.Control si vous souhaitez que le contrôle pour afficher les éléments nonvisual. Par exemple, <meta> et <head> est des exemples de rendu nonvisual.
  • Vous devez dériver de System.Web.UI.WebControls.WebControl si vous souhaitez que le contrôle rendu HTML qui génère une interface visual sur l'ordinateur client.
Si vous souhaitez modifier la fonctionnalité de contrôles existants, comme un bouton ou une étiquette, vous pouvez dériver directement la nouvelle classe avec ces classes existantes et pouvez modifier leur comportement par défaut.

En bref, la classe de contrôle offre les fonctionnalités de base à laquelle vous pouvez placer il dans l'arborescence de contrôle pour une classe de page . La classe WebControl ajoute les fonctionnalités à la classe de contrôle de base pour l'affichage contenu visual sur l'ordinateur client. Par exemple, vous pouvez utiliser la classe WebControl pour contrôler l'aspect et les styles via les propriétés comme police, couleur et hauteur.

Comment faire pour créer et utiliser un contrôle personnalisé simple qui s'étend de System.Web.UI.Control à l'aide de Visual Studio

  1. Démarrez Visual Studio.
  2. Créer un projet de bibliothèque de classes et donnez-lui un nom, par exemple, CustomServerControlsLib.
  3. Ajouter un fichier source au projet, par exemple, SimpleServerControl.cs.
  4. Inclure la référence de l'espace de noms System.Web dans la section Références.
  5. Vérifier si les espaces de noms suivants sont incluses dans le fichier SimpleServerControl.cs.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Héritent de la classe SimpleServerControls avec la classe de base contrôle .
    public class SimpleServerControl : Control
  7. Remplacer la méthode Render pour écrire la sortie dans le flux de sortie.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    note La classe HtmlTextWriter possède les fonctionnalités d'écriture de code HTML dans un flux de texte. La méthode Write de la classe HtmlTextWriter génère le texte spécifié dans le flux de réponse HTTP et est la même manière que la méthode Response.Write .
  8. Compiler le projet de bibliothèque de classes. Il génère la sortie DLL.
  9. Ouvrez un existant ou créez un nouveau projet d'application Web ASP.NET.
  10. Ajouter une page Web Forms où le contrôle personnalisé peut être utilisé.
  11. Ajouter une référence à la bibliothèque de classe dans la section Références du projet ASP.NET.
  12. Enregistrer le contrôle personnalisé sur la page Web Forms.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Pour instancier ou utiliser le contrôle personnalisé dans la page Web Forms, ajoutez la ligne suivante de code dans les balises <form>.
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    Remarque dans ce code, SimpleServerControl est le contrôle classe nom dans la bibliothèque de classe.
  14. Exécutez la page Web Forms et vous verrez le résultat du contrôle personnalisé.
Si vous n'utilisez pas Visual Studio, vous devez exécuter les étapes suivantes :
  1. Ouvrez n'importe quel éditeur de texte.
  2. Créez un fichier nommé SimpleServerControl.cs et écrire le code exemple donné aux étapes 1 à 14.
  3. Dans la variable PATH, ajoutez le chemin d'accès suivant :
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Démarrez une invite de commandes, puis passez à l'emplacement où SimpleServerControl.cs est présent.
  5. Exécutez la commande suivante :
    csc /t:Library/sortie : CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs
    Pour plus d'informations sur le compilateur C# (csc.exe), reportez-vous au site Web MSDN suivant :
    http://msdn2.microsoft.com/en-us/library/1700bbwd(vs.71).aspx
  6. Pour exécuter le contrôle personnalisé sur la page Web Forms, procédez comme suit :
    1. Créez un répertoire sous le dossier wwwroot.
    2. Démarrez le Gestionnaire Internet Information Services (IIS), puis sélectionnez le nouveau répertoire comme répertoire racine virtuel.
    3. Créez un dossier emplacement sous le nouveau répertoire.
    4. Copier le contrôle personnalisé DLL dans le dossier Bin.
    5. Placer la page de formulaires Web exemple créé à la procédure précédente dans le nouveau répertoire.
    6. Exécuter l'exemple de page à partir du Gestionnaire de services Internet (IIS).
Maintenant que vous avez conçu un simple contrôle personnalisé, examinons comment exposer les propriétés et appliquer des attributs de conception sur ce contrôle personnalisé.

Comment faire pour exposer les propriétés du contrôle personnalisé

JE créer dans l'exemple précédent et introduire une ou plusieurs propriétés qui peuvent être configurées en utilisant le contrôle personnalisé sur la page Web Forms.

L'exemple suivant montre comment définir une propriété qui affiche un message à partir du contrôle un certain nombre d'heures, comme indiqué dans la propriété du contrôle :
  1. Ouvrez SimpleServerControl.cs dans un éditeur de texte.
  2. Ajouter une propriété dans la classe SimpleServerControl . classe publique
    public class SimpleServerControl : Control
    {
       private int noOfTimes;
       public int NoOfTimes
       {
           get { return this.noOfTimes; }
           set { this.noOfTimes = value; }
       } 
       protected override void Render (HtmlTextWriter writer)
       {
         for (int i=0; i< NoOfTimes; i++)
         {
           write.Write("Hello World.."+"<BR>");
         } 
       }
    }
    
  3. Compiler le contrôle personnalisé.
  4. Pour utiliser le contrôle personnalisé sur la page Web Forms, ajouter la nouvelle propriété à la déclaration de contrôle.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. Exécution de la page affiche le message "Hello world » du contrôle personnalisé, autant de fois que spécifié dans la propriété du contrôle.

Comment appliquer des attributs de conception sur le contrôle personnalisé

Pourquoi les attributs de conception sont nécessaires
Le contrôle personnalisé qui vous avez créé dans l'exemple précédent fonctionne comme prévu. Toutefois, si vous souhaitez utiliser ce contrôle dans Visual Studio, vous pouvez souhaitez que cette NoOfTimes propriété est sélectionné automatiquement dans la fenêtre Propriétés lorsque le contrôle personnalisé est sélectionné au moment de la création.

Pour ce faire, vous devez fournir les informations de métadonnées à Visual Studio, vous pouvez effectuer en utilisant une fonction dans Visual Studio appelés attributs. Attributs peuvent de définir une classe, une méthode, une propriété ou un champ. Lorsque Visual Studio charge classe le contrôle personnalisé, il vérifie les attributs définis en classe, méthode, propriété ou au niveau champ et modifie le comportement du contrôle personnalisé au moment de la conception en conséquence.

Pour en savoir plus sur les attributs, reportez-vous au site Web MSDN suivant :
http://msdn2.microsoft.com/en-us/library/Aa288059(VS.71).aspx
Nous allons créer un exemple qui attributs utilise couramment utilisés :
  1. Ouvrez SimpleServerControl.cs dans un éditeur de texte.
  2. Introduire certains attributs base au niveau classe, par exemple, DefaultProperty , ToolboxData et TagPrefixAttrbute . Nous allons créer notre exemple sur ces trois attributs.
            [
    	// Specify the default property for the control.		
    	DefaultProperty("DefaultProperty"),
    	
    	// Specify the tag that is written to the aspx page when the
            // control is dragged from the Toolbox to the Design view. 
    	// However this tag is optional since the designer automatically 
    	// generates the default tag if it is not specified.		
    	ToolboxData("<{0}:ControlWithAttributes runat=\"server\">" +
    		"</{0}:ControlWithAttributes>")
    	]
    	public class ControlWithAttributes : Control
    	{
    		private string _defaultProperty;
    		public string DefaultProperty
    		{
    			get { return "This is a default property value"; }
    			set { this._defaultProperty = value; }
    		}
    
    		protected override void Render(HtmlTextWriter writer)
    		{
    			writer.Write("Default Property --> <B>" + 
    			DefaultProperty + "</B>");
    		}
             }
    
  3. Il existe une balise plus appelée TagPrefixAttrbute . Il est un attribut de niveau assembly qui fournit un préfixe à une balise lorsque vous faites glisser le contrôle à partir de la boîte à outils vers le concepteur. Sinon, le concepteur génère un préfixe tel que « cc1 » par défaut. TagPrefixAttrbute n'est pas directement appliquée à la classe de contrôle. Pour appliquer TagPrefixAttrbute , ouvrez AssemblyInfo.cs, inclure la ligne de code suivante et puis recréez le projet.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    Remarque si vous souhaitez créer la source à l'aide de la ligne de commande, vous devez créer le fichier AssemblyInfo.cs, placez le fichier dans le répertoire qui contient tous les fichiers source et exécutez la commande suivante pour créer le contrôle :
    > csc /t:Library/sortie : ServerControlsLib.dll /r:System.dll /r : System.Web.dll *.cs

Quelles sont les différences base entre les contrôles utilisateur et les contrôles personnalisés ?

Maintenant que vous avez une idée de base de ce que sont les contrôles utilisateur et des contrôles personnalisés et comment les créer, voyons un rapidement les différences entre les deux.
Réduire ce tableauAgrandir ce tableau
facteurs contrôle utilisateur contrôle personnalisé
DéploiementConçu pour les scénarios d'application unique

Déployé dans le formulaire source (.ascx) avec le code source de l'application

Si le même contrôle doit être utilisé dans plus d'une application, elle introduit de redondance et de gestion des problèmes
Conçues de telle sorte qu'il peut être utilisé par plus d'une application

Déployée dans le répertoire bin de l'application ou dans le global assembly cache

Distribué aisément et sans problèmes associés de redondance et de maintenance
CréationCréation est semblable à la manière de pages Web Forms sont créées ; adapté pour le développement rapide développement d'applications (RAD)Écriture implique beaucoup de code car il n'existe aucune prise en charge du concepteur
ContenuUn bien meilleur choix lorsque vous avez besoin du contenu statique dans une disposition fixe, par exemple, lorsque vous faire les en-têtes et pieds de pagePlus adapté lorsqu'une application nécessite dynamique du contenu à afficher ; peuvent être réutilisées dans une application, par exemple, pour un données lié contrôle table avec des lignes dynamiques
CréationÉcriture ne nécessite pas beaucoup Création d'applications car ils sont créés au moment du design et principalement contiennent des données statiquesÉcriture de toutes pièces nécessite une bonne compréhension de cycle de vie du contrôle et l'ordre dans lequel les événements exécutez, qui est normalement pris soin de dans les contrôles utilisateur

Rubriques avancées

Ensuite, voyons un un quelques-unes des fonctionnalités avancées que vous pouvez utiliser pendant le développement de contrôles personnalisés.

Gestion d'état

Applications Web sont intégrées sur HTTP, qui est sans conservation de statut. Une page et de ses contrôles enfants sont créés sur chaque demande et cédées après la demande. Pour conserver l'état en programmation ASP classique, utilisez les objets session et application. Mais pour cela, vous devez faire beaucoup de codage. Pour éviter ce problème, ASP.NET fournit un mécanisme connu sous état d'affichage pour maintenir l'état entre plusieurs demandes le nom. Pour en savoir plus sur la gestion et le mode État, visitez les sites Web MSDN aux adresses suivantes :
Introduction à la gestion d'état de formulaires Web
http://msdn2.microsoft.com/en-us/library/75x4ha6s(vs.71).aspx

L'état d'affichage ASP.NET
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

Enregistrement Web Forms de valeurs avec l'état d'affichage page
http://msdn2.microsoft.com/en-us/library/4yfdwycw(vs.71).aspx
Exemple utilisant l'état d'affichage dans un contrôle personnalisé
ViewStateExample.cs
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Text;

namespace ServerControlLib
{
	/// <summary>
	/// When a page framework reloads this control after postback, it   
        /// will restore the values which are in view state.
	/// This control can easily perform state management without 
        /// implementing our own logic for maintaining the state.
	/// </summary>
	public class ViewStateExample : WebControl
	{
		// Text to be displayed in Text box control.
		private string _text;
		
		/*
		 * This property needs to be populated before every 
                 * postback in order to 
		 * retain its value.
		*/ 
		public string Text
		{
			get { return (_text == null) ? "_text property is empty"  : _text; }
			set { _text = value; }
		}

		/*
		 * This property needs to be filled once and should be 
                 * available on the successive postbacks.
		*/ 
		public string TextInViewState
		{
			get
			{
				object o = ViewState["TextInViewState"];
				return (o == null) ? "View state is empty" : (string)o;
			}
			set { ViewState["TextInViewState"] = value; } 
		}

		/*
		 * Over-ridden method on WebControl base class which                   
                 * displays both of the property values 
		 * i.e. one stored in view state and other which is not 
                 * saved in view state.
		*/
		protected override void RenderContents(HtmlTextWriter writer)
		{
			writer.Write("Text Without View State = ");
			writer.Write(Text);
			writer.Write("<hr><br>");
			writer.Write("Text In View State = ");
			writer.Write(TextInViewState);
		}
	}
}
Exemple utilisant le contrôle précédent d'une page Web Forms
ViewStateExampleDemo.aspx
<%@ Page Language="C#" %>
<%@ Register TagPrefix="CC" Namespace="ServerControlLib" Assembly = "ServerControlLib" %>

<html>
  <head>
    <script runat="server">
      void button1_Click(object sender, EventArgs e)
      {
          Control1.Text = textbox1.Text;
          Control1.TextInViewState = textbox2.Text;
      }
    </script>
  </head>
  <body>
    <form runat="server" ID="Form1">
      <br>
      Property Value Without View State: <asp:TextBox id="textbox1" 
        runat="server" />
      <br>
      Property Value with View State: <asp:TextBox id="textbox2" 
        runat="server" />

      <asp:Button text="Cause Postback" onClick="button1_Click" 
        id="button1" Runat="server" />

      Output from the ViewStateExample Control :
      <CC:ViewStateExample id="Control1" runat="server"/>
    </form>
  </body>
</html>

Rendu

Dans cette section, je décrirai brièvement les méthodes que vous devez remplacer lorsque vous dérivez un contrôle personnalisé à partir de la classe Control ou la classe WebControl .
Méthodes de la classe System.Web.UI.Control de rendu
Pour d'informations sur les méthodes de rendu de la classe System.Web.UI.Control , reportez-vous aux sites Web de MSDN adresses suivantes :
méthode Control.Render
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.render(vs.71).aspx

méthode Control.RenderControl
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.rendercontrol(vs.71).aspx

méthode Control.RenderChildren
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.renderchildren(vs.71).aspx
Comment un contrôle est affiché dans la page
Chaque page contient une arborescence de contrôle qui représente une collection de tous les contrôles enfants de cette page. Pour afficher l'arborescence des contrôles, un objet de la classe HtmlTextWriter est créé qui contient le code HTML pour être affiché sur l'ordinateur client. Cet objet est transmis à la méthode RenderControl . À son tour, la méthode RenderControl appelle la méthode Render . Ensuite, la méthode Render appelle la méthode RenderChildren sur chaque contrôle enfant, effectuer une boucle récursive jusqu'à ce que la fin de la collection est atteinte. Ce processus est mieux expliquent par le code exemple suivant. public
public void RenderControl(HtmlTextWriter writer) 
{
    // Render method on that control will only be called if its visible property is true.
    if (Visible)
    {
        Render(writer);
    }
}

protected virtual void Render(HtmlTextWriter writer) 
{
    RenderChildren(writer);
}
protected virtual void RenderChildren(HtmlTextWriter writer) 
{
    foreach (Control c in Controls) 
    {
        c.RenderControl(writer);
    }
} 
Si (visible) {Render(writer);}} protégé rendu invalider virtuel (rédacteur HtmlTextWriter) {RenderChildren(writer);} protégé RenderChildren invalider virtuel (rédacteur HtmlTextWriter) {foreach (contrôle c dans des contrôles) {c.RenderControl(writer);}}
Méthodes de la classe System.Web.UI.WebControl de rendu
Pour d'informations sur les méthodes de rendu de la classe System.Web.UI.WebControl , reportez-vous aux sites Web MSDN suivante :
méthode WebControl.RenderBeginTag
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderbegintag(vs.71).aspx

méthode WebControl.RenderContents
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.rendercontents(vs.71).aspx

méthode WebControl.RenderEndTag
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderendtag(vs.71).aspx
Comment le rendu de la classe WebControl a lieu
L'exemple de code suivant montre la méthode Render pour le contrôle personnalisé.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
Vous ne devez remplacer la méthode Render pour la classe WebControl . Si vous souhaitez rendre les contenus dans la classe WebControl , vous devez remplacer la méthode RenderContents . Toutefois, si vous voulez remplacer la méthode Render , vous devez remplacer la méthode RenderBeginTag , ainsi que la méthode RenderEndTag dans la commande qui apparaît dans l'exemple de code précédent.

Conclusion

C'est tout pour l'instant sur les contrôles utilisateur et des contrôles personnalisés dans ASP.NET 1.0 et 1.1 de ASP.NET. J'espère que cette colonne vous permet de comprendre la différence base entre eux et les différentes approches que vous permettent de développer les.

Merci de votre temps. Nous prévoyons d'écrire plus d'informations sur les rubriques avancées pour personnalisés contrôles, tels que Gestion de l'état, les styles de contrôle, contrôles composites et prise en charge à la conception pour les contrôles personnalisés, dans un avenir proche.

Pour plus d'informations sur les contrôles, reportez-vous aux sites Web MSDN aux adresses suivantes :
Notions fondamentales du développement contrôle ASP.NET serveur
http://msdn2.microsoft.com/en-us/library/aa310918(vs.71).aspx

Un examen complète des contrôles utilisateur
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

Les construction contenant des modèles personnalisés contrôles serveur ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

Événements dans les contrôles serveur ASP.NET
http://msdn2.microsoft.com/en-us/library/aa720049(vs.71).aspx

Contrôle composite et le contrôle utilisateur
http://msdn2.microsoft.com/en-us/library/aa719735(vs.71).aspx

Développement de contrôles serveur ASP.NET
http://msdn2.microsoft.com/en-us/library/aa719973(vs.71).aspx

Développement de contrôles personnalisés : concepts de clés
http://msdn2.microsoft.com/en-us/library/aa720226(vs.71).aspx

Ajoutant la prise en charge à la conception aux contrôles ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
Comme toujours, hésitez pas à envoyer des idées sur des sujets souhaité adressé avenir colonnes ou dans la Base de connaissances en utilisant le formulaire Ask For It.

Propriétés

Numéro d'article: 893667 - Dernière mise à jour: mercredi 14 novembre 2007 - Version: 1.8
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Mots-clés : 
kbmt kbhowto kbasp KB893667 KbMtfr
Traduction automatique
IMPORTANT : Cet article est issu du système de traduction automatique mis au point par Microsoft (http://support.microsoft.com/gp/mtdetails). Un certain nombre d?articles obtenus par traduction automatique sont en effet mis à votre disposition en complément des articles traduits en langue française par des traducteurs professionnels. Cela vous permet d?avoir accès, dans votre propre langue, à l?ensemble des articles de la base de connaissances rédigés originellement en langue anglaise. Les articles traduits automatiquement ne sont pas toujours parfaits et peuvent comporter des erreurs de vocabulaire, de syntaxe ou de grammaire (probablement semblables aux erreurs que ferait une personne étrangère s?exprimant dans votre langue !). Néanmoins, mis à part ces imperfections, ces articles devraient suffire à vous orienter et à vous aider à résoudre votre problème. Microsoft s?efforce aussi continuellement de faire évoluer son système de traduction automatique.
La version anglaise de cet article est la suivante: 893667
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com