Asp.net mvc 2 在ASP.NET MVC中，如何将属性名称显示为CamelCase上的标签拆分

我知道我以前见过这个。我不记得是C4MVC模板演示还是输入生成器！我需要知道如何使用视图模型属性的CamelCasedProperty约定，并将标签中的“CamelCasedProperty”呈现为“CamelCasedProperty”。这应该由“创建新视图”向导来处理，而不是通过编程来处理。

我认为在普通的ASP.NET MVC 2中不可能实现您想要的功能

在ASP.NET MVC 2中，您需要使用所需文本的DisplayName属性装饰模型，然后自动生成的向导将使用

LabelFor

输出属性的标签。例如：

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

然后在视图中：

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

m.YourPropertyName）%%>

如果您看到它的一个演示是以其他方式完成的，那么它可能来自于年的MvcContrib项目

以下是我认为您所指的项目部分的直接链接：

以红色高亮显示的文字是来自模型类型的标签。标签是从表示模式各自属性的PropertyInfo对象创建的

标签是属性名

标签是在pascal case属性名称上拆分的属性名称。

使用应用于特性的标签属性指定标签

---

经过一番探索之后，我找到了一条通向我感兴趣的事情的线索。看这个。我相信这可能已经在MVC Contrib中作为输入生成器完成了。然而，我非常有兴趣了解所有的下钉，可以说，学习所有我可以为。下面是我提出的解决方案，它只需要在生成的代码表单“createnewview”中将Html.LabelFor重命名为Html.LabelFor2：

我创建了一个方法，从传入的lambda中获取属性名。然后，我创建了另一个方法来解析名称中包含的大写字母的属性名称

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;
        }
    }
}

使用系统；
使用System.Linq.Expressions；
使用System.Text.RegularExpressions；
命名空间FuryPartners.WebClient.Helpers
{
公共类帮助功能
{
内部静态字符串PropertyName（表达式）
{
开关（expression.Body.NodeType）
{
case ExpressionType.MemberAccess：
var memberExpression=expression.Body作为memberExpression；
返回memberExpression.Member.Name；
违约：
返回“oops”；
}
}
内部静态字符串SplitCamelCase（字符串camelCaseString）
{
字符串输出=System.Text.RegularExpressions.Regex.Replace(
骆驼串，
“（[A-Z]）”，
" $1",
RegexOptions.Compiled.Trim（）；
返回输出；
}
}
}

然后，我扩展了HtmlHelper，使其具有一个LabelFor2方法，该方法构建并传递属性名称的适当显示格式

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);
        }
    }
}

使用系统；
使用System.Linq.Expressions；
使用System.Web.Mvc；
命名空间FuryPartners.WebClient.Helpers
{
公共静态类LabelHelper
{
公共静态MvcHtmlString LabelFor2（此HtmlHelper，表达式）
{
字符串propertyName=HelperUtilities.propertyName（表达式）；
string labelValue=HelperUtilities.SplitCamelCase（propertyName）；
string label=string.Format（“{1}”，propertyName，labelValue）；
返回MvcHtmlString.Create（标签）；
}
}
}

我有一个更简单的新版本，可以从Andrews answer创建一个标题化标签，使用MVC2代码尊重任何[DisplayName（…）]属性

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);
    }
}

公共静态类LabelHelpers
{
公共静态MvcHtmlString LabelTitleizeFor（此HtmlHelper，表达式）
{
字符串propertyName=ExpressionHelper.GetExpressionText（表达式）；
如果（propertyName.IndexOf（“.”）大于0）
{
propertyName=propertyName.Substring（propertyName.LastIndexOf（“.”+1）；
}
字符串labelValue=ModelMetadata.FromLambdaExpression（表达式，helper.ViewData）.DisplayName；
if（string.IsNullOrEmpty（labelValue））
{
labelValue=definctor.Net.definctor.Titleize（propertyName）；
}
string label=string.Format（“{1}”，propertyName，labelValue）；
返回MvcHtmlString.Create（标签）；
}
}

使用

展开，这里有一个HTML属性重载

需要MIT许可的

inductor

NuGet软件包：

安装软件包inductor

示例用法：

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

公共静态类HtmlHelperExtensions
{
公共静态MvcHtmlString LabelTitleizeFor（此HtmlHelper，表达式）
{
返回LabelTitleizeHelper（helper，表达式，null）；
}
公共静态MvcHtmlString LabelTitleizeFor（此HtmlHelper、表达式、IDictionary htmlAttributes）
{
返回LabelTitleizeHelper（helper、表达式、htmlAttributes）；
}
公共静态MvcHtmlString标签ELTITLEIZEFOR（此HtmlHelper、表达式、对象htmlAttributes）
{
返回LabelTitleizeHelper（helper，表达式，HtmlHelper.AnonymousObjectToHtmlAttributes（htmlAttributes））；
}
私有静态MvcHtmlString LabelTitleizeHelper（HtmlHelper html，表达式表达式，IDictionary htmlAttributes=null）
{
字符串propertyName=ExpressionHelper
.GetExpressionText（表达式）
.Split（“.”）
.Last（）；
if（string.IsNullOrEmpty（propertyName））
返回MvcHtmlString.Empty；
ModelMetadata=ModelMetadata.FromLambdaExpression（表达式，html.ViewData）；
字符串labelValue=metadata.DisplayName？？I
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));
    }
}