@ Html.DisplayNameFor per i dettagli del modello

Question

Nel mio modello ho un'entità

public class Carrier 
{ 
public Guid CarrierId { get; set; } 
public string Name { get; set; } 
} 

Ho anche un ViewModel

public class CarrierIndexViewModel 
{ 
public IEnumerable<Carrier> Carriers { get; set; } 
public PagingInfo PagingInfo { get; set; } 
} 

Ho un fortemente tipizzato (CarrierIndexViewModel) Index View, che è supponiamo di mostrare una tabella di Carrier usando PagingInfo.

Sto cercando di utilizzare helper HTML per visualizzare Carrier.Name nel colpo di testa di mio tavolo Quando ho usato IEnumerable come modello per questo punto di vista ho avuto @Html.DisplayFor(model => model.Name)

Come posso ottenere lo stesso risultato utilizzando il mio nuovo CarrierIndexViewModel visualizzare il titolo per Carrier.Name?

Answer 1

È possibile aggiungere un'istruzione @using alla vista per specificare il tipo di operatore, quindi sarà necessario eseguire il ciclo attraverso la proprietà Carriers del modello.

tuo Vista avrà un aspetto simile ..

@model CarrierIndexViewModel 
@using Carrier 

@foreach(Carrier c in Model.Carriers) 
{ 
@Html.DisplayFor(model => c.Name) 
} 

Answer 2

Ho un problema simile, perché io non voglio scrivere i miei nomi delle colonne a mano così ho scritto un aiutante:

public static IHtmlString DisplayColumnNameFor<TModel, TClass, TProperty> 
    (this HtmlHelper<TModel> helper, IEnumerable<TClass> model, 
    Expression<Func<TClass, TProperty>> expression) 
{ 
    var name = ExpressionHelper.GetExpressionText(expression); 
    name = helper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name); 
    var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(
     () => Activator.CreateInstance<TClass>(), typeof(TClass), name); 

    return new MvcHtmlString(metadata.DisplayName); 
} 

Poi nella vista ti chiami

@Html.DisplayColumnNameFor(Model.Carriers, m => m.Name) 

si prega di notare che è possibile utilizzare l'attributo display che accetta N ame e molte altre personalizzazioni come risorsa file ecc

public class Carrier 
{ 
    [Display(Name="Carrier ID")] 
    public Guid CarrierId { get; set; } 
    [Display(Name="Carrier Name")] 
    public string Name { get; set; } 
} 

Answer 3

ho avuto un requisito analogo, ma avevo bisogno di ottenere i nomi di visualizzazione per oggetti di una classe non enumerabile diversa quindi la soluzione da @plurby non avrebbe funzionato . Ho finito per risolvere questo creando una chiamata fluente che può essere utilizzata per ottenere un nuovo HtmlHelper per qualsiasi tipo arbitrario. Il codice per l'estensione e l'adattatore è:

public static class HtmlHelpers 
{ 
    public static HtmlHelperAdapter<TModel> Adapt<TModel>(this HtmlHelper<TModel> helper) 
    { 
     return new HtmlHelperAdapter<TModel>(helper); 
    } 

    public class HtmlHelperAdapter<TModel> 
    { 
     private readonly HtmlHelper<TModel> _helper; 

     public HtmlHelperAdapter(HtmlHelper<TModel> helper) 
     { 
      _helper = helper; 
     } 

     public HtmlHelper<TNewModel> For<TNewModel>() 
     { 
      return new HtmlHelper<TNewModel>(_helper.ViewContext, new ViewPage(), _helper.RouteCollection); 
     } 
    } 
} 

È quindi possibile utilizzare questo nella vista in questo modo:

<td>@(Html.Adapt().For<MyOtherModel>().DisplayNameFor(m => m.SomeProperty))</td> 

Uno dei vantaggi è che questo approccio funziona per qualsiasi estensione HtmlHelper, non solo DisplayNameFor (ma tieni presente che l'HtmlHelper adattato non ha dati di visualizzazione poiché è tutto scritto in base al modello utilizzato nella vista e quindi non funzionerà con HtmlHelper adattato).

Answer 4

Ho trovato che non era necessario alcun metodo di supporto, codice aggiuntivo o ciclo della raccolta. Ho appena usato il seguente:

@Html.DisplayNameFor(model => model.Carriers.FirstOrDefault().Name) 

questo funziona ancora, anche se FirstOrDefault() sarebbero tornati null perché è solo alla ricerca di metadati, la proprietà Name in sé non è accessibile.

Mille grazie a @Kurian che ha ispirato questa risposta.

Answer 5

Qui è un approccio, che si basa sul metodo di estensione originaleDisplayNameFor e funziona coerente.

un metodo di estensione per HtmlHelper:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Linq.Expressions; 
using System.Web; 
using System.Web.Mvc; 

public static class HtmlHelperExtensions 
{ 
    public static MvcHtmlString DisplayNameFor<TModel, TEnumerable, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, IEnumerable<TEnumerable>>> enumerableExpression, Expression<Func<TEnumerable, TValue>> valueExpression) 
    { 
     var metadata = ModelMetadata.FromLambdaExpression(valueExpression, new ViewDataDictionary<TEnumerable>()); 
     string displayName = metadata.DisplayName ?? metadata.PropertyName ?? ExpressionHelper.GetExpressionText(valueExpression).Split('.').Last(); 
     return new MvcHtmlString(HttpUtility.HtmlEncode(displayName)); 
    } 
} 

Ed è così che potrebbe essere utilizzato in una vista:

@Html.DisplayNameFor(m => m.Carriers, c => c.Name)