¿Es posible crear un método @helper genérico con Razor?

Estoy tratando de escribir un ayudante en Razor que se parezca a lo siguiente:

@helper DoSomething<T, U>(Expression<Func<T, U>> expr) where T : class

Desafortunadamente, el analizador cree que <Tes el comienzo de un elemento HTML y termino con un error de sintaxis. ¿Es posible crear un ayudante con Razor que sea un método genérico? Si es así, ¿cuál es la sintaxis?

No, esto no es posible actualmente. En su lugar, podría escribir un ayudante HTML normal.

public static MvcHtmlString DoSomething<T, U>(
    this HtmlHelper htmlHelper, 
    Expression<Func<T, U>> expr
) where T : class
{
    ...
}

y entonces:

@(Html.DoSomething<SomeModel, string>(x => x.SomeProperty))

o si está apuntando al modelo como primer argumento genérico:

public static MvcHtmlString DoSomething<TModel, TProperty>(
    this HtmlHelper<TModel> htmlHelper, 
    Expression<Func<TModel, TProperty>> expr
) where TModel : class
{
    ...
}

lo que le permitirá invocarlo así (asumiendo, por supuesto, que su vista está fuertemente tipada, pero esa es una suposición segura porque todas las vistas deben estar fuertemente tipadas de todos modos :-)):

@Html.DoSomething(x => x.SomeProperty)

Esto se puede lograr dentro de un archivo de ayuda con la @functionssintaxis, pero si desea la legibilidad de estilo navaja a la que se refiere, también deberá llamar a un ayudante habitual para que ajuste y termine el HTML.

Tenga en cuenta que las funciones en un archivo Helper son estáticas, por lo que aún deberá pasar la instancia de HtmlHelper desde la página si tiene la intención de usar sus métodos.

por ejemplo, Views \ MyView.cshtml:

@MyHelper.DoSomething(Html, m=>m.Property1)
@MyHelper.DoSomething(Html, m=>m.Property2)
@MyHelper.DoSomething(Html, m=>m.Property3)

App_Code \ MyHelper.cshtml:

@using System.Web.Mvc;
@using System.Web.Mvc.Html;
@using System.Linq.Expressions;
@functions
{
    public static HelperResult DoSomething<TModel, TItem>(HtmlHelper<TModel> html, Expression<Func<TModel, TItem>> expr)
    {
        return TheThingToDo(html.LabelFor(expr), html.EditorFor(expr), html.ValidationMessageFor(expr));
    }
}
@helper TheThingToDo(MvcHtmlString label, MvcHtmlString textbox, MvcHtmlString validationMessage)
{
    <p>
        @label
        <br />
        @textbox
        @validationMessage
    </p>
}
...

En todos los casos, el TModelserá el mismo (el modelo declarado para la vista), y en mi caso, el TValueiba a ser el mismo, por lo que pude declarar el tipo de argumento Expresión:

@helper FormRow(Expression<Func<MyViewModel, MyClass>> expression) {
  <div class="form-group">
    @(Html.LabelFor(expression, new { @class = "control-label col-sm-6 text-right" }))
    <div class="col-sm-6">
      @Html.EnumDropDownListFor(expression, new { @class = "form-control" })
    </div>
    @Html.ValidationMessageFor(expression)
  </div>
}

Si los campos de su modelo son todos string, puede reemplazarlos MyClasscon string.

Puede que no sea malo definir dos o tres ayudantes con el TValuedefinido, pero si tiene más que generarían un código desagradable, realmente no encontré una buena solución. Intenté envolver el @helperdesde una función que puse dentro del @functions {}bloque, pero nunca logré que funcionara en ese camino.

si su principal problema es obtener el valor del atributo de nombre para el enlace mediante la expresión lambda @Html.TextBoxFor(x => x.MyPoperty), y si su componente tiene etiquetas html muy complejas y debe implementarse en el asistente de afeitar, ¿por qué no crear un método de extensión HtmlHelper<TModel>para resolver el nombre de enlace:

namespace System.Web.Mvc
{
    public static class MyHelpers
    {
        public static string GetNameForBinding<TModel, TProperty>
           (this HtmlHelper<TModel> model, 
            Expression<Func<TModel, TProperty>> property)
        {
            return ExpressionHelper.GetExpressionText(property);
        }
    }
}

su ayudante de afeitado debe ser como de costumbre:

@helper MyComponent(string name)
{
    <input name="@name" type="text"/>
}

entonces aquí puedes usarlo

@TheHelper.MyComponent(Html.GetNameForBinding(x => x.MyProperty))