web-dev-qa-db-fra.com

ASP.NET MVC 3 Custom HTML Helpers - Meilleures pratiques/utilisations

Nouveau sur MVC et parcourez les didacticiels du site Web asp.net. 

Ils incluent un exemple d’assistant HTML personnalisé pour tronquer le texte long affiché dans un tableau. 

Je me demandais simplement quelles autres solutions les gens avaient imaginées avec l'aide de HTML et s'il existait des meilleures pratiques ou des choses à éviter lors de leur création/utilisation. 

Par exemple, je pensais écrire un assistant personnalisé pour formater les dates que je devrais afficher à différents endroits, mais je crains maintenant une solution plus élégante (I.E. DataAnnotations dans mes modèles).

Des pensées?

MODIFIER:

Une autre utilisation potentielle que je viens de penser à ... Concaténation de chaînes . Un assistant personnalisé pourrait prendre un ID utilisateur en tant qu'entrée et renvoyer un nom complet de l'utilisateur .... ) (Milieu) (Dernier) selon lequel de ces champs sont disponibles. Juste une pensée, je n'ai encore rien essayé de tel. 

asp.net-mvcasp.net-mvc-2asp.net-mvc-3html-helper
32
stephen776

Eh bien, dans le cas du formatage de DisplayFormat attribut pourrait être une solution intéressante:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}")]
public DateTime Date { get; set; }

et ensuite simplement:

@Html.DisplayFor(x => x.Date)

En ce qui concerne la chaîne tronquée, un assistant HTML personnalisé est une bonne solution.

METTRE À JOUR:

En ce qui concerne votre modification, un assistant HTML personnalisé peut fonctionner dans cette situation, mais il existe également une approche alternative qui me plait beaucoup: afficher les modèles. Ainsi, si dans cette vue particulière, vous allez toujours afficher la concaténation des noms, vous pouvez définir un modèle de vue:

public class PersonViewModel
{
    public string FullName { get; set; }
}

Le contrôleur va maintenant interroger le référentiel pour extraire le modèle, puis mapper ce modèle sur un modèle de vue qui sera transmis à la vue de sorte que la vue puisse simplement @Html.DisplayFor(x => x.FullName). La correspondance entre les modèles et les modèles de vue pourrait être simplifiée avec des cadres tels que AutoMapper .

16
Darin Dimitrov

J'utilise HtmlHelpers tout le temps, le plus souvent pour encapsuler la génération de code HTML standard, au cas où je changerais d'avis. J'ai eu des aides telles que:

  • Html.BodyId (): génère une balise ID de corps conventionnelle pour le référencement lors de l'ajout de CSS personnalisés pour une vue.
  • Html.SubmitButton (string): génère un élément input [type = submit] ou button [type = submit], en fonction de la manière dont je souhaite styliser les boutons.
  • Html.Pager (IPagedList): Pour générer des contrôles de pagination à partir d'un modèle de liste paginée.
  • etc.... 

Une de mes utilisations préférées de HtmlHelpers est de DRY améliorer le balisage de formulaire courant. En général, j'ai un conteneur div pour une ligne de formulaire, un div pour l'étiquette et un libellé pour l'entrée, les messages de validation, le texte d'indication, etc. En fin de compte, il pourrait s'agir d'un grand nombre de balises HTML standard. Voici un exemple de la façon dont j'ai géré ceci:

public static MvcHtmlString FormLineDropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> helper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string labelText = null, string customHelpText = null, object htmlAttributes = null)
{
    return FormLine(
        helper.LabelFor(expression, labelText).ToString() +
        helper.HelpTextFor(expression, customHelpText),
        helper.DropDownListFor(expression, selectList, htmlAttributes).ToString() +
        helper.ValidationMessageFor(expression));
}

public static MvcHtmlString FormLineEditorFor<TModel, TProperty>(this HtmlHelper<TModel> helper, Expression<Func<TModel, TProperty>> expression, string templateName = null, string labelText = null, string customHelpText = null, object htmlAttributes = null)
{
    return FormLine(
        helper.LabelFor(expression, labelText).ToString() +
        helper.HelpTextFor(expression, customHelpText),
        helper.EditorFor(expression, templateName, htmlAttributes).ToString() +
        helper.ValidationMessageFor(expression));
}

private static MvcHtmlString FormLine(string labelContent, string fieldContent, object htmlAttributes = null)
{
    var editorLabel = new TagBuilder("div");
    editorLabel.AddCssClass("editor-label");
    editorLabel.InnerHtml += labelContent;

    var editorField = new TagBuilder("div");
    editorField.AddCssClass("editor-field");
    editorField.InnerHtml += fieldContent;

    var container = new TagBuilder("div");
    if (htmlAttributes != null)
        container.MergeAttributes(new RouteValueDictionary(htmlAttributes));
    container.AddCssClass("form-line");
    container.InnerHtml += editorLabel;
    container.InnerHtml += editorField;

    return MvcHtmlString.Create(container.ToString());
}

public static MvcHtmlString HelpTextFor<TModel, TProperty>(this HtmlHelper<TModel> helper, Expression<Func<TModel, TProperty>> expression, string customText = null)
{
    // Can do all sorts of things here -- eg: reflect over attributes and add hints, etc...
}

Une fois que vous avez fait cela, cependant, vous pouvez générer des lignes de formulaire comme ceci:

<%: Html.FormLineEditorFor(model => model.Property1) %>
<%: Html.FormLineEditorFor(model => model.Property2) %>
<%: Html.FormLineEditorFor(model => model.Property3) %>

... et BAM, toutes vos étiquettes, entrées, astuces et messages de validation sont sur votre page. Là encore, vous pouvez utiliser des attributs sur vos modèles et y réfléchir pour devenir vraiment intelligent et SEC. Et bien sûr, ce serait une perte de temps si vous ne pouvez pas normaliser la conception de vos formulaires. Cependant, pour des cas simples, où CSS peut fournir toute la personnalisation dont vous avez besoin, cela fonctionne grrrrrrrrrr! 

Morale de l'histoire - HtmlHelpers peut vous isoler des modifications de conception globales, détruisant ainsi les balises créées à la main. Je les aime. Mais vous pouvez aller trop loin, et des vues partielles sont parfois meilleures que des aides codées. Une règle générale que j'utilise pour décider entre aide et vue partielle: Si le bloc HTML nécessite beaucoup de logique conditionnelle ou de ruse de codage, j'utilise une aide (placez le code là où le code devrait être); sinon, si je ne sors que du balisage commun sans trop de logique, j'utilise une vue partielle (mettre le balisage là où le balisage devrait être).  

J'espère que cela vous donne quelques idées!

100
spot
public static HtmlString OwnControlName<T, U>(this HtmlHelper<T> helper, Expression<Func<T, U>> expression, string label_Name = "", string label_Title = "", Attr attr = null)
        {
            TemplateBuilder tb = null;
            string template = null;
          if (expression == null) throw new ArgumentException("expression");
 obj = helper.ViewData.Model;
                tb.Build(obj, expression.Body as MemberExpression, typeof(T), new SimpleTemplate(new TextArea()), label_Name, label_Title, attr);
                template = tb.Get();
 return new MvcHtmlString(template);
}
0
satya prakash