FluentValidation.NET equivalent to [Display(Name)]

Question

Before FluentValidation.NET I could give a custom label to a properly like so:

[Display(Name="Blah")]
public string BlahBlahBlah { get; set; }

And I could consume this in several ways:

@Html.LabelFor(m => m.BlahBlahBlah)
@Html.DisplayNameFor(m => m.BlahBlahBlah)

<label asp-for="BlahBlahBlah"></label>

Now I want to remove all data annotations from my models, and move to fluent validation. In my validator, I have this:

RuleFor(o => o.BlahBlahBlah)
    .NotEmpty()
    .WithName("Blah");

But this does not work. Why?

Answer 1

WithName method in FluentValidation is used ONLY to tune validation error message if you want to replace C# property name to smth more user friendly (see Overriding the Default Property Name for details).

So the answer is - you cannot replace Display with WithName() in general, only for validation error message.

Answer 2

In case it helps, I threw together a little attribute and helper to make this more dynamic.

WithDisplayNameAttribute.cs

[AttributeUsage(AttributeTargets.Property)]
public class WithDisplayNameAttribute : Attribute
{
    public WithDisplayNameAttribute(string displayName)
    {
        DisplayName = displayName;
    }

    /// <summary>
    /// The preferred friendly name to display for this property during validation.
    /// </summary>
    public string DisplayName { get; set; }
}

WithDisplayNameHelper.cs

internal static class WithDisplayNameHelper
{
    public static IReadOnlyDictionary<string, string> Map { get; }

    static WithDisplayNameHelper()
    {
        var core = typeof(WithDisplayNameHelper).Assembly;
        var map = new Dictionary<string, string>();
        foreach (var parentModelType in core.GetExportedTypes().Where(x => x.IsClass))
        {
            foreach (var prop in parentModelType.GetProperties())
            {
                var att = prop.GetCustomAttribute<WithDisplayNameAttribute>();
                if (att == null) continue;
                var key = GetKey(parentModelType, prop);
                if (!map.ContainsKey(key))
                {
                    map.Add(key, att.DisplayName);
                }
            }
        }

        Map = new ReadOnlyDictionary<string, string>(map);
    }

    /// <summary>
    /// Gets the key to use for this property.
    /// </summary>
    /// <param name="parent">The parent class containing the property.</param>
    /// <param name="prop">The property described by the display name.</param>
    /// <returns></returns>
    private static string GetKey(Type parent, PropertyInfo prop) => GetKey(parent, prop.Name);
    
    /// <inheritdoc cref="GetKey(System.Type,System.Reflection.PropertyInfo)"/>
    private static string GetKey(Type parent, string prop) => $"{parent.FullName}.{prop}";

    /// <summary>
    /// Retrieves the display name if one was set using the <see cref="WithDisplayNameAttribute"/>. Otherwise will return the given <paramref name="propertyName"/>.
    /// </summary>
    /// <param name="parent">The parent class containing the property.</param>
    /// <param name="propertyName">The property name.</param>
    /// <returns></returns>
    public static string GetDisplayNameOrDefault(Type parent, string propertyName) =>
        Map.TryGetValue(GetKey(parent, propertyName), out var value)
        ? value
        : propertyName;

    /// <summary>
    /// Attempts to retrieve the display name if one was set using the <see cref="WithDisplayNameAttribute"/>.
    /// </summary>
    /// <inheritdoc cref="GetDisplayNameOrDefault"/>
    /// <returns></returns>
    public static bool TryGetDisplayName(Type parent, string propertyName, out string result) =>
        Map.TryGetValue(GetKey(parent, propertyName), out result);


}

And the extension method:

    /// <summary>
    /// Specifies a custom property name to use within the error message.
    /// </summary>
    /// <param name="rule">The current rule</param>
    /// <returns></returns>
    public static IRuleBuilderOptions<T, TProperty> WithDisplayName<T, TProperty>(
        this IRuleBuilderOptions<T, TProperty> rule)
    {
        
        return rule.Configure(x =>
        {
            if (WithDisplayNameHelper.TryGetDisplayName(typeof(T), x.PropertyName, out var displayName))
                x.DisplayName = new StaticStringSource(displayName);
        });
    }