@ Html.DisplayFor - DateFormat (“mm / dd / aaaa”)

Eu tenho o seguinte código de navalha que desejo ter o mm/dd/yyyyformato de data:

Audit Date: @Html.DisplayFor(Model => Model.AuditDate)

Eu tentei várias abordagens diferentes, mas nenhuma delas funciona na minha situação

meu AuditDate é um DateTime?tipo

Eu tentei algo assim e recebi este erro:

@Html.DisplayFor(Model => Model.AuditDate.Value.ToShortDateString())

Informações adicionais: os modelos podem ser usados ​​apenas com acesso a campo, acesso de propriedade, índice de matriz de dimensão única ou expressões de indexador personalizadas de parâmetro único.

Tentei isso:

@Html.DisplayFor(Model => Model.AuditDate.ToString("mm/dd/yyyy"))

Sem sobrecarga para o método 'ToString' leva 1 argumento

Se você usar DisplayFor, terá que definir o formato por meio do DisplayFormatatributo ou usar um modelo de exibição personalizado. (Uma lista completa de predefinições DisplayFormatStringpode ser encontrada aqui .)

[DisplayFormat(DataFormatString = "{0:d}")]
public DateTime? AuditDate { get; set; }

Ou crie a visualização Views\Shared\DisplayTemplates\DateTime.cshtml:

@model DateTime?
@if (Model.HasValue)
{
    @Model.Value.ToString("MM/dd/yyyy")
}

Isso se aplicará a todos os programas DateTime, mesmo aqueles em que você está codificando o tempo também. Se você deseja que ele se aplique apenas a propriedades somente para datas, use Views\Shared\DisplayTemplates\Date.cshtmle o DataTypeatributo em sua propriedade:

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

A opção final é não usar DisplayFore, em vez disso, renderizar a propriedade diretamente:

@if (Model.AuditDate.HasValue)
{
    @Model.AuditDate.Value.ToString("MM/dd/yyyy")
}

Se você está simplesmente emitindo o valor dessa propriedade de modelo, não precisa do DisplayForhelper html, apenas chame-o diretamente com a formatação de string adequada .

Audit Date: @Model.AuditDate.Value.ToString("d")

Deve produzir

Audit Date: 1/21/2015

Por último, sua data de auditoria pode ser nula, portanto, você deve fazer a verificação condicional antes de tentar formatar um valor anulável.

@if (item.AuditDate!= null) { @Model.AuditDate.Value.ToString("d")}

Procurar no Google o erro que você está obtendo fornece esta resposta , que mostra que o erro é devido ao uso da palavra Model em seus helpers Html. Por exemplo, usando @Html.DisplayFor(Model=>Model.someProperty). Altere-os para usar algo diferente de Model, por exemplo: @Html.DisplayFor(x=>x.someProperty)ou altere a maiúscula Mpara minúsculas mnesses auxiliares.

Tenho usado esta mudança em meu código:

código antigo:

 <td>
  @Html.DisplayFor(modelItem => item.dataakt)
 </td>

Novo :

<td>
 @Convert.ToDateTime(item.dataakt).ToString("dd/MM/yyyy")
</td>

A resposta de @ChrisPratt sobre o uso do modelo de exibição está errada. O código correto para fazer funcionar é:

@model DateTime?

@if (Model.HasValue)
{
    @Convert.ToDateTime(Model).ToString("MM/dd/yyyy")
}

Isso porque o .ToString()for Nullable<DateTime>não aceita o Formatparâmetro .

Eu implementei algo semelhante desta forma:

1. Use TextBoxFor para exibir a data no formato necessário e tornar o campo somente leitura .

@Html.TextBoxFor(Model => Model.AuditDate, "{0:dd-MMM-yyyy}", new{@class="my-style", @readonly=true})

2. Dê contorno zero e borda zero para TextBox em css.

.my-style {
    outline: none;
    border: none;
}

E ...... Está feito :)

Para mim foi o suficiente para usar

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

Você pode usar o atributo [ DisplayFormat ] em seu modelo de visualização, pois deseja aplicar este formato a todo o projeto.

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

Depois de algumas pesquisas, acabei definindo Threado valor de CurrentCulture para ter CultureInfo ("en-US") no método de ação do controlador:

Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); 

Aqui estão algumas outras opções se você quiser ter essa configuração em todas as visualizações.

Sobre o CurrentCulturevalor da propriedade:

O objeto CultureInfo que é retornado por esta propriedade, junto com seus objetos associados, determina o formato padrão para datas, horas, números, valores monetários, a ordem de classificação de texto, convenções de maiúsculas e minúsculas e comparações de strings.

Fonte: MSDN CurrentCulture

Nota: A CurrentCultureconfiguração da propriedade anterior é provavelmente opcional se o controlador já estiver em execução com CultureInfo("en-US")ou semelhante onde está o formato de data "MM/dd/yyyy".

Depois de definir a CurrentCulturepropriedade, adicione o bloco de código para converter a data para o "M/d/yyyy"formato na visualização:

@{  //code block 
    var shortDateLocalFormat = "";
    if (Model.AuditDate.HasValue) {
       shortDateLocalFormat = ((DateTime)Model.AuditDate).ToString("M/d/yyyy");
       //alternative way below
       //shortDateLocalFormat = ((DateTime)Model.AuditDate).ToString("d");
    }
}

@shortDateLocalFormat

Acima a @shortDateLocalFormatvariável é formatada com ToString("M/d/yyyy")obras. Se ToString("MM/dd/yyyy")for usado, como eu fiz primeiro, você acaba tendo problema zero . Também funciona como recomendado por Tommy ToString("d") . Na verdade, "d"significa “Padrão de data abreviada” e pode ser usado com diferentes formatos de cultura / idioma também.

Eu acho que o bloco de código acima também pode ser substituído por algum método auxiliar legal ou similar.

Por exemplo

@helper DateFormatter(object date)
{
    var shortDateLocalFormat = "";
    if (date != null) {     
        shortDateLocalFormat = ((DateTime)date).ToString("M/d/yyyy");
     }

    @shortDateLocalFormat
}

pode ser usado com esta chamada de ajuda

@DateFormatter(Model.AuditDate)

Update , descobri que existe uma maneira alternativa de fazer a mesma coisa quando o método DateTime.ToString (String, IFormatProvider) é usado. Quando este método é usado, não há necessidade de usar Threada CurrentCulturepropriedade de. O CultureInfo("en-US")é passado como segundo argumento -> IFormatProvider para o DateTime.ToString(String, IFormatProvider)método.

Método auxiliar modificado:

@helper DateFormatter(object date)
{
    var shortDateLocalFormat = "";
    if (date != null) {
       shortDateLocalFormat = ((DateTime)date).ToString("d", new System.Globalization.CultureInfo("en-US"));
    }

    @shortDateLocalFormat
}

.NET Fiddle

Talvez tente simplesmente

@(Model.AuditDate.HasValue ? Model.AuditDate.ToString("mm/dd/yyyy") : String.Empty)

também você pode usar muitos tipos de formato de string como .ToString ("dd MMM, yyyy") .ToString ("d") etc.

Em vista, substitua isto:

@Html.DisplayFor(Model => Model.AuditDate.Value.ToShortDateString())

Com:

@if(@Model.AuditDate.Value != null){@Model.AuditDate.Value.ToString("dd/MM/yyyy")}
else {@Html.DisplayFor(Model => Model.AuditDate)}

Explicação: Se o valor AuditDate não for nulo, ele formatará a data para dd / MM / aaaa, caso contrário, deixe-a como está porque não tem valor.

Tive um problema semelhante no meu controlador e aqui está o que funcionou para mim:

model.DateSigned.HasValue ? model.DateSigned.Value.ToString("MM/dd/yyyy") : ""

"DateSigned" é o valor do meu modelo. A linha lê, se o valor do modelo tiver um valor, formate o valor, caso contrário, não mostre nada.

espero que ajude

Esta é a melhor maneira de obter uma string de data simples:

 @DateTime.Parse(Html.DisplayFor(Model => Model.AuditDate).ToString()).ToShortDateString()

Você pode usar o Convert

 <td>@Convert.ToString(string.Format("{0:dd/MM/yyyy}", o.frm_dt))</td> 

Veja esta resposta sobre o No overload for method 'ToString' takes 1 argumentserro.

Você não pode formatar um DateTime anulável - você deve usar a propriedade DateTime.Value.

@Model.AuditDate.HasValue ? Model.AuditDate.Value.ToString("mm/dd/yyyy") : string.Empty

Dica: É sempre útil resolver essas coisas em uma classe padrão com o intellisense antes de colocá-las em uma visualização. Nesse caso, você obteria um erro de compilação que seria fácil de detectar em uma classe.