Editor MVC3 para solo lectura

Este código es compatible con MVC4 en adelante

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

Para aquellos que se preguntan por qué quieres usar un EditoFor si no quieres que sea editable, tengo un ejemplo.

Tengo esto en mi Modelo.

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

Y cuando se desea mostrar ese formato, la única forma en que funciona es con un EditorFor, pero tengo un datepicker de jquery para esa "entrada", por lo que tiene que ser leído solo para evitar que los usuarios escriban fechas incorrectas.

Para que funcione de la manera que quiero pongo esto en la vista...

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

Y esto en mi lista función...

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

Espero que esto sea útil para alguien por ahí. Lo siento por mi inglés

Puedes hacerlo de esta manera:

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

Así es como lo hago:

Modelo:

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

Vista:

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

Extensión:

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

Por supuesto, mi editor está haciendo un montón de cosas más, como agregar una etiqueta, agregar una clase requerida a esa etiqueta según sea necesario, agregar un DisplayFor si la propiedad es ReadOnly EditorFor si no es así, agregar un ValidateMessageFor y finalmente envolver todo eso en un Div que puede tener Html Attributes asignado... mis Views están súper limpios.

Sé que la pregunta dice MVC 3, pero era 2012, así que por si acaso:

A partir de MVC 5.1 ahora puede pasar atributos HTML a EditorFor de la siguiente manera:

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

Intenta usar:

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

Crear una EditorTemplate para un conjunto específico de vistas (enlazadas por un Controlador):

En este ejemplo tengo una plantilla para una Fecha, pero puedes cambiarla a lo que quieras.

Aquí está el código en los Datos.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" }) 

Y en el modelo:

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

Viejo post que conozco.. pero ahora usted puede hacer esto para mantener la alineación y todos buscando consistente..

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

Creo que esto es más simple que otro mediante el uso de [Editable(false)] atributo

Por ejemplo:

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

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

Utilice jquery para desactivar

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