Blazor supports DisplayName for models

src/Components/Web/src/Forms/DisplayName.cs

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using System.Linq.Expressions;
+using Microsoft.AspNetCore.Components.Rendering;
+
+namespace Microsoft.AspNetCore.Components.Forms;
+
+/// <summary>
+/// Displays the display name for a specified field, reading from <see cref="DisplayAttribute"/>
+/// or <see cref="DisplayNameAttribute"/> if present, or falling back to the property name.
+/// </summary>
+/// <typeparam name="TValue">The type of the field.</typeparam>
+public class DisplayName<TValue> : IComponent
+{
+
+    private RenderHandle _renderHandle;
+    private Expression<Func<TValue>>? _previousFieldAccessor;
+    private string? _displayName;
+
+    /// <summary>
+    /// Specifies the field for which the display name should be shown.
+    /// </summary>
+    [Parameter, EditorRequired]
+    public Expression<Func<TValue>>? For { get; set; }
+    /// <inheritdoc />
+    void IComponent.Attach(RenderHandle renderHandle)
+    {
+        _renderHandle = renderHandle;
+    }
+
+    /// <inheritdoc />
+    Task IComponent.SetParametersAsync(ParameterView parameters)
+    {
+        parameters.SetParameterProperties(this);
+
+        if (For is null)
+        {
+            throw new InvalidOperationException($"{GetType()} requires a value for the " +
+                $"{nameof(For)} parameter.");
+        }
+
+        // Only recalculate if the expression changed
+        if (For != _previousFieldAccessor)
+        {
+            var newDisplayName = ExpressionMemberAccessor.GetDisplayName(For);
+
+            if (newDisplayName != _displayName)
+            {
+                _displayName = newDisplayName;
+                _renderHandle.Render(BuildRenderTree);
+            }
+
+            _previousFieldAccessor = For;
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private void BuildRenderTree(RenderTreeBuilder builder)
+    {
+        builder.AddContent(0, _displayName);
+    }
+}

src/Components/Web/src/Forms/ExpressionMemberAccessor.cs

@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.AspNetCore.Components.HotReload;
+
+namespace Microsoft.AspNetCore.Components.Forms;
+
+internal static class ExpressionMemberAccessor
+{
+    private static readonly ConcurrentDictionary<Expression, MemberInfo> _memberInfoCache = new();
+    private static readonly ConcurrentDictionary<MemberInfo, string> _displayNameCache = new();
+
+    static ExpressionMemberAccessor()
+    {
+        if (HotReloadManager.Default.MetadataUpdateSupported)
+        {
+            HotReloadManager.Default.OnDeltaApplied += ClearCache;
+        }
+    }
+
+    private static MemberInfo GetMemberInfo<TValue>(Expression<Func<TValue>> accessor)
+    {
+        ArgumentNullException.ThrowIfNull(accessor);
+
+        return _memberInfoCache.GetOrAdd(accessor, static expr =>
+        {
+            var lambdaExpression = (LambdaExpression)expr;
+            var accessorBody = lambdaExpression.Body;
+
+            if (accessorBody is UnaryExpression unaryExpression
+                && unaryExpression.NodeType == ExpressionType.Convert
+                && unaryExpression.Type == typeof(object))
+            {
+                accessorBody = unaryExpression.Operand;
+            }
+
+            if (accessorBody is not MemberExpression memberExpression)
+            {
+                throw new ArgumentException(
+                    $"The provided expression contains a {accessorBody.GetType().Name} which is not supported. " +
+                    $"Only simple member accessors (fields, properties) of an object are supported.");
+            }
+
+            return memberExpression.Member;
+        });
+    }
+
+    public static string GetDisplayName(MemberInfo member)
+    {
+        ArgumentNullException.ThrowIfNull(member);
+
+        return _displayNameCache.GetOrAdd(member, static m =>
+        {
+            var displayAttribute = m.GetCustomAttribute<DisplayAttribute>();
+            if (displayAttribute is not null)
+            {
+                var name = displayAttribute.GetName();
+                if (name is not null)
+                {
+                    return name;
+                }
+            }
+
+            var displayNameAttribute = m.GetCustomAttribute<DisplayNameAttribute>();
+            if (displayNameAttribute?.DisplayName is not null)
+            {
+                return displayNameAttribute.DisplayName;
+            }
+
+            return m.Name;
+        });
+    }
+
+    public static string GetDisplayName<TValue>(Expression<Func<TValue>> accessor)
+    {
+        ArgumentNullException.ThrowIfNull(accessor);
+        var member = GetMemberInfo(accessor);
+        return GetDisplayName(member);
+    }
+
+    private static void ClearCache()
+    {
+        _memberInfoCache.Clear();
+        _displayNameCache.Clear();
+    }
+}

src/Components/Web/src/PublicAPI.Unshipped.txt

@@ -40,3 +40,7 @@ Microsoft.AspNetCore.Components.Web.Media.MediaSource.MediaSource(byte[]! data,
 Microsoft.AspNetCore.Components.Web.Media.MediaSource.MediaSource(System.IO.Stream! stream, string! mimeType, string! cacheKey) -> void
 Microsoft.AspNetCore.Components.Web.Media.MediaSource.MimeType.get -> string!
 Microsoft.AspNetCore.Components.Web.Media.MediaSource.Stream.get -> System.IO.Stream!
+Microsoft.AspNetCore.Components.Forms.DisplayName<TValue>
+Microsoft.AspNetCore.Components.Forms.DisplayName<TValue>.DisplayName() -> void
+Microsoft.AspNetCore.Components.Forms.DisplayName<TValue>.For.get -> System.Linq.Expressions.Expression<System.Func<TValue>!>?
+Microsoft.AspNetCore.Components.Forms.DisplayName<TValue>.For.set -> void

src/Components/Web/test/Forms/DisplayNameTest.cs

@@ -0,0 +1,232 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.AspNetCore.Components.Test.Helpers;
+
+namespace Microsoft.AspNetCore.Components.Forms;
+
+public class DisplayNameTest
+{
+    [Fact]
+    public async Task ThrowsIfNoForParameterProvided()
+    {
+        // Arrange
+        var rootComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<string>>(0);
+                builder.CloseComponent();
+            }
+        };
+
+        var testRenderer = new TestRenderer();
+        var componentId = testRenderer.AssignRootComponentId(rootComponent);
+
+        // Act & Assert
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            async () => await testRenderer.RenderRootComponentAsync(componentId));
+        Assert.Contains("For", ex.Message);
+        Assert.Contains("parameter", ex.Message);
+    }
+
+    [Fact]
+    public async Task DisplaysPropertyNameWhenNoAttributePresent()
+    {
+        // Arrange
+        var model = new TestModel();
+        var rootComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<string>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<string>>)(() => model.PlainProperty));
+                builder.CloseComponent();
+            }
+        };
+
+        // Act
+        var output = await RenderAndGetOutput(rootComponent);
+
+        // Assert
+        Assert.Equal("PlainProperty", output);
+    }
+
+    [Fact]
+    public async Task DisplaysDisplayAttributeName()
+    {
+        // Arrange
+        var model = new TestModel();
+        var rootComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<string>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<string>>)(() => model.PropertyWithDisplayAttribute));
+                builder.CloseComponent();
+            }
+        };
+
+        // Act
+        var output = await RenderAndGetOutput(rootComponent);
+
+        // Assert
+        Assert.Equal("Custom Display Name", output);
+    }
+
+    [Fact]
+    public async Task DisplaysDisplayNameAttributeName()
+    {
+        // Arrange
+        var model = new TestModel();
+        var rootComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<string>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<string>>)(() => model.PropertyWithDisplayNameAttribute));
+                builder.CloseComponent();
+            }
+        };
+
+        // Act
+        var output = await RenderAndGetOutput(rootComponent);
+
+        // Assert
+        Assert.Equal("Custom DisplayName", output);
+    }
+
+    [Fact]
+    public async Task DisplayAttributeTakesPrecedenceOverDisplayNameAttribute()
+    {
+        // Arrange
+        var model = new TestModel();
+        var rootComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<string>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<string>>)(() => model.PropertyWithBothAttributes));
+                builder.CloseComponent();
+            }
+        };
+
+        // Act
+        var output = await RenderAndGetOutput(rootComponent);
+
+        // Assert
+        // DisplayAttribute should take precedence per MVC conventions
+        Assert.Equal("Display Takes Precedence", output);
+    }
+
+    [Fact]
+    public async Task WorksWithDifferentPropertyTypes()
+    {
+        // Arrange
+        var model = new TestModel();
+        var intComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<int>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<int>>)(() => model.IntProperty));
+                builder.CloseComponent();
+            }
+        };
+        var dateComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<DateTime>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<DateTime>>)(() => model.DateProperty));
+                builder.CloseComponent();
+            }
+        };
+
+        // Act
+        var intOutput = await RenderAndGetOutput(intComponent);
+        var dateOutput = await RenderAndGetOutput(dateComponent);
+
+        // Assert
+        Assert.Equal("Integer Value", intOutput);
+        Assert.Equal("Date Value", dateOutput);
+    }
+
+    [Fact]
+    public async Task SupportsLocalizationWithResourceType()
+    {
+        var model = new TestModel();
+        var rootComponent = new TestHostComponent
+        {
+            InnerContent = builder =>
+            {
+                builder.OpenComponent<DisplayName<string>>(0);
+                builder.AddComponentParameter(1, "For", (System.Linq.Expressions.Expression<Func<string>>)(() => model.PropertyWithResourceBasedDisplay));
+                builder.CloseComponent();
+            }
+        };
+
+        var output = await RenderAndGetOutput(rootComponent);
+        Assert.Equal("Localized Display Name", output);
+    }
+
+    private static async Task<string> RenderAndGetOutput(TestHostComponent rootComponent)
+    {
+        var testRenderer = new TestRenderer();
+        var componentId = testRenderer.AssignRootComponentId(rootComponent);
+        await testRenderer.RenderRootComponentAsync(componentId);
+
+        var batch = testRenderer.Batches.Single();
+        var displayLabelComponentFrame = batch.ReferenceFrames
+            .First(f => f.FrameType == RenderTree.RenderTreeFrameType.Component &&
+                       f.Component is DisplayName<string> or DisplayName<int> or DisplayName<DateTime>);
+
+        // Find the text content frame within the component
+        var textFrame = batch.ReferenceFrames
+            .First(f => f.FrameType == RenderTree.RenderTreeFrameType.Text);
+
+        return textFrame.TextContent;
+    }
+
+    private class TestHostComponent : ComponentBase
+    {
+        public RenderFragment InnerContent { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            InnerContent(builder);
+        }
+    }
+
+    private class TestModel
+    {
+        public string PlainProperty { get; set; } = string.Empty;
+
+        [Display(Name = "Custom Display Name")]
+        public string PropertyWithDisplayAttribute { get; set; } = string.Empty;
+
+        [DisplayName("Custom DisplayName")]
+        public string PropertyWithDisplayNameAttribute { get; set; } = string.Empty;
+
+        [Display(Name = "Display Takes Precedence")]
+        [DisplayName("This Should Not Be Used")]
+        public string PropertyWithBothAttributes { get; set; } = string.Empty;
+
+        [Display(Name = "Integer Value")]
+        public int IntProperty { get; set; }
+
+        [Display(Name = "Date Value")]
+        public DateTime DateProperty { get; set; }
+
+        [Display(Name = nameof(TestResources.LocalizedDisplayName), ResourceType = typeof(TestResources))]
+        public string PropertyWithResourceBasedDisplay { get; set; } = string.Empty;
+    }
+
+    public static class TestResources
+    {
+        public static string LocalizedDisplayName => "Localized Display Name";
+    }
+}