ASP.NET: Encadernação caixa de texto maxlength para Classe constante em HTML

Question

Eu estou tentando permitir que os meus web designers para usar os metadados temos sobre os campos de banco de dados nas páginas ASP.NET que estão criando. A mais óbvia é a seguinte:

<asp:TextBox runat="server" id="txTextBox" MaxLength="<Value From Metadata here>" ... />

Todos os metadados necessários é armazenado em nossos objetos de classe e é acessível devido à sua natureza estática pública.

O benefício deste seria que eles podem definir valores que

a) pode alterar sem que eles sejam conscientes ou cuidar
b) melhorar a experiência do usuário com muito pouco codificação esforço

e todos sem tê-los precisa se preocupar com o que o valor é ou de onde veio. Este vai ser utilizada principalmente para controles ligados automaticamente - ou seja, aqueles que são adicionados com pouca ou nenhuma interação desenvolvedor.

Esta questão é muito semelhante ao das minhas perguntas anteriores que agora funciona maravilhosamente (mas que estava em WPF / XAML).

O ponto principal da questão é que eu quero tão pouco exigência desenvolvedor sobre este possível - Idealmente, haveria alguma sintaxe tipo <%# Constant.Value %> que poderia ser usado diretamente no atributo Maxlength="" do asp: controle caixa de texto o que significa que não necessita de código a ser adicionado a uma página / usercontrol em tudo.

Eu tenho um sentimento que não é possível, mas eu adoraria que alguém me provar que estou errado.

Ta

Answer 1

Você pode usar uma expressão de ligação de dados:

<asp:TextBox MaxLength="<%# Constant.Value %>" />

e , que exige que seja em um controle de ligação de dados. Se ele não está em um repetidor ou algo assim, você precisa chamar Container.DataBind () em algum ponto no ciclo de vida página.

Como alternativa, você pode criar um ExpressionBuilder o que permitiria sintaxe como:

<asp:TextBox MaxLength="<%$ Constants:Value %>" />

Aqui está um exemplo que vai puxar de um único dicionário estático:

using System;
using System.Web.UI;
using System.Web.Compilation;
using System.CodeDom;
using System.Collections.Generic;

class ConstantsExpressionBuilder : ExpressionBuilder {
   private static readonly Dictionary<string, object> Values = 
      new Dictionary<string, object>() {
         { "Value1", 12 },
         { "Value2", false },
         { "Value3", "this is a test" }
      };

   public override bool SupportsEvaluate { get { return true; } }

   public override object EvaluateExpression(object target, BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context) {
      string key = entry.Expression.Trim();
      return GetValue(key);
   }

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

   public static object GetValue(string key) {
      return Values[key];
   }
}

Você iria registrar isso em web.config:

<system.web>
   <compilation>
      <expressionBuilders>
    <add expressionPrefix="Constants" type="ConstantsExpressionBuilder" />
      </expressionBuilders>
   </compilation>
</system.web>

E chamá-lo em uma página ASPX:

<asp:Textbox runat="server" MaxLength="<%$ Constants:Value1 %>" ReadOnly="<%$ Constants:Value2 %>" Text="<%$ Constants:Value3 %>" />

O que deve produzir:

<input type="text" maxlength="12" readonly="false" value="this is a test" />

na saída HTML.

Answer 2

Eu acho que você deve ser capaz de fazê-lo com algo como isto

<asp:TextBox runat="server" id="txTextBox" MaxLength="<%=Constants.SomeValue%>" />

Mas a minha única preocupação é que isso realmente não faz muito sentido. Se a constante é armazenado em um arquivo .cs, a fim de fazer uma mudança que faria com que o novo valor constante a ser refletido na interface do usuário, você teria que recompilar o site. Eu acho que pode ser mais fácil apenas para ter um valor codificado duro na página .aspx que pode ser alterado facilmente, sem a necessidade de recompilar toda a base de código. Talvez eu não estou entendendo o problema embora.