ExpressionEditor Classe

  • Référence

Définition

Espace de noms:
System.Web.UI.Design
Assembly:
System.Design.dll

Définit un jeu de propriétés et de méthodes pour évaluer une expression associée à une propriété du contrôle au moment du design et pour fournir une feuille d'éditeur d'expressions à l'hôte de conception visuel pour une utilisation dans la boîte de dialogue de l'éditeur d'expressions. Cette classe est abstraite.

public ref class ExpressionEditor abstract
public abstract class ExpressionEditor
type ExpressionEditor = class
Public MustInherit Class ExpressionEditor
Héritage
Object
ExpressionEditor
Dérivé

Exemples

L’exemple de code suivant montre comment dériver de la ExpressionEditor classe pour définir un éditeur d’expression personnalisée.

using System;
using System.Collections;
using System.Collections.Specialized;
using System.CodeDom;
using System.Configuration;
using System.Web.UI.Design;
using System.Web.Compilation;

namespace ExpressionEditorSamples.CS
{
    [ExpressionPrefix("CustomAppSettings")]
    [ExpressionEditor(typeof(ExpressionEditorSamples.CS.CustomAppSettingsEditor))]
    public class CustomAppSettingsBuilder : AppSettingsExpressionBuilder
    {
        // Use the built-in AppSettingsExpressionBuilder class,
        // but associate it with a custom expression editor class.
    }

    public class CustomAppSettingsEditor : System.Web.UI.Design.ExpressionEditor
    {
        public override object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider)
        {
            KeyValueConfigurationCollection customSettings = null;

            if (serviceProvider != null)
            {
                IWebApplication webApp = (IWebApplication)serviceProvider.GetService(typeof(IWebApplication));
                if (webApp != null)
                {
                    Configuration config = webApp.OpenWebConfiguration(true);
                    if (config != null)
                    {
                        AppSettingsSection settingsSection = config.AppSettings;
                        if (settingsSection != null)
                        {
                            customSettings = settingsSection.Settings;
                        }
                    }
                }
            }

            if (customSettings != null)
            {
                return customSettings[expression];
            }

            return expression;
        }
    }
}

Remarques

Un hôte de concepteur visuel, tel que Visual Studio 2005, utilise la ExpressionEditor classe pour présenter des feuilles d’éditeur d’expressions personnalisées à l’utilisateur, puis évaluer l’expression sélectionnée pour le rendu au moment du design.

Lorsque vous parcourez la Expressions propriété d’un contrôle dans la grille Propriétés au moment du design, le concepteur visuel affiche une boîte de dialogue pour définir des expressions pour une propriété de contrôle. Vous pouvez sélectionner le type d’expression en fonction d’une liste de préfixes d’expression. Lorsque vous sélectionnez un préfixe d’expression dans la liste, le concepteur visuel utilise les objets associés et ExpressionEditorSheet associés ExpressionEditor pour définir, évaluer et convertir la chaîne d’expression en fonction de la syntaxe de ce type d’expression. Le concepteur visuel définit l’expression de la propriété de contrôle associée, puis utilise le résultat de l’expression évaluée pour affecter des valeurs de propriété de contrôle qui sont affichées sur l’aire de conception.

Les méthodes statiques GetExpressionEditor obtiennent l’éditeur d’expression associé à un préfixe d’expression ou un générateur d’expressions particulier. La ExpressionPrefix propriété d’un ExpressionEditor objet retourne le préfixe d’expression configuré. La EvaluateExpression méthode évalue une chaîne d’expression d’entrée. La GetExpressionEditorSheet méthode retourne l’implémentation ExpressionEditorSheet utilisée pour demander les propriétés d’expression personnalisées dans la boîte de dialogue expressions.

En règle générale, pour prendre en charge un nouveau type d’expression au moment du design, vous définissez un préfixe d’expression unique et fournissez des implémentations personnaliséesExpressionBuilder.ExpressionEditor Si vous le souhaitez, vous pouvez fournir une implémentation personnalisée ExpressionEditorSheet qui définit les propriétés utilisées pour former l’expression dans la boîte de dialogue expressions.

Le préfixe d’expression identifie le type d’expression personnalisé et associe une expression à l’éditeur d’expressions et au générateur d’expressions. Lorsque des expressions personnalisées sont analysées dans une page, le préfixe d’expression est utilisé pour créer des instances des classes et ExpressionEditor des associésExpressionBuilder. Pour associer un préfixe d’expression à un générateur d’expressions et un éditeur d’expression, appliquez les ExpressionEditorAttribute attributs et ExpressionPrefixAttribute les attributs à la classe personnalisée ExpressionBuilder et configurez le préfixe d’expression pour un générateur d’expressions dans l’élément expressionBuilders du fichier de configuration Web. Le préfixe n’est pas obligatoire, mais fortement recommandé.

Notes pour les responsables de l’implémentation

Les étapes suivantes sont nécessaires pour dériver une classe personnalisée ExpressionEditor :

Par exemple, la ResourceExpressionEditor classe dérive de la classe et fournit une implémentation pour évaluer et associer une référence de chaîne de ressource à une propriété de contrôle au moment de la ExpressionEditor conception. La ResourceExpressionBuilder classe est associée au préfixe Resources d’expression et à l’implémentation ResourceExpressionEditor . La GetExpressionEditorSheet(String, IServiceProvider) méthode retourne un ResourceExpressionEditorSheet, qui définit les propriétés individuelles qui forment une expression de référence de ressource.

Constructeurs

ExpressionEditor()

Initialise une nouvelle instance de la classe ExpressionEditor.

Propriétés

ExpressionPrefix

Obtient le préfixe d'expression qui identifie des chaînes d'expressions prises en charge par l'implémentation d'éditeur d'expressions.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
EvaluateExpression(String, Object, Type, IServiceProvider)

Évalue une chaîne d'expression et fournit la valeur au moment du design pour une propriété du contrôle.
GetExpressionEditor(String, IServiceProvider)

Retourne une implémentation ExpressionEditor associée au préfixe d'expression spécifié.
GetExpressionEditor(Type, IServiceProvider)

Retourne une implémentation ExpressionEditor associée au type de générateur d'expressions spécifié.
GetExpressionEditorSheet(String, IServiceProvider)

Retourne une feuille d'éditeur d'expressions qui est associée à l'éditeur d'expressions actuel.
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
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)

S’applique à

Voir aussi