So legen Sie die Sichtbarkeit von Steuerelementen dynamisch in MVC fest, abhängig von den Datenbankeinträgen

Question

Ich suche nach der Einstellung meiner Steuerelemente, die abhängig von der Sichtbarkeit der Datenbankspalte auf "True" oder "False" angezeigt werden. Ich möchte die Sichtbarkeit der Steuerelemente dynamisch festlegen. Ich denke daran, CustomAttributes zu verwenden und das ViewModel damit zu setzen. Aber ich weiß nicht wie. Ein Ausgangspunkt von jemandem und hilf mir anzufangen.

[Visible] 
public string FullName { get; set; } 

Answer 1

Meins ist etwas einfacher als ali Antwort:

in Ihrem Modell Klasse:

public class Client 
{ 
    [Visible] 
    public string FullName { get; set; } 
} 

eine Erweiterungsmethode hinzufügen VisibleLabelFor

public static class HtmlExtensions 
{ 
    public static MvcHtmlString VisibleLabelFor<TModel, TResult>(this HtmlHelper<TModel> html, Expression<Func<TModel, TResult>> expression) 
    { 
     var type = expression.Body.NodeType; 

     if (type == ExpressionType.MemberAccess) 
     { 
      var memberExpression = (MemberExpression) expression.Body; 
      var p = memberExpression.Member as PropertyInfo; 

      if (!Attribute.IsDefined(p, typeof (VisibleAttribute))) 
       return new MvcHtmlString(string.Empty); 

      return html.LabelFor(expression); 
     } 
    } 
} 

Dann aus Ihrer Sicht:

Answer 2

Sie können einen einfachen @helper mit Razor wie folgt schreiben:

In App_Code\MyHelpers.cshtml:

@helper DisplayIt(object value, bool visibility) 
{ 
    if (!visibility){return;} 

    <span>@value</span> 
} 

es dann so aus Ihrer Sicht verwenden:

@MyHelpers.DisplayIt(@Model.FullName, @Model.Visible) 
@MyHelpers.DisplayIt(@Model.Email, @Model.Visible) 
@MyHelpers.DisplayIt(@Model.Tel, @Model.Visible) 

Answer 3

Sie müssen Führen Sie die folgenden Schritte aus:

Schritt 1: custom

public class VisibilityAttribute : ValidationAttribute 
{ 
    private bool _isVisible; 

    public VisibilityAttribute(bool visible = true) 
    { 
     _isVisible = visible; 
    } 

    public bool Status 
    { 
     get 
     { 
      return _isVisible; 
     } 
     set 
     { 
      _isVisible = value; 
     } 
    } 
} 

Schritt 2 Attribut erstellen: Fügen Sie benutzerdefinierte Attribut

[Visibility(Status = false)] 
public string FullName { get; set; } 

Schritt 3 zu modellieren: Erstellen Sie benutzerdefinierte HTML-Hilfs

public static class CustomHtmlExtensions 
{ 
    public static MvcHtmlString CustomDisplayFor<TModel, TResult>(this HtmlHelper<TModel> html, 
     Expression<Func<TModel, TResult>> expression) 
    { 
     ExpressionType type = expression.Body.NodeType; 
     if (type == ExpressionType.MemberAccess) 
     { 
      MemberExpression memberExpression = (MemberExpression)expression.Body; 
      PropertyInfo pi = memberExpression.Member as PropertyInfo; 

      var attributes = pi.GetCustomAttributes(); 

      foreach (var attribute in attributes) 
      { 

       if (attribute is VisibilityAttribute) 
       { 
        VisibilityAttribute vi = attribute as VisibilityAttribute; 
        if (vi.Status) 
        { 
         var metadata = ModelMetadata.FromLambdaExpression<TModel, TResult>(expression, html.ViewData); 
         return MvcHtmlString.Create(metadata.SimpleDisplayText); 
        } 
       } 
      } 
     } 
     return MvcHtmlString.Create(""); 
    } 
} 

Schritt 4: Verwenden Sie benutzerdefinierte HTML-Helper in Ansicht

@Html.CustomDisplayFor(model => model.FullName)