Csla.Blazor.IPropertyInfo and [Required] attribute?

[michaelcsikos]

I'm experimenting with Ant Design Blazor. A nice feature of the FormItem component wrapper for edit controls is that it will look for a [Required] attribute on the property and automatically prefix the label with a coloured asterisk, but this doesn't work when we use the pass-through property with Csla.Blazor.IPropertyInfo. If we had something like bool HasAttribute<T>() in the interface we could hook up the Required property like we do with disabled="@(!Property.CanWrite)". Could this be possible?

[swegele]

I took a peek into the Csla.PropertyInfo and in the constructor there is _propertyInfo = containingType.GetProperty(Name);

That variable is stored here private readonly System.Reflection.PropertyInfo _propertyInfo; and then used a little more
in some subsequent reflection very similar to what you are suggesting:

public virtual string FriendlyName
{
  get
  {
    string result = Name;
    if (!string.IsNullOrWhiteSpace(_friendlyName))
    {
      result = _friendlyName;
    }
    else if (_propertyInfo != null)
    {
      var display = _propertyInfo.GetCustomAttributes(typeof(DisplayAttribute), true).OfType<DisplayAttribute>().FirstOrDefault();
      if (display != null)
      {
        // DataAnnotations attribute.
        result = display.GetName();
      }
      else
      {
        // ComponentModel attribute.
        var displayName = _propertyInfo.GetCustomAttributes(typeof(DisplayNameAttribute), true).OfType<DisplayNameAttribute>().FirstOrDefault();
        if (displayName != null)
          result = displayName.DisplayName;
      }
    }
    return result;
  }
}

I'm thinking you could do the same in your own code and see how it works...you'd have to use reflection and inspect the property (via Name) that the PropertyInfo is pointing to for that attribute.

[michaelcsikos]

Hi @swegele, thanks for the suggestion. The following works:

public static bool HasRequiredAttribute(object model, string propertyName)
{
    return model.GetType().GetProperty(propertyName).GetCustomAttributes(typeof(RequiredAttribute), true).Any();
}

However, this can't be called directly from Csla.Blazor.IPropertyInfo as the Model property is not exposed. I was hoping this could be automatically handled by something like the TextInput class in the Blazor example. @rockfordlhotka can you think of any workaround, or would I need to reflect the Model first and then call the above?

[michaelcsikos]

Hi @rockfordlhotka, if Csla.Blazor.IPropertyInfo exposed a Type ModelType { get; } the following would be a lot easier:

using System.ComponentModel.DataAnnotations;
using Csla.Blazor;
using BindingFlags = System.Reflection.BindingFlags;

namespace AttributeHelperExample
{
    public static class AttributeHelper
    {
        public static bool HasRequiredAttribute(IPropertyInfo iPropertyInfo)
        {
            var propertyInfo = iPropertyInfo as PropertyInfo;

            if (propertyInfo == null)
                return false;

            var type          = typeof(PropertyInfo);

            var modelProperty = type.GetProperty("Model", BindingFlags.NonPublic | BindingFlags.Instance);

            if (modelProperty == null)
                return false;

            var model = modelProperty.GetValue(propertyInfo);

            if (model == null)
                return false;

            return HasRequiredAttribute(model, iPropertyInfo.PropertyName);
        }

        public static bool HasRequiredAttribute(object model, string propertyName)
        {
            if (model == null)
                return false;

            var type = model.GetType();

            return HasRequiredAttribute(type, propertyName);
        }

        public static bool HasRequiredAttribute(Type type, string propertyName)
        {
            return type.GetProperty(propertyName).GetCustomAttributes(typeof(RequiredAttribute), true).Any();
        }
    }
}

[rockfordlhotka]

I don't understand the request?

You can use the Required attribute (or any of the data annotations attributes) on a CSLA property and it will be enforced by CSLA as a rule (CSLA finds those attributes and adds them as rules so they are executed even if there's no UI at all, or an older UI that doesn't honor those attributes).

That doesn't stop the attribute from being used by the UIs that do honor the attributes - MVC, Razor Pages, and apparently now Blazor.

[michaelcsikos]

The UI will find the [Required] attribute if it's bound directly to the model, but with the CSLA TextInput.razor component which displays errors, warnings and info, the @bind-value is bound to the TextValue pass-through property, which doesn't have the [Required] attribute (or any others). So we have to manually specify the bool Required on the Label.

Using reflection we can find it via the model's Type and the Csla.Blazor.IPropertyInfo.PropertyName. It would be more efficient if we didn't have to cast to PropertyInfo and then look for protected object Model { get; } in order to get the model's `Type'.

It would be helpful if Csla.Blazor.IPropertyInfo had a Type ModelType { get; }.

public Type ModelType { get => Model.GetType(); }

[rockfordlhotka]

Perhaps there should be a GetPropertyInfo method that directly returns the System.Reflection.PropertyInfo for the property? That's ultimately what you want right?

[michaelcsikos]

Ultimately, yes.

[rockfordlhotka]

Done in #2921

[michaelcsikos]

Hi @rockfordlhotka, it looks like System.Reflection.PropertyInfo GetPropertyInfo() was added to Csla.Core.IPropertyInfo but not Csla.Blazor.IPropertyInfo.