MVC3 EditorFor readOnly

Ce code est pris en charge dans MVC4 et suivants

@Html.EditorFor(model => model.userName, new { htmlAttributes = new { @class = "form-control", disabled = "disabled", @readonly = "readonly" } })

Pour ceux qui se demandent pourquoi vous voulez utiliser un EditoFor si vous ne voulez pas qu'il soit modifiable, j'ai un exemple.

J'ai ceci dans mon modèle.

    [DataType(DataType.Date)]
    [DisplayFormat(ApplyFormatInEditMode = true, DataFormatString = "{0: dd/MM/yyyy}")]
    public DateTime issueDate { get; set; }

Et quand vous voulez afficher ce format, la seule façon dont cela fonctionne est avec un EditorFor, mais j'ai un datepicker jquery pour cette "entrée" donc il doit être en lecture seule pour éviter que les utilisateurs écrivent de mauvaises dates.

Pour le faire fonctionner comme je le veux, je mets ceci dans la vue...

     @Html.EditorFor(m => m.issueDate, new{ @class="inp", @style="width:200px", @MaxLength = "200"})

Et ceci dans mon prêt fonction...

     $('#issueDate').prop('readOnly', true);

J'espère que cela serait utile pour quelqu'un là-bas. Désolé pour mon anglais

, Vous pouvez le faire de cette façon:

@Html.EditorFor(m => m.userName, new { htmlAttributes = new { disabled = true } })

Voici comment je le fais:

Modèle:

[ReadOnly(true)]
public string Email { get { return DbUser.Email; } }

Vue:

@Html.TheEditorFor(x => x.Email)

Extension:

namespace System.Web.Mvc
{
    public static class CustomExtensions
    {
        public static MvcHtmlString TheEditorFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes = null)
        {
            return iEREditorForInternal(htmlHelper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        private static MvcHtmlString iEREditorForInternal<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
        {
            if (htmlAttributes == null) htmlAttributes = new Dictionary<string, object>();

            TagBuilder builder = new TagBuilder("div");
            builder.MergeAttributes(htmlAttributes);

            var metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);


            string labelHtml = labelHtml = Html.LabelExtensions.LabelFor(htmlHelper, expression).ToHtmlString();

            if (metadata.IsRequired)
                labelHtml = Html.LabelExtensions.LabelFor(htmlHelper, expression, new { @class = "required" }).ToHtmlString();


            string editorHtml = Html.EditorExtensions.EditorFor(htmlHelper, expression).ToHtmlString();

            if (metadata.IsReadOnly)
                editorHtml = Html.DisplayExtensions.DisplayFor(htmlHelper, expression).ToHtmlString();


            string validationHtml = Html.ValidationExtensions.ValidationMessageFor(htmlHelper, expression).ToHtmlString();

            builder.InnerHtml = labelHtml + editorHtml + validationHtml;

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

Bien sûr, mon éditeur fait beaucoup plus de choses, comme ajouter une étiquette, Ajouter une classe requise à cette étiquette si nécessaire, ajouter un DisplayFor si la propriété est ReadOnly EditorFor si ce n'est pas le cas, ajoutez un ValidateMessageFor et finalement enveloppez tout cela dans un Div qui peut avoir Html Attributes affecté... mes Views sont super propres.

Je sais que la question indique MVC 3, mais c'était 2012, donc juste au cas où:

À partir de MVC 5.1, vous pouvez maintenant passer des attributs HTML à EditorFor comme ceci:

@Html.EditorFor(x => x.Name, new { htmlAttributes = new { @readonly = "", disabled = "" } })

Essayez d'utiliser:

@Html.DisplayFor(model => model.userName) <br/>
@Html.HiddenFor(model => model.userName)

Créez un EditorTemplate pour un ensemble spécifique de vues (lié par un contrôleur):

Dans cet exemple, j'ai un modèle pour une Date, mais vous pouvez le changer à ce que vous voulez.

Voici le code dans les Données.cshtml:

@model Nullable<DateTime>

@Html.TextBox("", @Model != null ? String.Format("{0:d}",     ((System.DateTime)Model).ToShortDateString()) : "", new { @class = "datefield", type =    "date", disabled = "disabled"  @readonly = "readonly" }) 

Et dans le modèle:

[DataType(DataType.Date)]
public DateTime? BlahDate { get; set; }

Ancien poste que je connais.. mais maintenant, vous pouvez le faire pour garder l'alignement et tout regarder cohérent..

 @Html.EditorFor(model => model.myField, new { htmlAttributes = new { @class = "form-control", @readonly = "readonly" } })

Je pense que c'est simple que les autres en utilisant l'attribut [Editable(false)]

Par exemple:

 public class MyModel
    {
        [Editable(false)]
        public string userName { get; set; }
    }

<div class="editor-field">
        @Html.EditorFor(model => model.userName)
</div>

Utilisez jquery pour désactiver

<script type="text/javascript">
   $(document).ready(function () {
      $('#userName').attr('disabled', true);
     });
</script>