les scriptlets sont des extraits de code figurant dans une page aspx. Ils sont délimités par des marqueurs spécifiques.
Le scriptlet

<% instruction %>

permet d'éxecuter des instructions dans leur ordre d'appartion dans la page. Elles sont exécutées lors du rendu de la page. Elles permettent d'imbriquer facilement des instructions dans le code html.
Exemple :

<%if (DateTime.Now.DayOfWeek == DayOfWeek.Saturday || DateTime.Now.DayOfWeek == DayOfWeek.Sunday)
{
%>
	<span>Bon week-end ...</span>
<%
}
else
{
%>
	<span>Bonne semaine ...</span>
<%
}
%>

les scriptlets sont des extraits de code figurant dans une page aspx. Ils sont délimités par des marqueurs spécifiques.
Le scriptlet

<%= expression %>

permet d'évaluer une expression lorsqu'elle apparait dans la page, dans le contexte d'exécution. Il peut s'agir de valeurs littérales, de variables, ou d'appels de méthodes.
Exemple :

<span>Nous sommes le : <%=DateTime.Now.ToShortDateString() %></span>

Attention, les expressions systématiques ne fonctionnent pas comme valeur d'attribut. Ainsi la syntaxe suivante :

<asp:Label runat="server" Text='<%=DateTime.Now.ToShortDateString()'/>

ne fonctionnera pas. Voir Qu'est-ce que le scriptlet d'expressions liées

les scriptlets sont des extraits de code figurant dans une page aspx. Ils sont délimités par des marqueurs spécifiques.
Le scriptlet

<%# expression %>

permet d'évaluer une expression lorsque la méthode de page ou de contrôle databinding() est appelée. Le principe est quasimement le même que pour les expressions systèmatiques.
Exemple :

<asp:Label runat="server" Text="<%#DateDuJour %>" ID="MonLabel" />

Sachant que dans le code behind, nous aurons (par exemple) :

protected string DateDuJour
{
    get { return string.Format("Nous sommes le {0}", DateTime.Now.ToShortDateString()); }
}
protected override void OnLoad(EventArgs e)
{
    if (!IsPostBack)
        MonLabel.DataBind();
    base.OnLoad(e);
}

Il faut bien faire attention à appeler correctement la méthode DataBind, lorsque l'on en a besoin.

les scriptlets sont des extraits de code figurant dans une page aspx. Ils sont délimités par des marqueurs spécifiques.
Le scriptlet

<%$ expression %>

permet d'analyser une expression à la compilation de la page, évaluée à chaque requete.
Ces expressions conviennent bien aux accès aux bases de données par exemple et son evaluées au moment du databind().
Asp.net connait 3 types d'expressions :

• ConnectionString, qui va lire dans la section ConnectionStrings du web.config
• AppSettings, qui va lire dans la section AppSettings du web.config
• Resources, qui lit une entrée dans un fichier de ressources

Exemple :

<asp:Label runat="server" Text="<%$AppSettings:version%>" ID="MonAppSettingsExpression"/>

Sachant que dans le web.config nous aurons (par exemple) :

<appSettings>
	<add key="version" value="1.0 alpha"/>
</appSettings>

Pour créer une expression personnalisée, il faut hériter de la classe ExpressionBuilder.
On aura aussi un attribut de classe de type ExpressionPrefix qui permettra de faire le lien avec le web.config.
On devra également surchager la méthode GetCodeExpression qui permet de construire un CodeExpression à partir de l'objet CodeMethodInvokeExpression.
Le minimum à implémenter dans cette fonction est de construire cet objet en lui passant le nom de la méthode qui fait l'évaluation :

<asp:Label runat="server" Text="<%$monexpression:nico-pyright(c)%>" ID="MonLabelExpression"/>

[ExpressionPrefix("monexpression")]
public class MonExpression : ExpressionBuilder
{
	public static object GetEvaluationString(string expression)
	{
		return string.Format("Hello : {0}", expression);
	}

	public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
	{
		CodePrimitiveExpression expression = new CodePrimitiveExpression(entry.Expression.Trim());
		return new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(GetType()), 
			"GetEvaluationString", new CodeExpression[] { expression });
	}
}

Ici on construit l'objet avec le type de l'expression (le type de la classe) et le nom de la méthode à appeler. Dans le troisième paramètre, on lui passe la valeur de l'expression qui ici vaut "nico-pyright(c)".
Il faudra ensuite définir l'expression personnalisée dans le web.config :

<compilation debug="true">
	<expressionBuilders>
		<add expressionPrefix="monexpression" type="testWeb.MonExpression, testWeb"/>
	</expressionBuilders>
</compilation>

On utilise toujours la notation namespace.classe, assemblage pour le type. On aura aussi noté la correspondance entre l'expressionPrefix et l'attribut de la classe.

On peut aussi surcharger la méthode GetCodeExpression pour lui passer plus de paramètres, comme le type de l'objet cible (ici un Label) ou le nom de la propriété (ici Text) comme le montre cet exemple de la msdn. Il suffira d'utiliser correctement les éléments CodeDom.
On aura par exemple :

[ExpressionPrefix("monexpression")]
public class MonExpression : ExpressionBuilder
{
	public static object GetEvalData(string expression, Type target, string entry)
	{
		return string.Format("Hello : {0}", expression);
	}

	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(GetType()), "GetEvalData", expressionArray1));
	}
}

Notez que la méthode GetEvalData prends trois paramètres, comme construit pour l'objet CodeMethodInvokeExpression