TemplateDefinition Classe

Définition

Espace de noms:

System.Web.UI.Design

Assembly:

System.Design.dll

Fournit des propriétés et des méthodes qui définissent un élément de modèle dans un contrôle serveur Web au moment du design.

C#

public class TemplateDefinition : System.Web.UI.Design.DesignerObject

Héritage

Object

DesignerObject

TemplateDefinition

Exemples

L’exemple de code suivant montre comment dériver une classe personnalisée à partir de la ControlDesigner classe . Ce concepteur de contrôles prend en charge un contrôle avec quatre modèles possibles.

Pour l’essayer, ajoutez une référence à l’assembly System.Design.dll, compilez le code, puis, dans un hôte de conception tel que Visual Studio 2005, consultez la page en mode Création. Sélectionnez le contrôle, cliquez sur la liste d’actions pour sélectionner un modèle à modifier, puis utilisez la fonctionnalité glisser-déplacer pour déplacer des contrôles dans le modèle.

C#

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

namespace ASPNet.Design.Samples
{
    // Set an attribute reference to the designer, and define 
    // the HTML markup that the toolbox will write into the source.
    [Designer(typeof(TemplateGroupsSampleDesigner)),
        ToolboxData("<{0}:TemplateGroupsSample runat=server></{0}:TemplateGroupsSample>")]
    public sealed class TemplateGroupsSample : WebControl, INamingContainer
    {
        // Field for the templates
        private ITemplate[] _templates;

        // Constructor
        public TemplateGroupsSample()
        {
            _templates = new ITemplate[4];
        }

        // For each template property, set the designer attributes 
        // so the property does not appear in the property grid, but 
        // changes to the template are persisted in the control.
        [Browsable(false),
            PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate Template1
        {
            get { return _templates[0]; }
            set { _templates[0] = value; }
        }
        [Browsable(false),
            PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate Template2
        {
            get { return _templates[1]; }
            set { _templates[1] = value; }
        }
        [Browsable(false),
            PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate Template3
        {
            get { return _templates[2]; }
            set { _templates[2] = value; }
        }
        [Browsable(false),
            PersistenceMode(PersistenceMode.InnerProperty)]
        public ITemplate Template4
        {
            get { return _templates[3]; }
            set { _templates[3] = value; }
        }

        protected override void CreateChildControls()
        {
            // Instantiate each template inside a panel
            // then add the panel to the Controls collection
            for (int i = 0; i < 4; i++)
            {
                Panel pan = new Panel();
                _templates[i].InstantiateIn(pan);
                this.Controls.Add(pan);
            }
        }
    }

    // Designer for the TemplateGroupsSample control
    public class TemplateGroupsSampleDesigner : ControlDesigner
    {
        TemplateGroupCollection col = null;

        public override void Initialize(IComponent component)
        {
            // Initialize the base
            base.Initialize(component);
            // Turn on template editing
            SetViewFlags(ViewFlags.TemplateEditing, true);
        }

        // Add instructions to the placeholder view of the control
        public override string GetDesignTimeHtml()
        {
            return CreatePlaceHolderDesignTimeHtml("Click here and use " +
                "the task menu to edit the templates.");
        }

        public override TemplateGroupCollection TemplateGroups
        {
            get
            {

                if (col == null)
                {
                    // Get the base collection
                    col = base.TemplateGroups;

                    // Create variables
                    TemplateGroup tempGroup;
                    TemplateDefinition tempDef;
                    TemplateGroupsSample ctl;

                    // Get reference to the component as TemplateGroupsSample
                    ctl = (TemplateGroupsSample)Component;

                    // Create a TemplateGroup
                    tempGroup = new TemplateGroup("Template Set A");

                    // Create a TemplateDefinition
                    tempDef = new TemplateDefinition(this, "Template A1", 
                        ctl, "Template1", true);

                    // Add the TemplateDefinition to the TemplateGroup
                    tempGroup.AddTemplateDefinition(tempDef);

                    // Create another TemplateDefinition
                    tempDef = new TemplateDefinition(this, "Template A2", 
                        ctl, "Template2", true);

                    // Add the TemplateDefinition to the TemplateGroup
                    tempGroup.AddTemplateDefinition(tempDef);

                    // Add the TemplateGroup to the TemplateGroupCollection
                    col.Add(tempGroup);

                    // Create another TemplateGroup and populate it
                    tempGroup = new TemplateGroup("Template Set B");
                    tempDef = new TemplateDefinition(this, "Template B1", 
                        ctl, "Template3", true);
                    tempGroup.AddTemplateDefinition(tempDef);
                    tempDef = new TemplateDefinition(this, "Template B2", 
                        ctl, "Template4", true);
                    tempGroup.AddTemplateDefinition(tempDef);

                    // Add the TemplateGroup to the TemplateGroupCollection
                    col.Add(tempGroup);
                }

                return col;
            }
        }

        // Do not allow direct resizing unless in TemplateMode
        public override bool AllowResize
        {
            get
            {
                if (this.InTemplateMode)
                    return true;
                else
                    return false;
            }
        }
    }
}

Remarques

La TemplateDefinition classe fournit une classe de définition de modèle de base qui peut être héritée de et étendue pour qu’un concepteur de contrôles puisse l’utiliser dans la prise en charge des contrôles modèle dans un hôte de conception tel que Visual Studio 2005. Un hôte de conception utilise les propriétés et les méthodes de la classe pour faciliter la TemplateDefinition création et la modification d’un modèle au moment de la conception.

Constructeurs

TemplateDefinition(ControlDesigner, String, Object, String)	Initialise une nouvelle instance de la classe TemplateDefinition à l'aide du concepteur, du nom de modèle, du modèle et du nom de propriété fournis.
TemplateDefinition(ControlDesigner, String, Object, String, Boolean)	Initialise une nouvelle instance de la classe TemplateDefinition à l'aide du concepteur, nom de modèle, modèle, nom de propriété fournis et si le contenu du modèle doit être limité aux contrôles serveur Web.
TemplateDefinition(ControlDesigner, String, Object, String, Style)	Initialise une nouvelle instance de la classe TemplateDefinition, à l'aide du concepteur, nom de modèle, modèle, nom de propriété et objet Style fournis.
TemplateDefinition(ControlDesigner, String, Object, String, Style, Boolean)	Initialise une nouvelle instance de la classe TemplateDefinition à l'aide du concepteur, nom de modèle, modèle, nom de propriété, objet Style fournis et si le contenu doit être limité aux contrôles serveur Web.

Propriétés

AllowEditing	Obtient une valeur qui indique si le modèle doit activer la modification de son contenu.
Content	Obtient ou définit le balisage HTML qui représente le contenu du modèle.
Designer	Obtient le composant de concepteur associé. (Hérité de DesignerObject)
Name	Obtient le nom de l'objet. (Hérité de DesignerObject)
Properties	Obtient les propriétés de l'objet. (Hérité de DesignerObject)
ServerControlsOnly	Récupère une valeur qui indique si le modèle doit limiter le contenu aux contrôles serveur Web, comme défini dans le constructeur TemplateDefinition. Cette propriété est en lecture seule.
Style	Récupère le style qui doit être appliqué au modèle tel que défini dans le constructeur TemplateDefinition. Cette propriété est en lecture seule.
SupportsDataBinding	Récupère ou définit une valeur qui indique si le modèle prend en charge la liaison de données.
TemplatedObject	Récupère le composant dans lequel le modèle réside. Cette propriété est en lecture seule.
TemplatePropertyName	Récupère le nom de propriété pour le modèle que l'hôte de conception doit afficher dans la grille des propriétés.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetService(Type)	Obtient un service de l'hôte de conception, tel qu'identifié par le type fourni. (Hérité de DesignerObject)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

IServiceProvider.GetService(Type)

Pour obtenir une description de ce membre, consultez GetService(Type). (Hérité de DesignerObject)

Méthodes d’extension

GetKeyedService<T>(IServiceProvider, Object)	Obtient un service de type T à partir de IServiceProvider.
GetKeyedServices(IServiceProvider, Type, Object)	Obtient une énumération des services de type serviceType à partir de .IServiceProvider
GetKeyedServices<T>(IServiceProvider, Object)	Obtient une énumération des services de type T à partir de .IServiceProvider
GetRequiredKeyedService(IServiceProvider, Type, Object)	Obtient un service de type serviceType à partir de IServiceProvider.
GetRequiredKeyedService<T>(IServiceProvider, Object)	Obtient un service de type T à partir de IServiceProvider.
CreateAsyncScope(IServiceProvider)	Crée un AsyncServiceScope qui peut être utilisé pour résoudre des services délimités.
CreateScope(IServiceProvider)	Crée un IServiceScope qui peut être utilisé pour résoudre des services délimités.
GetRequiredService(IServiceProvider, Type)	Obtient le service de type serviceType à partir du IServiceProvider.
GetRequiredService<T>(IServiceProvider)	Obtient le service de type T à partir du IServiceProvider.
GetService<T>(IServiceProvider)	Obtient le service de type T à partir du IServiceProvider.
GetServices(IServiceProvider, Type)	Obtient une énumération des services de type serviceType à partir du IServiceProvider.
GetServices<T>(IServiceProvider)	Obtient une énumération des services de type T à partir du IServiceProvider.
GetFakeLogCollector(IServiceProvider)	Obtient l’objet qui collecte les enregistrements de journal envoyés au faux journal.
GetFakeRedactionCollector(IServiceProvider)	Obtient l’instance de collecteur de faux réacteur à partir du conteneur d’injection de dépendances.

S’applique à

Voir aussi

• ControlDesigner
• TemplateGroups
• TemplatedControlDesigner
• Extension de la prise en charge au moment du design
• Comment : étendre l'apparence et le comportement des contrôles en mode design