[Blazor] Take cascading parameter attribute type into account when supplying cascading values

src/Components/Components/src/Binding/CascadingModelBinder.cs

@@ -11,7 +11,7 @@ namespace Microsoft.AspNetCore.Components;
 /// <summary>
 /// Defines the binding context for data bound from external sources.
 /// </summary>
-public sealed class CascadingModelBinder : IComponent, ICascadingValueComponent, IDisposable
+public sealed class CascadingModelBinder : IComponent, ICascadingValueSupplier, IDisposable
 {
     private RenderHandle _handle;
     private ModelBindingContext? _bindingContext;
@@ -42,6 +42,8 @@ public sealed class CascadingModelBinder : IComponent, ICascadingValueComponent,
 
     [Inject] internal IFormValueSupplier FormValueSupplier { get; set; } = null!;
 
+    internal ModelBindingContext? BindingContext => _bindingContext;
+
     void IComponent.Attach(RenderHandle renderHandle)
     {
         _handle = renderHandle;
@@ -142,8 +144,15 @@ void IDisposable.Dispose()
         Navigation.LocationChanged -= HandleLocationChanged;
     }
 
-    bool ICascadingValueComponent.CanSupplyValue(Type valueType, string? valueName)
+    bool ICascadingValueSupplier.CanSupplyValue(in CascadingParameterInfo parameterInfo)
     {
+        if (parameterInfo.Attribute is not IFormValueCascadingParameterAttribute formCascadingParameterAttribute)
+        {
+            return false;
+        }
+
+        var valueType = parameterInfo.PropertyType;
+        var valueName = formCascadingParameterAttribute.Name;
         var formName = string.IsNullOrEmpty(valueName) ?
             (_bindingContext?.Name) :
             ModelBindingContext.Combine(_bindingContext, valueName);
@@ -174,21 +183,21 @@ bool ICascadingValueComponent.CanSupplyValue(Type valueType, string? valueName)
         return false;
     }
 
-    void ICascadingValueComponent.Subscribe(ComponentState subscriber)
+    void ICascadingValueSupplier.Subscribe(ComponentState subscriber)
     {
         throw new InvalidOperationException("Form values are always fixed.");
     }
 
-    void ICascadingValueComponent.Unsubscribe(ComponentState subscriber)
+    void ICascadingValueSupplier.Unsubscribe(ComponentState subscriber)
     {
         throw new InvalidOperationException("Form values are always fixed.");
     }
 
-    object? ICascadingValueComponent.CurrentValue => _bindingInfo == null ?
+    object? ICascadingValueSupplier.GetCurrentValue(in CascadingParameterInfo parameterInfo) => _bindingInfo == null ?
         throw new InvalidOperationException("Tried to access form value before it was bound.") :
         _bindingInfo.BoundValue;
 
-    bool ICascadingValueComponent.CurrentValueIsFixed => true;
+    bool ICascadingValueSupplier.CurrentValueIsFixed => true;
 
     private record BindingInfo(string? FormName, Type ValueType, bool BindingResult, object? BoundValue);
 }

src/Components/Components/src/Binding/IFormValueCascadingParameterAttribute.cs

@@ -0,0 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Binding;
+
+internal interface IFormValueCascadingParameterAttribute : ICascadingParameterAttribute
+{
+}

src/Components/Components/src/CascadingParameterAttribute.cs

@@ -9,7 +9,7 @@ namespace Microsoft.AspNetCore.Components;
 /// supplies values with a compatible type and name.
 /// </summary>
 [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
-public sealed class CascadingParameterAttribute : Attribute
+public sealed class CascadingParameterAttribute : Attribute, ICascadingParameterAttribute
 {
     /// <summary>
     /// If specified, the parameter value will be supplied by the closest

src/Components/Components/src/CascadingParameterInfo.cs

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components;
+
+internal readonly struct CascadingParameterInfo(ICascadingParameterAttribute attribute, string propertyName, Type propertyType)
+{
+    public ICascadingParameterAttribute Attribute { get; } = attribute;
+    public string PropertyName { get; } = propertyName;
+    public Type PropertyType { get; } = propertyType;
+}

src/Components/Components/src/CascadingParameterState.cs

@@ -13,21 +13,21 @@ namespace Microsoft.AspNetCore.Components;
 
 internal readonly struct CascadingParameterState
 {
-    private static readonly ConcurrentDictionary<Type, ReflectedCascadingParameterInfo[]> _cachedInfos = new();
+    private static readonly ConcurrentDictionary<Type, CascadingParameterInfo[]> _cachedInfos = new();
 
-    public string LocalValueName { get; }
-    public ICascadingValueComponent ValueSupplier { get; }
+    public CascadingParameterInfo ParameterInfo { get; }
+    public ICascadingValueSupplier ValueSupplier { get; }
 
-    public CascadingParameterState(string localValueName, ICascadingValueComponent valueSupplier)
+    public CascadingParameterState(in CascadingParameterInfo parameterInfo, ICascadingValueSupplier valueSupplier)
     {
-        LocalValueName = localValueName;
+        ParameterInfo = parameterInfo;
         ValueSupplier = valueSupplier;
     }
 
     public static IReadOnlyList<CascadingParameterState> FindCascadingParameters(ComponentState componentState)
     {
         var componentType = componentState.Component.GetType();
-        var infos = GetReflectedCascadingParameterInfos(componentType);
+        var infos = GetCascadingParameterInfos(componentType);
 
         // For components known not to have any cascading parameters, bail out early
         if (infos.Length == 0)
@@ -48,23 +48,21 @@ public static IReadOnlyList<CascadingParameterState> FindCascadingParameters(Com
             {
                 // Although not all parameters might be matched, we know the maximum number
                 resultStates ??= new List<CascadingParameterState>(infos.Length - infoIndex);
-
-                resultStates.Add(new CascadingParameterState(info.ConsumerValueName, supplier));
+                resultStates.Add(new CascadingParameterState(info, supplier));
             }
         }
 
         return resultStates ?? (IReadOnlyList<CascadingParameterState>)Array.Empty<CascadingParameterState>();
     }
 
-    private static ICascadingValueComponent? GetMatchingCascadingValueSupplier(in ReflectedCascadingParameterInfo info, ComponentState componentState)
+    private static ICascadingValueSupplier? GetMatchingCascadingValueSupplier(in CascadingParameterInfo info, ComponentState componentState)
     {
         var candidate = componentState;
         do
         {
-            if (candidate.Component is ICascadingValueComponent candidateSupplier
-                && candidateSupplier.CanSupplyValue(info.ValueType, info.SupplierValueName))
+            if (candidate.Component is ICascadingValueSupplier valueSupplier && valueSupplier.CanSupplyValue(info))
             {
-                return candidateSupplier;
+                return valueSupplier;
             }
 
             candidate = candidate.ParentComponentState;
@@ -74,64 +72,37 @@ public static IReadOnlyList<CascadingParameterState> FindCascadingParameters(Com
         return null;
     }
 
-    private static ReflectedCascadingParameterInfo[] GetReflectedCascadingParameterInfos(
+    private static CascadingParameterInfo[] GetCascadingParameterInfos(
         [DynamicallyAccessedMembers(Component)] Type componentType)
     {
         if (!_cachedInfos.TryGetValue(componentType, out var infos))
         {
-            infos = CreateReflectedCascadingParameterInfos(componentType);
+            infos = CreateCascadingParameterInfos(componentType);
             _cachedInfos[componentType] = infos;
         }
 
         return infos;
     }
 
-    private static ReflectedCascadingParameterInfo[] CreateReflectedCascadingParameterInfos(
+    private static CascadingParameterInfo[] CreateCascadingParameterInfos(
         [DynamicallyAccessedMembers(Component)] Type componentType)
     {
-        List<ReflectedCascadingParameterInfo>? result = null;
+        List<CascadingParameterInfo>? result = null;
         var candidateProps = ComponentProperties.GetCandidateBindableProperties(componentType);
         foreach (var prop in candidateProps)
         {
-            var attribute = prop.GetCustomAttribute<CascadingParameterAttribute>();
-            if (attribute != null)
+            var cascadingParameterAttribute = prop.GetCustomAttributes()
+                .OfType<ICascadingParameterAttribute>().SingleOrDefault();
+            if (cascadingParameterAttribute != null)
             {
-                result ??= new List<ReflectedCascadingParameterInfo>();
-
-                result.Add(new ReflectedCascadingParameterInfo(
-                    prop.Name,
-                    prop.PropertyType,
-                    attribute.Name));
-            }
-
-            var hostParameterAttribute = prop.GetCustomAttributes()
-                .OfType<IHostEnvironmentCascadingParameter>().SingleOrDefault();
-            if (hostParameterAttribute != null)
-            {
-                result ??= new List<ReflectedCascadingParameterInfo>();
-
-                result.Add(new ReflectedCascadingParameterInfo(
+                result ??= new List<CascadingParameterInfo>();
+                result.Add(new CascadingParameterInfo(
+                    cascadingParameterAttribute,
                     prop.Name,
-                    prop.PropertyType,
-                    hostParameterAttribute.Name));
+                    prop.PropertyType));
             }
         }
 
-        return result?.ToArray() ?? Array.Empty<ReflectedCascadingParameterInfo>();
-    }
-
-    readonly struct ReflectedCascadingParameterInfo
-    {
-        public string ConsumerValueName { get; }
-        public string? SupplierValueName { get; }
-        public Type ValueType { get; }
-
-        public ReflectedCascadingParameterInfo(
-            string consumerValueName, Type valueType, string? supplierValueName)
-        {
-            ConsumerValueName = consumerValueName;
-            SupplierValueName = supplierValueName;
-            ValueType = valueType;
-        }
+        return result?.ToArray() ?? Array.Empty<CascadingParameterInfo>();
     }
 }

src/Components/Components/src/CascadingQueryValueProvider.cs

@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.AspNetCore.Components.Routing;
+
+namespace Microsoft.AspNetCore.Components;
+
+internal sealed class CascadingQueryValueProvider : IComponent, ICascadingValueSupplier, IDisposable
+{
+    private readonly QueryParameterValueSupplier _queryParameterValueSupplier = new();
+
+    private HashSet<ComponentState>? _subscribers;
+    private RenderHandle _handle;
+    private bool _hasSetInitialParameters;
+
+    [Inject] private NavigationManager Navigation { get; set; } = default!;
+
+    [Parameter] public RenderFragment? ChildContent { get; set; }
+
+    void IComponent.Attach(RenderHandle renderHandle)
+    {
+        _handle = renderHandle;
+    }
+
+    Task IComponent.SetParametersAsync(ParameterView parameters)
+    {
+        if (!_hasSetInitialParameters)
+        {
+            _hasSetInitialParameters = true;
+
+            UpdateQueryParameterValues();
+
+            Navigation.LocationChanged += HandleLocationChanged;
+        }
+
+        parameters.SetParameterProperties(this);
+
+        _handle.Render(Render);
+
+        return Task.CompletedTask;
+    }
+
+    private void HandleLocationChanged(object? sender, LocationChangedEventArgs e)
+        => UpdateQueryParameterValues();
+
+    private void UpdateQueryParameterValues()
+    {
+        var query = GetQueryString(Navigation.Uri);
+
+        _queryParameterValueSupplier.ReadParametersFromQuery(query);
+
+        if (_subscribers is null)
+        {
+            return;
+        }
+
+        foreach (var subscriber in _subscribers)
+        {
+            subscriber.NotifyCascadingValueChanged(ParameterViewLifetime.Unbound);
+        }
+
+        static ReadOnlyMemory<char> GetQueryString(string url)
+        {
+            var queryStartPos = url.IndexOf('?');
+
+            if (queryStartPos < 0)
+            {
+                return default;
+            }
+
+            var queryEndPos = url.IndexOf('#', queryStartPos);
+            return url.AsMemory(queryStartPos..(queryEndPos < 0 ? url.Length : queryEndPos));
+        }
+    }
+
+    private void Render(RenderTreeBuilder builder)
+    {
+        builder.AddContent(0, ChildContent);
+    }
+
+    bool ICascadingValueSupplier.CanSupplyValue(in CascadingParameterInfo parameterInfo)
+        => parameterInfo.Attribute is SupplyParameterFromQueryAttribute;
+
+    bool ICascadingValueSupplier.CurrentValueIsFixed => false;
+
+    object? ICascadingValueSupplier.GetCurrentValue(in CascadingParameterInfo parameterInfo)
+    {
+        var queryParameterName = parameterInfo.Attribute.Name ?? parameterInfo.PropertyName;
+        return _queryParameterValueSupplier.GetQueryParameterValue(parameterInfo.PropertyType, queryParameterName);
+    }
+
+    void ICascadingValueSupplier.Subscribe(ComponentState subscriber)
+    {
+        _subscribers ??= new();
+        _subscribers.Add(subscriber);
+    }
+
+    void ICascadingValueSupplier.Unsubscribe(ComponentState subscriber)
+    {
+        _subscribers?.Remove(subscriber);
+    }
+
+    void IDisposable.Dispose()
+    {
+        Navigation.LocationChanged -= HandleLocationChanged;
+    }
+}

src/Components/Components/src/CascadingValue.cs

@@ -8,7 +8,7 @@ namespace Microsoft.AspNetCore.Components;
 /// <summary>
 /// A component that provides a cascading value to all descendant components.
 /// </summary>
-public class CascadingValue<TValue> : ICascadingValueComponent, IComponent
+public class CascadingValue<TValue> : ICascadingValueSupplier, IComponent
 {
     private RenderHandle _renderHandle;
     private HashSet<ComponentState>? _subscribers; // Lazily instantiated
@@ -41,9 +41,7 @@ public class CascadingValue<TValue> : ICascadingValueComponent, IComponent
     /// </summary>
     [Parameter] public bool IsFixed { get; set; }
 
-    object? ICascadingValueComponent.CurrentValue => Value;
-
-    bool ICascadingValueComponent.CurrentValueIsFixed => IsFixed;
+    bool ICascadingValueSupplier.CurrentValueIsFixed => IsFixed;
 
     /// <inheritdoc />
     public void Attach(RenderHandle renderHandle)
@@ -130,18 +128,26 @@ public Task SetParametersAsync(ParameterView parameters)
         return Task.CompletedTask;
     }
 
-    bool ICascadingValueComponent.CanSupplyValue(Type requestedType, string? requestedName)
+    bool ICascadingValueSupplier.CanSupplyValue(in CascadingParameterInfo parameterInfo)
     {
-        if (!requestedType.IsAssignableFrom(typeof(TValue)))
+        if (parameterInfo.Attribute is not CascadingParameterAttribute cascadingParameterAttribute || !parameterInfo.PropertyType.IsAssignableFrom(typeof(TValue)))
         {
             return false;
         }
 
-        return (requestedName == null && Name == null) // Match on type alone
-            || string.Equals(requestedName, Name, StringComparison.OrdinalIgnoreCase); // Also match on name
+        // We only consider explicitly specified names, not the property name.
+        var parameterSpecifiedName = cascadingParameterAttribute.Name;
+
+        return (parameterSpecifiedName == null && Name == null) || // Match on type alone
+            string.Equals(parameterSpecifiedName, Name, StringComparison.OrdinalIgnoreCase); // Also match on name
+    }
+
+    object? ICascadingValueSupplier.GetCurrentValue(in CascadingParameterInfo parameterInfo)
+    {
+        return Value;
     }
 
-    void ICascadingValueComponent.Subscribe(ComponentState subscriber)
+    void ICascadingValueSupplier.Subscribe(ComponentState subscriber)
     {
 #if DEBUG
         if (IsFixed)
@@ -160,7 +166,7 @@ void ICascadingValueComponent.Subscribe(ComponentState subscriber)
         _subscribers.Add(subscriber);
     }
 
-    void ICascadingValueComponent.Unsubscribe(ComponentState subscriber)
+    void ICascadingValueSupplier.Unsubscribe(ComponentState subscriber)
     {
         _subscribers?.Remove(subscriber);
     }