In ASP.NET MVC, come faccio a visualizzare un nome di proprietà come un'etichetta che si divide su CamelCase

Question

So che l'ho già visto prima. Non riesco a ricordare se si trattasse di una demo del modello C4MVC o di un generatore di input! Ho bisogno di sapere come posso usare la convenzione di Camel per modificare le proprietà del mio modello di vista e avere la "proprietà CamelCasedProperty" resa nell'etichetta come "Proprietà del contenitore Camel". Questo dovrebbe essere gestito dalla creazione di un nuovo wizard di visualizzazione piuttosto che gestirlo in modo programmatico.

Answer 1

Dopo un po 'di tentativi, ho trovato un indizio su ciò che mi interessava fare. Guardando questo C4MVC video. Sono certo che questo potrebbe essere già completato in MVC Contrib come generatore di input. Tuttavia, sono molto interessato a comprendere tutte le puntellature per così dire per imparare tutto quello che posso per my upcoming book "ASP.NET MVC Cookbook" (shameless plug for public review). Ecco la soluzione che mi è venuta in mente che richiede solo il rinominare Html.LabelFor per Html.LabelFor2 nel formato di codice generato "create new view":

Ho creato un metodo per ottenere il nome della proprietà dal passato in lambda. Ho quindi creato un altro metodo per analizzare il nome della proprietà nelle lettere maiuscole contenute nel nome.

using System; 
using System.Linq.Expressions; 
using System.Text.RegularExpressions; 

namespace FuryPartners.WebClient.Helpers 
{ 
    public class HelperUtilities 
    { 
     internal static string PropertyName<T, TResult>(Expression<Func<T, TResult>> expression) 
     { 
      switch (expression.Body.NodeType) 
      { 
       case ExpressionType.MemberAccess: 
        var memberExpression = expression.Body as MemberExpression; 
        return memberExpression.Member.Name; 
       default: 
        return "oops"; 
      } 
     } 

     internal static string SplitCamelCase(string camelCaseString) 
     { 
      string output = System.Text.RegularExpressions.Regex.Replace(
       camelCaseString, 
       "([A-Z])", 
       " $1", 
       RegexOptions.Compiled).Trim(); 
      return output; 
     } 
    } 
} 

Ho poi esteso HtmlHelper avere un metodo LabelFor2 che costruisce e passa fuori il formato di visualizzazione appropriato di un nome di proprietà.

using System; 
using System.Linq.Expressions; 
using System.Web.Mvc; 

namespace FuryPartners.WebClient.Helpers 
{ 
    public static class LabelHelpers 
    { 
     public static MvcHtmlString LabelFor2<T, TResult>(this HtmlHelper<T> helper, Expression<Func<T, TResult>> expression) 
     { 
      string propertyName = HelperUtilities.PropertyName(expression); 
      string labelValue = HelperUtilities.SplitCamelCase(propertyName); 

      string label = String.Format("<label for=\"{0}\">{1}</label>", propertyName, labelValue); 
      return MvcHtmlString.Create(label); 
     } 
    } 
} 

Answer 2

Non credo che ciò che si vuole è possibile in vaniglia ASP.NET MVC 2.

In ASP.NET MVC 2 che serve per decorare il vostro modello con un attributo DisplayName con il testo che si desidera e poi il la procedura guidata generata automaticamente utilizzerà LabelFor per generare l'etichetta per la proprietà. Ad esempio:

class MyModel() 
{ 
    [DisplayName("Your Property Name")] 
    public string YourPropertyName { get; set; } 
} 

Poi nella vista:

<%= Html.LabelFor(m => m.YourPropertyName) %> 

Se avete visto una demo di esso che è fatto qualche altro modo avrebbe potuto essere dal progetto MvcContrib per InputBuilders.

Ecco link al parte del progetto Credo che il tuo riferimento a:

http://www.lostechies.com/blogs/hex/archive/2009/06/09/opinionated-input-builders-for-asp-net-mvc-part-2-html-layout-for-the-label.aspx

Il testo evidenziato in rosso sono le etichette che vengono dal tipo di modello. L'etichetta viene creata dall'oggetto PropertyInfo che rappresenta le rispettive proprietà della modalità.

L'etichetta è Nome proprietà.

L'etichetta è il nome proprietà diviso nel nome della proprietà del caso pascal.

L'etichetta viene specificata utilizzando l'attributo Etichetta applicato alla proprietà.

Answer 3

ho una nuova versione più semplice per creare un'etichetta titolo-izzato dal Andrews risposta, utilizzando il codice MVC2 a rispettare qualsiasi [DisplayName (...)] Attribuisce

public static class LabelHelpers 
{ 
    public static MvcHtmlString LabelTitleizeFor<T, TResult>(this HtmlHelper<T> helper, Expression<Func<T, TResult>> expression) 
    { 
     string propertyName = ExpressionHelper.GetExpressionText(expression); 

     if (propertyName.IndexOf(".") > 0) 
     { 
      propertyName = propertyName.Substring(propertyName.LastIndexOf(".") + 1); 
     } 

     string labelValue = ModelMetadata.FromLambdaExpression(expression, helper.ViewData).DisplayName; 

     if (string.IsNullOrEmpty(labelValue)) 
     { 
      labelValue = Inflector.Net.Inflector.Titleize(propertyName); 
     } 

     string label = String.Format("<label for=\"{0}\">{1}</label>", propertyName, labelValue); 
     return MvcHtmlString.Create(label); 
    } 
} 

utilizzando https://github.com/srkirkland/Inflector/blob/master/Inflector/Inflector.cs

Answer 4

Ampliando Jason More's answer, ecco uno con sovraccarichi di attributi HTML.

Il pacchetto NuGet con licenza MIT Inflector è richiesto: Install-Package Inflector.

utilizzo Esempio:

Html.LabelTitleizeFor(model => model.FirstName) 
Html.LabelTitleizeFor(model => model.FirstName, htmlAttributes: new { @class="control-label col-md-2" }) 

public static class HtmlHelperExtensions 
{ 
    public static MvcHtmlString LabelTitleizeFor<T, TResult>(this HtmlHelper<T> helper, Expression<Func<T, TResult>> expression) 
    { 
     return LabelTitleizeHelper(helper, expression, null); 
    } 

    public static MvcHtmlString LabelTitleizeFor<T, TResult>(this HtmlHelper<T> helper, Expression<Func<T, TResult>> expression, IDictionary<string, object> htmlAttributes) 
    { 
     return LabelTitleizeHelper(helper, expression, htmlAttributes); 
    } 

    public static MvcHtmlString LabelTitleizeFor<T, TResult>(this HtmlHelper<T> helper, Expression<Func<T, TResult>> expression, object htmlAttributes) 
    { 
     return LabelTitleizeHelper(helper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes)); 
    } 

    private static MvcHtmlString LabelTitleizeHelper<T, TResult>(HtmlHelper<T> html, Expression<Func<T, TResult>> expression, IDictionary<string, object> htmlAttributes = null) 
    { 
     string propertyName = ExpressionHelper 
      .GetExpressionText(expression) 
      .Split('.') 
      .Last(); 

     if (string.IsNullOrEmpty(propertyName)) 
      return MvcHtmlString.Empty; 

     ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData); 

     string labelValue = metadata.DisplayName ?? Inflector.Inflector.Titleize(propertyName); 

     TagBuilder tagBuilder = new TagBuilder("label"); 
     tagBuilder.Attributes.Add("for", TagBuilder.CreateSanitizedId(html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(propertyName))); 
     tagBuilder.SetInnerText(labelValue); 
     tagBuilder.MergeAttributes(htmlAttributes, true); 

     return new MvcHtmlString(tagBuilder.ToString(TagRenderMode.Normal)); 
    } 
} 

Questo codice è Unlicense licenza (libero di utilizzare e cambiare in qualsiasi contesto senza attribuzione).