C# data annotation, can't extend a specific attribute - what are the possibilities?

Question

I'm working on a legacy application build with ASP.NET Dynamic Data. The models, as per usual, are all read-only and one can set the display name or description through attributes.

This worked well, however, now I'm in a situation where I need to query two different sources (resource file and some other source) for display name.

The code before was clean, because we only queried the resources:

[Display(ResourceType = typeof(Resources.m_Res), Name = "M_RES_MIMETYPE_ID", Description = "M_RES_MIMETYPE_ID_DESCR")]

This was totally fine and it worked as intended. However, now I have to get the display name and description firstly from some other file and if everything else fails, I have to fallback to resources.

I had to create two different custom attributes, something in this manner:

    public class MGADisplayName : DisplayNameAttribute
    {
          private readonly string propertyName;
          public string Name { get; set; }
          public Type TableName { get; set; }
          public Type ResourceType { get; set; }

          public MGADisplayName([CallerMemberName] string PropertyName = null)
          {
              propertyName = PropertyName;
          }

          public override string DisplayName
          {
              get
              {
                  var key = (TableName.Name + ":" + (propertyName ?? Name)).ToLower();
                  if (/* SOME QUERYING */)
                  {
                      return QUERY[key];
                  }
                  else
                  {
                      string property = Resources.m_Res.ResourceManager.GetString(Name);
                      if (property != null)
                      {
                          return property;
                      }
                      else
                      {
                          return Name;
                      }

                  }
              }
          }
    }

This kind of works and I guess it's OK for the time being, but the next issue is around the corner: I'll need to do with Display.GroupName the same.

Now, as far as I know, there is no GroupNameAttribute to extend, so I'm kind of in the dark here.

I wish I could extend the DisplayAttribute, it would be EXACTLY what I need, but the class is sealed, so that's a dead end.

I wish I could change the model on the fly and provide DisplayName and Description through setters, but the model has only getters, so that's another dead end.

I'm running slowly out of options here. What else can be done here?

Answer 1

Although DisplayAttribute class is sealed, it can be customized via ResourceType property:

Gets or sets the type that contains the resources for the ShortName, Name, Prompt, and Description properties.

Two things to mention. First, it also handles GroupName. Second is mentioned in the Remarks section:

If this value is not null, the string properties are assumed to be the names of public static properties that return the actual string value.

Shortly, the provided type can be any public class / struct having public static string property for each string key.

This perfectly fits with PublicResXFileCodeGenerator generated typed resource classes. But the important is that it can be arbitrary type, and you can utilize that fact.

For instance:

public static class SR
{
    // Assuming you have file SR.resx under same namespace
    static readonly ResourceManager ResourceManager = new ResourceManager(typeof(SR));

    static string GetString([CallerMemberName]string propertyName = null)
    {
        // Custom logic goes here
        return ResourceManager.GetString(propertyName) ?? propertyName;
    }

    // Properties
    public static string M_RES_MIMETYPE_ID => GetString();
    public static string M_RES_MIMETYPE_ID_DESCR => GetString();
    public static string M_RES_MIMETYPE_ID_GROUP => GetString();
    // ...
}

Usage:

[Display(
    ResourceType = typeof(SR), 
    Name = nameof(SR.M_RES_MIMETYPE_ID),
    Description = nameof(SR.M_RES_MIMETYPE_ID_DESCR),
    GroupName = nameof(SR.M_RES_MIMETYPE_ID_GROUP)
)]

Test:

var displayInfo = new DisplayAttribute
{
    ResourceType = typeof(SR),
    Name = nameof(SR.M_RES_MIMETYPE_ID),
    Description = nameof(SR.M_RES_MIMETYPE_ID_DESCR),
    GroupName = nameof(SR.M_RES_MIMETYPE_ID_GROUP)
};
// These are used by ASP.NET for retrieving actual values
var name = displayInfo.GetName();
var description = displayInfo.GetDescription();
var groupName = displayInfo.GetGroupName();

So, this is the solution.

Now, the only problem with it is the need to manually add string property for each resource key. It could be solved by rolling out your own single file generator or T4 template generator, but how to do that I believe is out of the scope of this post.

Answer 2

As you mentioned as well DisplayAttribute is sealed. And for custom scenarios we need to add our own custom attribute. But to simplify implementation for custom attribute we can use wrapper pattern to reuse original code as well as adding our own custom code. Like this:

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = false)]
    public class CustomDisplayAttribute : Attribute
    {
        private DisplayAttribute _innerAttribute;

        public CustomDisplayAttribute()
        {
            _innerAttribute = new DisplayAttribute();
        }

        public string ShortName
        {
            get
            {
                return _innerAttribute.ShortName;
            }
            set
            {
                _innerAttribute.ShortName = value;
            }
        }
...

The custom added attribute would not be picked as it does not implement DisplayAttribute. To have it be picked on reading metadata, we need to add a custom meta data provider. It should inherits from DataAnnotationsModelMetadataProvider. You can customize the provider code as you wish.

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

            CustomDisplayAttribute customDisplay = attributes.OfType<CustomDisplayAttribute>().FirstOrDefault();
            if (customDisplay != null)
            {
                result.Description = customDisplay.GetDescription();
                result.ShortDisplayName = customDisplay.GetShortName();
                result.Watermark = customDisplay.GetPrompt();
                result.Order = customDisplay.GetOrder() ?? ModelMetadata.DefaultOrder;

                result.DisplayName = customDisplay.GetName();
            }

            return result;
        }
    }

And at the end to make sure CustomDataAnnotationsModelMetadataProvider is used, we should set the current meta data provider to be it. We can add this code on Global.asax.cs or Startup.cs to set the current value.

ModelMetadataProviders.Current = new CustomDataAnnotationsModelMetadataProvider();

Find the complete sample code here. I tested it on an MVC web app in same directory. Feel free to clone the repo and try it out.

BTW as mentioned on the other answer this solution was discussed long time ago on here, I just tried to make it prettier and added full sample code