Add contravariance to RenderFragment<TValue>

src/Components/Components/src/RenderFragment.cs

@@ -18,4 +18,4 @@ namespace Microsoft.AspNetCore.Components;
 /// </summary>
 /// <typeparam name="TValue">The type of object.</typeparam>
 /// <param name="value">The value used to build the content.</param>
-public delegate RenderFragment RenderFragment<TValue>(TValue value);
+public delegate RenderFragment RenderFragment<in TValue>(TValue value);

src/Components/Components/test/RendererTest.cs

@@ -5158,6 +5158,159 @@ public class HasSubstituteComponentRenderMode : RenderModeAttribute
         }
     }
 
+    [Fact]
+    public void RenderFragmentContravariance_WorksWithBaseClassParameter()
+    {
+        // Arrange
+        var renderer = new TestRenderer();
+        var baseFragment = (RenderFragment<Animal>)((Animal animal) => builder =>
+        {
+            builder.AddContent(0, $"Animal: {animal.Name}");
+        });
+
+        var component = new TestComponent(builder =>
+        {
+            builder.OpenComponent<ComponentWithRenderFragmentOfDog>(0);
+            builder.AddComponentParameter(1, nameof(ComponentWithRenderFragmentOfDog.Template), baseFragment);
+            builder.CloseComponent();
+        });
+
+        // Act
+        var componentId = renderer.AssignRootComponentId(component);
+        component.TriggerRender();
+
+        // Assert - Should compile and render without exception
+        var batch = renderer.Batches.Single();
+        var componentFrame = batch.ReferenceFrames
+            .Single(frame => frame.FrameType == RenderTreeFrameType.Component);
+        Assert.IsType<ComponentWithRenderFragmentOfDog>(componentFrame.Component);
+        var dogComponent = (ComponentWithRenderFragmentOfDog)componentFrame.Component;
+        Assert.NotNull(dogComponent.Template);
+    }
+
+    [Fact]
+    public void RenderFragmentContravariance_WorksWithInterfaceParameter()
+    {
+        // Arrange
+        var renderer = new TestRenderer();
+        var baseFragment = (RenderFragment<IList<string>>)((IList<string> items) => builder =>
+        {
+            builder.AddContent(0, $"Count: {items.Count}");
+        });
+
+        var component = new TestComponent(builder =>
+        {
+            builder.OpenComponent<ComponentWithRenderFragmentOfListOfString>(0);
+            builder.AddComponentParameter(1, nameof(ComponentWithRenderFragmentOfListOfString.Template), baseFragment);
+            builder.CloseComponent();
+        });
+
+        // Act
+        var componentId = renderer.AssignRootComponentId(component);
+        component.TriggerRender();
+
+        // Assert - Should compile and render without exception
+        var batch = renderer.Batches.Single();
+        var componentFrame = batch.ReferenceFrames
+            .Single(frame => frame.FrameType == RenderTreeFrameType.Component);
+        Assert.IsType<ComponentWithRenderFragmentOfListOfString>(componentFrame.Component);
+        var listComponent = (ComponentWithRenderFragmentOfListOfString)componentFrame.Component;
+        Assert.NotNull(listComponent.Template);
+    }
+
+    [Fact]
+    public void RenderFragmentContravariance_WorksWithStructWrapperParameter()
+    {
+        // Arrange
+        var renderer = new TestRenderer();
+        // Using reference type wrapper around struct to demonstrate contravariance
+        var baseFragment = (RenderFragment<StructWrapperBase>)((StructWrapperBase wrapper) => builder =>
+        {
+            builder.AddContent(0, $"Value: {wrapper.GetValue()}");
+        });
+
+        var component = new TestComponent(builder =>
+        {
+            builder.OpenComponent<ComponentWithRenderFragmentOfStructWrapperDerived>(0);
+            builder.AddComponentParameter(1, nameof(ComponentWithRenderFragmentOfStructWrapperDerived.Template), baseFragment);
+            builder.CloseComponent();
+        });
+
+        // Act
+        var componentId = renderer.AssignRootComponentId(component);
+        component.TriggerRender();
+
+        // Assert - Should compile and render without exception
+        var batch = renderer.Batches.Single();
+        var componentFrame = batch.ReferenceFrames
+            .Single(frame => frame.FrameType == RenderTreeFrameType.Component);
+        Assert.IsType<ComponentWithRenderFragmentOfStructWrapperDerived>(componentFrame.Component);
+        var wrapperComponent = (ComponentWithRenderFragmentOfStructWrapperDerived)componentFrame.Component;
+        Assert.NotNull(wrapperComponent.Template);
+    }
+
+    [Fact]
+    public void RenderFragmentContravariance_WorksWithStringParameter()
+    {
+        // Arrange
+        var renderer = new TestRenderer();
+        // Testing contravariance from object to string (both reference types)
+        var baseFragment = (RenderFragment<object>)((object value) => builder =>
+        {
+            builder.AddContent(0, $"Value: {value}");
+        });
+
+        var component = new TestComponent(builder =>
+        {
+            builder.OpenComponent<ComponentWithRenderFragmentOfString>(0);
+            builder.AddComponentParameter(1, nameof(ComponentWithRenderFragmentOfString.Template), baseFragment);
+            builder.CloseComponent();
+        });
+
+        // Act
+        var componentId = renderer.AssignRootComponentId(component);
+        component.TriggerRender();
+
+        // Assert - Should compile and render without exception
+        var batch = renderer.Batches.Single();
+        var componentFrame = batch.ReferenceFrames
+            .Single(frame => frame.FrameType == RenderTreeFrameType.Component);
+        Assert.IsType<ComponentWithRenderFragmentOfString>(componentFrame.Component);
+        var stringComponent = (ComponentWithRenderFragmentOfString)componentFrame.Component;
+        Assert.NotNull(stringComponent.Template);
+    }
+
+    [Fact]
+    public void RenderFragmentContravariance_WorksWithEnumWrapperParameter()
+    {
+        // Arrange
+        var renderer = new TestRenderer();
+        // Using reference type wrapper around enum to demonstrate contravariance
+        var baseFragment = (RenderFragment<EnumWrapperBase>)((EnumWrapperBase wrapper) => builder =>
+        {
+            builder.AddContent(0, $"Enum: {wrapper.GetValue()}");
+        });
+
+        var component = new TestComponent(builder =>
+        {
+            builder.OpenComponent<ComponentWithRenderFragmentOfEnumWrapperDerived>(0);
+            builder.AddComponentParameter(1, nameof(ComponentWithRenderFragmentOfEnumWrapperDerived.Template), baseFragment);
+            builder.CloseComponent();
+        });
+
+        // Act
+        var componentId = renderer.AssignRootComponentId(component);
+        component.TriggerRender();
+
+        // Assert - Should compile and render without exception
+        var batch = renderer.Batches.Single();
+        var componentFrame = batch.ReferenceFrames
+            .Single(frame => frame.FrameType == RenderTreeFrameType.Component);
+        Assert.IsType<ComponentWithRenderFragmentOfEnumWrapperDerived>(componentFrame.Component);
+        var enumWrapperComponent = (ComponentWithRenderFragmentOfEnumWrapperDerived)componentFrame.Component;
+        Assert.NotNull(enumWrapperComponent.Template);
+    }
+
     [HasUnknownRenderMode]
     private class ComponentWithUnknownRenderMode : IComponent
     {
@@ -6162,4 +6315,126 @@ public ImplicitlyConvertsToString(string value)
 
         public static implicit operator string(ImplicitlyConvertsToString value) => value._value;
     }
+
+    // Test classes for RenderFragment contravariance
+    private class Animal
+    {
+        public string Name { get; set; } = string.Empty;
+    }
+
+    private class Dog : Animal
+    {
+        public string Breed { get; set; } = string.Empty;
+    }
+
+    private class ComponentWithRenderFragmentOfDog : AutoRenderComponent
+    {
+        [Parameter]
+        public RenderFragment<Dog> Template { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            if (Template != null)
+            {
+                var dog = new Dog { Name = "Buddy", Breed = "Golden Retriever" };
+                builder.AddContent(0, Template(dog));
+            }
+        }
+    }
+
+    private class ComponentWithRenderFragmentOfListOfString : AutoRenderComponent
+    {
+        [Parameter]
+        public RenderFragment<List<string>> Template { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            if (Template != null)
+            {
+                var list = new List<string> { "Item1", "Item2", "Item3" };
+                builder.AddContent(0, Template(list));
+            }
+        }
+    }
+
+    // Reference type hierarchy containing struct property for testing contravariance
+    private struct TestStruct
+    {
+        public int Value { get; set; }
+        public string Name { get; set; }
+    }
+
+    private class StructWrapperBase
+    {
+        public virtual string GetValue() => "base";
+    }
+
+    private class StructWrapperDerived : StructWrapperBase
+    {
+        public TestStruct Struct { get; set; }
+        public override string GetValue() => $"Struct: {Struct.Value}, {Struct.Name}";
+    }
+
+    private class ComponentWithRenderFragmentOfStructWrapperDerived : AutoRenderComponent
+    {
+        [Parameter]
+        public RenderFragment<StructWrapperDerived> Template { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            if (Template != null)
+            {
+                var wrapper = new StructWrapperDerived { Struct = new TestStruct { Value = 42, Name = "Test" } };
+                builder.AddContent(0, Template(wrapper));
+            }
+        }
+    }
+
+    private class ComponentWithRenderFragmentOfString : AutoRenderComponent
+    {
+        [Parameter]
+        public RenderFragment<string> Template { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            if (Template != null)
+            {
+                builder.AddContent(0, Template("test string"));
+            }
+        }
+    }
+
+    // Reference type hierarchy containing enum property for testing contravariance
+    private enum TestEnum
+    {
+        Value1,
+        Value2,
+        Value3
+    }
+
+    private class EnumWrapperBase
+    {
+        public virtual string GetValue() => "base";
+    }
+
+    private class EnumWrapperDerived : EnumWrapperBase
+    {
+        public TestEnum Enum { get; set; }
+        public override string GetValue() => $"Enum: {Enum}";
+    }
+
+    private class ComponentWithRenderFragmentOfEnumWrapperDerived : AutoRenderComponent
+    {
+        [Parameter]
+        public RenderFragment<EnumWrapperDerived> Template { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            if (Template != null)
+            {
+                var wrapper = new EnumWrapperDerived { Enum = TestEnum.Value2 };
+                builder.AddContent(0, Template(wrapper));
+            }
+        }
+    }
 }