ExpressionBuilder Classe

Definizione

Valuta le espressioni durante l'analisi della pagina.Evaluates expressions during page parsing.

public ref class ExpressionBuilder abstract
public abstract class ExpressionBuilder
type ExpressionBuilder = class
Public MustInherit Class ExpressionBuilder
Ereditarietà
ExpressionBuilder
Derivato

Esempi

Negli esempi di codice seguenti viene illustrato come compilare un generatore di espressioni personalizzato implementando la ExpressionBuilder classe astratta.The following code examples demonstrate how to build a custom expression builder by implementing the ExpressionBuilder abstract class. Questa implementazione di ExpressionBuilder restituisce un'istruzione valutata che viene passata all'espressione.This implementation of ExpressionBuilder returns an evaluated statement that is passed to the expression. Per eseguire questo esempio, è necessario innanzitutto registrare il generatore di espressioni personalizzato nel file Web. config.To run this example, you must first register the custom expression builder in the Web.config file. Nel primo esempio di codice viene illustrato come registrare il generatore di espressioni personalizzato nel file Web. config.The first code example demonstrates how to register the custom expression builder in the Web.config file.

<configuration>  
    <system.web>  
       <compilation>  
          <expressionBuilders>  
              <add expressionPrefix="MyCustomExpression"  
               type="MyCustomExpressionBuilder"/>  
          </expressionBuilders>  
       </compilation>  
    </system.web>  
</configuration>  

Nel secondo esempio di codice viene illustrato come fare riferimento all'espressione in un file aspx.The second code example demonstrates how to reference the expression in an .aspx file.

<asp:Label ID="Label1" runat="server"   
Text="<%$ MyCustomExpression:Hello, world! %>" />  

Nel terzo esempio di codice viene illustrato come sviluppare un generatore di espressioni personalizzato mediante la ExpressionBuilderderivazione da.The third code example demonstrates how to develop a customized expression builder by deriving from ExpressionBuilder. Per eseguire questo esempio di codice, è necessario inserire la classe nella cartella App_Code.To run this code example, you must place the class in the App_Code folder.

using System;
using System.CodeDom;
using System.Web.UI;
using System.ComponentModel;
using System.Web.Compilation;
using System.Web.UI.Design;

// Apply ExpressionEditorAttributes to allow the 
// expression to appear in the designer.
[ExpressionPrefix("MyCustomExpression")]
[ExpressionEditor("MyCustomExpressionEditor")]
public class MyExpressionBuilder : ExpressionBuilder
{
    // Create a method that will return the result 
    // set for the expression argument.
    public static object GetEvalData(string expression, Type target, string entry)
    {
        return expression;
    }

    public override object EvaluateExpression(object target, BoundPropertyEntry entry, 
    object parsedData, ExpressionBuilderContext context)
    {
        return GetEvalData(entry.Expression, target.GetType(), entry.Name);
    }

    public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, 
    object parsedData, ExpressionBuilderContext context)
    {
        Type type1 = entry.DeclaringType;
        PropertyDescriptor descriptor1 = TypeDescriptor.GetProperties(type1)[entry.PropertyInfo.Name];
        CodeExpression[] expressionArray1 = new CodeExpression[3];
        expressionArray1[0] = new CodePrimitiveExpression(entry.Expression.Trim());
        expressionArray1[1] = new CodeTypeOfExpression(type1);
        expressionArray1[2] = new CodePrimitiveExpression(entry.Name);
        return new CodeCastExpression(descriptor1.PropertyType, new CodeMethodInvokeExpression(new 
       CodeTypeReferenceExpression(base.GetType()), "GetEvalData", expressionArray1));
    }

    public override bool SupportsEvaluate
    {
        get { return true; }
    }
}
Imports System.CodeDom
Imports System.Web.UI
Imports System.ComponentModel
Imports System.Web.Compilation
Imports System.Web.UI.Design

' Apply ExpressionEditorAttributes to allow the 
' expression to appear in the designer.
<ExpressionPrefix("MyCustomExpression")> _
<ExpressionEditor("MyCustomExpressionEditor")> _
Public Class MyExpressionBuilder
    Inherits ExpressionBuilder
    ' Create a method that will return the result 
    ' set for the expression argument.
    Public Shared Function GetEvalData(ByVal expression As String, _
       ByVal target As Type, ByVal entry As String) As Object
        Return expression
    End Function

    Public Overrides Function EvaluateExpression(ByVal target As Object, _
       ByVal entry As BoundPropertyEntry, ByVal parsedData As Object, _
       ByVal context As ExpressionBuilderContext) As Object
        Return GetEvalData(entry.Expression, target.GetType(), entry.Name)
    End Function

    Public Overrides Function GetCodeExpression(ByVal entry _
       As BoundPropertyEntry, ByVal parsedData As Object, ByVal context _
       As ExpressionBuilderContext) As CodeExpression
        Dim type1 As Type = entry.DeclaringType
        Dim descriptor1 As PropertyDescriptor = _
           TypeDescriptor.GetProperties(type1)(entry.PropertyInfo.Name)
        Dim expressionArray1(2) As CodeExpression
        expressionArray1(0) = New CodePrimitiveExpression(entry.Expression.Trim())
        expressionArray1(1) = New CodeTypeOfExpression(type1)
        expressionArray1(2) = New CodePrimitiveExpression(entry.Name)
        Return New CodeCastExpression(descriptor1.PropertyType, _
           New CodeMethodInvokeExpression(New CodeTypeReferenceExpression _
           (MyBase.GetType()), "GetEvalData", expressionArray1))
    End Function

    Public Overrides ReadOnly Property SupportsEvaluate() As Boolean
        Get
            Return True
        End Get
    End Property
End Class

Commenti

La ExpressionBuilder classe è la classe base per i generatori di espressioni, ad AppSettingsExpressionBuilder esempio la classe, che creano espressioni di codice durante l'analisi della pagina.The ExpressionBuilder class is the base class for expression builders, such as the AppSettingsExpressionBuilder class, that create code expressions during page parsing.

I generatori di espressioni analizzano espressioni dichiarative e creano codice per recuperare i valori associati a una proprietà del controllo.Expression builders parse declarative expressions and create code to retrieve values bound to a control property. In scenari senza compilazione, un generatore di espressioni che supporta una funzionalità senza compilazione valuta l'espressione in fase di esecuzione.In no-compile scenarios, an expression builder that supports a no-compile feature evaluates the expression during run time.

Quando il parser di pagine rileva un'espressione delimitata dalla stringa <%$ %>, viene creato un generatore di espressioni per l'espressione in base al prefisso nella stringa.When the page parser encounters an expression that is delimited with the string <%$ %>, it creates an expression builder for the expression based on the prefix in the string. Il prefisso è la parte della stringa a sinistra dei due punti (:).The prefix is the portion of the string that is to the left of the colon (:). Ad esempio, quando il parser rileva la stringa <%$ ConnectionStrings:MessageDB %>, viene creato un ConnectionStringsExpressionBuilder oggetto.For example, when the parser encounters the string <%$ ConnectionStrings:MessageDB %>, it creates a ConnectionStringsExpressionBuilder object. I prefissi sono associati ai generatori di espressioni nel file Web. config nella ExpressionBuilders sezione.Prefixes are associated with expression builders in the Web.config file in the ExpressionBuilders section.

Il lato destro dell'espressione dichiarativa viene passato al generatore di espressioni per la valutazione.The right side of the declarative expression is passed to the expression builder for evaluation. Eseguire l' GetCodeExpression override del metodo per generare il codice che verrà compilato con la pagina.Override the GetCodeExpression method to generate code that will be compiled with the page.

Se si desidera che il generatore di espressioni personalizzato sia attivo nelle pagine non compilate, è necessario eseguire l' EvaluateExpression override anche del metodo per restituire un oggetto che rappresenta i risultati dell'espressione.If you want the custom expression builder to be active on pages that are not compiled, you must also override the EvaluateExpression method to return an object that represents the results of the expression. È inoltre necessario eseguire l' SupportsEvaluate override della proprietà per indicare che il generatore di espressioni personalizzato supporta le pagine senza compilazione.You also must override the SupportsEvaluate property to indicate that the custom expression builder does support no-compile pages.

È possibile definire un set di proprietà e metodi per la selezione e la valutazione di un'espressione associata a una proprietà del controllo in fase di progettazione implementando un editor di espressioni.You can define a set of properties and methods for selecting and evaluating an expression that is associated with a control property at design time by implementing an expression editor. L'editor è contrassegnato nel generatore di espressioni tramite metadati a livello di classe.The editor is marked on the expression builder through class-level metadata. Per ulteriori informazioni, vedere ExpressionEditor.For more information, see ExpressionEditor.

Note per gli implementatori

Quando si eredita dalla ExpressionBuilder classe, è necessario eseguire l'override del GetCodeExpression(BoundPropertyEntry, Object, ExpressionBuilderContext) metodo.When you inherit from the ExpressionBuilder class, you must override the GetCodeExpression(BoundPropertyEntry, Object, ExpressionBuilderContext) method.

Costruttori

ExpressionBuilder()

Inizializza una nuova istanza della classe ExpressionBuilder.Initializes a new instance of the ExpressionBuilder class.

Proprietà

SupportsEvaluate

Se sottoposto a override in una classe derivata, restituisce un valore che indica se l'oggetto ExpressionBuilder corrente supporta le pagine di non compilazione.When overridden in a derived class, returns a value indicating whether the current ExpressionBuilder object supports no-compile pages.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
EvaluateExpression(Object, BoundPropertyEntry, Object, ExpressionBuilderContext)

Quando viene eseguito l'override in una classe derivata, restituisce un oggetto che rappresenta un'espressione valutata.When overridden in a derived class, returns an object that represents an evaluated expression.

GetCodeExpression(BoundPropertyEntry, Object, ExpressionBuilderContext)

Quando sottoposto a override in una classe derivata, restituisce il codice utilizzato durante l'esecuzione della pagina per ottenere l'espressione valutata.When overridden in a derived class, returns code that is used during page execution to obtain the evaluated expression.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ParseExpression(String, Type, ExpressionBuilderContext)

Quando sottoposto a override in una classe derivata, restituisce un oggetto che rappresenta l'espressione analizzata.When overridden in a derived class, returns an object that represents the parsed expression.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a

Vedi anche