Classes de concepteurs de base
Mise à jour : novembre 2007
Tous les concepteurs implémentent l'interface IDesigner, qui définit les méthodes de base des interfaces de concepteur. Le .NET Framework offre également un ensemble de classes de concepteur de base qui fournit des méthodes pouvant être utiles aux concepteurs qui prennent en charge des types de composants ou de contrôles spécifiques.
Interface IDesigner
Une classe de concepteur doit implémenter l'interface IDesigner, comme indiqué dans l'exemple de code suivant.
Public Interface IDesigner
Sub Dispose()
Sub Initialize(component As IComponent)
' Other methods.
...
ReadOnly Property Component() As IComponent
' Other properties.
...
End Interface
public interface IDesigner {
void Dispose();
void Initialize(IComponent component);
// Other methods.
...
IComponent Component {
get;
}
// Other properties.
...
}
La méthode Initialize de IDesigner est appelée après l'installation et l'initialisation d'un composant du concepteur et la création du concepteur. Vous pouvez substituer la méthode Initialize pour effectuer des actions qui doivent avoir lieu au moment de l'initialisation du concepteur ou d'un composant. Vous ne pouvez pas remplacer l'initialisation de constructeur pour le composant, mais vous pouvez l'augmenter ou redéfinir les propriétés à initialiser. La propriété Component de IDesigner est définie par l'intermédiaire de cette méthode d'initialisation. Vous devez toujours appeler base.Initialize(component) à partir de votre méthode Initialize si vous substituez cette méthode. Vous pouvez accéder au composant de IDesigner à partir de sa propriété Component.
La propriété Component fournit l'accès au composant auquel le concepteur est associé. Cette propriété est définie lorsque l'objet concepteur est créé pour la première fois et que sa méthode Initialize est appelée. Un site est associé au composant et le concepteur peut l'utiliser pour obtenir des services de l'hôte du concepteur.
La méthode DoDefaultAction est appelée lorsqu'un utilisateur double-clique sur un composant ou un contrôle.
La propriété Verbs peut être substituée pour retourner DesignerVerbCollection qui contient les objets nécessaires pour étendre les éléments d'un menu contextuel d'un composant.
La méthode Dispose est appelée lorsque l'objet concepteur doit être détruit. Elle est appelée chaque fois qu'un composant est supprimé du conteneur de design.
Classe de concepteur de base pour des composants
La classe ComponentDesigner implémente les interfaces IDesigner et IDesignerFilter pour fournir des méthodes supplémentaires qui peuvent être utiles à certains concepteurs de composants.
Classe de concepteurs de base pour les contrôles Windows Forms
La classe de concepteurs de base pour les contrôles Windows Forms est ControlDesigner. Cette classe dérive de ComponentDesigner et fournit des méthodes supplémentaires utiles pour personnaliser l'apparence et le comportement d'un contrôle Windows Forms. Pour voir un exemple d'implémentation d'un concepteur Windows Forms, consultez Comment : implémenter un concepteur pour un contrôle.
La classe DocumentDesigner fournit un concepteur de base afin d'étendre le comportement en mode design d'un Control qui prend en charge des contrôles imbriqués et reçoit les messages de la barre de défilement, et de fournir une vue design de niveau racine pour ce contrôle. Pour plus d'informations, consultez Comment : créer un contrôle Windows Forms qui bénéficie des fonctionnalités au moment du design.
Classe de concepteurs de base pour les contrôles serveur ASP.NET
La classe de concepteurs de base pour les contrôles serveur ASP.NET est ControlDesigner. Cette classe fournit les fonctionnalités de base pour le rendu du code HTML de design personnalisé. Les autres classes de base pour des tâches telles que la modification de modèle sont décrites dans Prise en charge des Web Forms au moment du design.
Classes de base pour l'intégration au moment du design
La classe TypeConverter fournit une classe de base pour convertir un type vers et à partir d'une représentation textuelle. Pour plus d'informations sur les convertisseurs de type, consultez Comment : implémenter un convertisseur de type ou Conversion de type généralisée.
La classe UITypeEditor fournit une classe de base dont vous pouvez dériver et que vous pouvez étendre pour implémenter un éditeur de type personnalisé pour l'environnement au moment du design. Pour plus d'informations sur l'implémentation d'un UITypeEditor, consultez Vue d'ensemble des éditeurs de types d'interface utilisateur.
Classes de base pour l'apparence et le comportement du concepteur
La classe Behavior peut être étendue pour développer tout type de comportement d'interface utilisateur, notamment les comportements de sélection, de glisser et de redimensionnement. La peinture et le test de recherche sont effectués par la classe Glyph.
Pour plus d'informations, consultez Vue d'ensemble du service de comportement.
Classes de base pour les chargeurs de concepteur
La classe BasicDesignerLoader fournit une implémentation de l'interface IDesignerLoaderService. Un BasicDesignerLoader est une implémentation complète d'un chargeur de concepteur sans aucun rapport avec un format de persistance.
CodeDomDesignerLoader est une classe abstraite qui fournit un chargeur de concepteur complet basé sur le modèle CodeDOM (Code Document Object Model).
Classes de base pour la sérialisation du concepteur
La classe CodeDomSerializerBase fournit une classe de base pour les classes CodeDomSerializer. La classe CodeDomSerializerBase est utilisée comme base partagée entre les classes CodeDomSerializer et TypeCodeDomSerializer.
La classe DesignerSerializationManager fournit une implémentation de l'interface IDesignerSerializationManager.
Pour plus d'informations, consultez Vue d'ensemble de la sérialisation du concepteur.
Classe de base pour les balises actives
La classe DesignerActionList fournit la classe de base pour les types qui définissent la liste des éléments utilisés pour créer un panneau des balises actives. Pour plus d'informations, consultez Comment : attacher des balises actives à un composant Windows Forms.
Classe de base pour la présentation personnalisée
La classe LayoutEngine fournit la classe de base pour implémenter des moteurs de présentation. Les contrôles TableLayoutPanel et FlowLayoutPanel utilisent la classe LayoutEngine pour fournir un comportement de mise en forme. Pour plus d'informations, consultez Comment : implémenter un moteur de présentation personnalisé.
Concepteurs standard
Le Kit de développement logiciel (SDK) Windows fournit un ensemble de concepteurs pour prendre en charge des types de composants spécifiques. Ces concepteurs sont nommés d'après les composants qu'ils conçoivent, avec le suffixe Concepteur. Par exemple, le concepteur pour la classe System.Windows.Forms.Control est System.Windows.Forms.Design.ControlDesigner.
Fonctionnalités courantes des concepteurs
Accès à des services au moment du design à partir d'un concepteur
La plupart des services au moment du design peuvent être demandés à l'aide d'une méthode GetService en passant le type du service à demander. Il existe une méthode GetService sur Component et ComponentDesigner. Il existe également une méthode GetService sur IServiceProvider qui est implémentée par le ISite retourné par la propriété Site d'un IComponent installé en mode design.
Le code suivant montre comment obtenir une interface de service IDesignerHost et IMenuCommandService à l'aide de la méthode GetService.
Pour plus d'informations, consultez Comment : accéder aux services au moment du design.
Le code suivant montre comment obtenir un service à partir d'une interface de fournisseur de service en mode design.
' Obtain an IDesignerHost service from the design-time environment.
Dim host As IDesignerHost = CType(Me.Component.Site.GetService(GetType(IDesignerHost)), IDesignerHost)
' Obtain an IMenuCommandService service.
Dim mcs As IMenuCommandService = CType(Me.Component.Site.GetService(GetType(IMenuCommandService)), IMenuCommandService)
// Obtain an IDesignerHost service from the design-time environment.
IDesignerHost host = (IDesignerHost)this.Component.Site.GetService(typeof(IDesignerHost));
// Obtain an IMenuCommandService service.
IMenuCommandService mcs =
(IMenuCommandService)this.Component.Site.GetService(typeof(IMenuCommandService));
Accès à des composants de projet à partir d'un concepteur
Un concepteur peut accéder aux composants d'un document en mode design en accédant à la collection Components de la propriété Container d'une interface de service IDesignerHost. L'exemple de code suivant montre comment accéder aux composants figurant dans le projet actif en mode design.
' Obtains an IDesignerHost service from the design-time environment.
Dim host As IDesignerHost = CType(Me.Component.Site.GetService(GetType(IDesignerHost)), IDesignerHost)
' Gets the components container for the current design-time project.
Dim container As IContainer = host.Container
' The host.Container IContainer contains each IComponent in the project.
// Obtains an IDesignerHost service from the design-time environment.
IDesignerHost host = (IDesignerHost)this.Component.Site.GetService(typeof(IDesignerHost));
// Gets the components container for the current design-time project.
IContainer container = host.Container;
// The host.Container IContainer contains each IComponent in the project.
Une fois que vous avez accès à la collection de composants, vous pouvez utiliser les méthodes TypeDescriptor et les objets PropertyDescriptor pour identifier des types et définir les valeurs des propriétés des composants. Vous pouvez également créer des composants à l'aide de la méthode CreateComponent de l'interface IDesignerHost.
Extension d'un concepteur
Lorsque vous dérivez d'un composant auquel un concepteur est associé, le concepteur de la classe de base est associé au composant dérivé par défaut. Vous pouvez associer un autre concepteur à votre composant en appliquant un attribut DesignerAttribute qui spécifie le type de concepteur à associer au composant. Il est courant qu'un composant dérivé possède un concepteur qui étend le concepteur de base.
Pour plus d'informations, consultez Comment : implémenter un concepteur pour un contrôle.
Pour étendre un concepteur
Définissez une classe qui dérive de la classe de base du concepteur.
Associez la nouvelle classe du concepteur à votre composant en appliquant DesignerAttribute.
L'exemple de code suivant définit un concepteur qui étend System.Web.UI.Design.WebControls.LabelDesigner et l'associe à une étiquette personnalisée qui étend System.Web.UI.WebControls.Label.
Namespace MyControls.Design
Public Class MyLabelDesigner
Inherits System.Web.UI.Design.WebControls.LabelDesigner
End Class
End Namespace
Namespace MyControls
<Designer(GetType(MyControls.Design.MyLabelDesigner))> _
Public Class MyLabel
Inherits System.Web.UI.WebControls.Label
End Class
End Namespace
namespace MyControls.Design {
public class MyLabelDesigner : System.Web.UI.Design.WebControls.LabelDesigner {}
}
namespace MyControls {
[Designer(typeof(MyControls.Design.MyLabelDesigner))]
public class MyLabel : System.Web.UI.WebControls.Label {}
}
.gif "Remarque") Remarque : |
|---|
Si vous définissez un concepteur pour une classe scellée, ou si vous ne souhaitez pas que d'autres classes utilisent ou héritent de votre concepteur, vous pouvez rendre votre classe de concepteurs interne à votre assembly. L'hôte de concepteur est toujours capable de créer une instance de votre concepteur, mais il ne contribue pas au modèle objet public. |
Voir aussi
Tâches
Comment : accéder aux services au moment du design
Comment : accéder à la prise en charge au moment du design dans les Windows Forms
Concepts
Comment : implémenter un concepteur pour un contrôle