ModelMetadata: La propriété ShowForEdit ne semble pas fonctionner

Question

Iv a écrit un MetaDataProvider comme celui ci-dessous et je l'utilise conjointement avec les modèles d'éditeur. Le DisplayName fonctionne correctement, mais pour une raison quelconque, la valeur ShowForEdit n'a aucun effet. Des idées?

public class MyModelMetadataProvider : DataAnnotationsModelMetadataProvider 
{ 
     protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, 
                 Func<object> modelAccessor, Type modelType, string propertyName) 
     { 
      var metadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);   I 

      metadata.DisplayName = "test"; 

      metadata.ShowForEdit = false; 
      metadata.ShowForDisplay = false; 
      metadata.HideSurroundingHtml = true; 

      return metadata; 
     } 
} 

Answer 1

Cela semble similaire à la question Why can't I set ShowForEdit model metadata with an attribute?, donc je vais répliquer ma réponse ici:

Quel est le type de propriété que vous postulez à? Si nous utilisons réflecteur, nous pouvons découvrir que les propriétés de ShowForEdit et ShowForDisplay sont utilisés dans les fonctions suivantes:

ShowForEdit: System.Web.Mvc.Html.DefaultEditorTemplates.ShouldShow (...)

ShowForDisplay: Système .Web.Mvc.Html.DefaultDisplayTemplates.ShouldShow (...)

la définition de ces méthodes est:

private static bool ShouldShow(ModelMetadata metadata, TemplateInfo templateInfo) 
{ 
    return (((metadata.ShowForEdit && (metadata.ModelType != typeof(EntityState))) && !metadata.IsComplexType) && !templateInfo.Visited(metadata)); 
} 

private static bool ShouldShow(ModelMetadata metadata, TemplateInfo templateInfo) 
{ 
    return (((metadata.ShowForDisplay && (metadata.ModelType != typeof(EntityState))) && !metadata.IsComplexType) && !templateInfo.Visited(metadata)); 
} 

Ignorer la vérification de la propriété évidente (metadata.ShowForX), vous pouvez voir qu'il est vérifier si le modèle est un nIntstance de EntityState (ne l'est probablement pas), puis une vérification de metadata.IsComplexType.

Nous pouvons regarder la propriété isComplexType ici:

public virtual bool IsComplexType 
{ 
    get 
    { 
    return !TypeDescriptor.GetConverter(this.ModelType).CanConvertFrom(typeof(string)); 
    } 
} 

Qu'est-ce qui dit est qu'il retourne vrai si le modèle ne peut pas être converti à partir d'une chaîne, et dans les méthodes ShouldShow(), il montre si ce n'est pas un type complexe, c'est-à-dire que la valeur CAN peut être convertie à partir d'une chaîne.

Ce que vous devez faire, est de créer un TypeConverter qui peut convertir une chaîne, au modèle, par exemple:

Un modèle:

[TypeConverter(typeof(ItemConverter))] 
public class Item 
{ 
    #region Properties 
    public string Text { get; set; } 
    #endregion 
} 

Et un convertisseur:

public class ItemConverter : TypeConverter 
{ 
    #region Methods 
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) 
    { 
    if (sourceType == typeof(string)) 
     return true; 

    return base.CanConvertFrom(context, sourceType); 
    } 

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) 
    { 
    if (value.GetType() == typeof(string)) 
    { 
     return new Item { Text = (string)value }; 
    } 

    return base.ConvertFrom(context, culture, value); 
    } 
    #endregion 
} 

Avec cela en place, essayez à nouveau et voir si cela aide.