Parameter updates not captured in SetParametersAsync if [Parameter]Changed assigns same value

[yanisslav]

Is there an existing issue for this?

• I have searched the existing issues

Describe the bug

In .NET 10, we’ve noticed the following difference compared to .NET 8 and 9.

I’m not sure if this is actually a bug, but there is a clear difference - so this is more of a question to understand what the expected behavior should be.

We have the following:

InputComponent:

<input @bind="@Value" @oninput="OnInput" />

@code {
    private bool _valueChanged;

    [Parameter]
    public string Value { get; set; }

    [Parameter]
    public EventCallback<string> ValueChanged { get; set; }

    private async Task OnInput(ChangeEventArgs e)
    {
        Value = e.Value.ToString();
        await ValueChanged.InvokeAsync(Value);
    }

    public override Task SetParametersAsync(ParameterView parameters)
    {
        _valueChanged = HasParameterChanged(parameters, nameof(Value), Value);
        Console.WriteLine($"SetParametersAsync fired: {_valueChanged}");
        return base.SetParametersAsync(parameters);
    }

    public bool HasParameterChanged<TParameterType>(ParameterView parameters, string parameterName, TParameterType value)
    {
        if (parameters.TryGetValue(parameterName, out TParameterType parameterValue))
        {
            return !EqualityComparer<TParameterType>.Default.Equals(parameterValue, value);
        }

        return false;
    }
}

This works OK, except in cases like the following:

<InputComponent Value="@Value" ValueChanged="@OnValueChanged" />

@code {
    private string Value { get; set; } = "Initial Value";

    private void OnValueChanged(string newValue)
    {
        Value = "Initial Value";
    }
}

When typing in the input field, the ValueChanged event is triggered with the entered value, and the ValueChanged handler is invoked. In this handler, we set the Value parameter to the same value, instead of using the newValue.

Before invoking the ValueChanged event, we assign the Value of the InputComponent to the string value returned from the @oninput event.

Example (when entering “123” in the input):

.NET 8/9: Inside the SetParametersAsync method, we can detect that the Value set within the ValueChanged handler differs from the Value of the InputComponent.

.NET 10: We can no longer detect this change - the SetParametersAsync is not triggered at all.

Expected Behavior

No response

Steps To Reproduce

No response

Exceptions (if any)

No response

.NET Version

10

Anything else?

No response

[javiercn]

@yanisslav thanks for contacting us.

I'm not aware of any change that we have done in 10.0 that would impact this. To make sure that we are on the same page, can you create a public github repository with a repro project and specific repro steps? (make the project multi-target 9/10 or 8/10)

[yanisslav]

The information I initially shared in the issue was slightly incorrect, sorry about that. The SetParametersAsync method isn’t triggered at all, and I’ve updated the description.

I created this repository to show the different behavior.

[javiercn]

We have investigated the issue and can explain why the component no longer re-renders when the ValueChanged callback parameter is updated in .NET 10.

What we observed

In your reproduction scenario, the MyComponent child component receives two parameters from the parent: Value and ValueChanged. When text is typed into the input field, the child invokes the ValueChanged callback, but the parent's callback implementation sets Value back to "Initial Value" rather than accepting the new value from the child:

private void OnValueChanged(string newValue)
{
    Value = "Initial Value";  // Always resets to initial value
}

In .NET 8 and 9, SetParametersAsync was invoked on the child component after each input event, even though the Value parameter remained unchanged at "Initial Value". In .NET 10, SetParametersAsync is no longer invoked in this scenario, and the component does not re-render.

Why this happens

The change in behavior stems from an improvement to how Blazor compares EventCallback parameters to determine if a component needs to re-render. Previously, Blazor used reference equality (ReferenceEquals) to compare callback delegates. In .NET 10, we improved this to use semantic equality (Delegate.Equals()), which correctly identifies when a callback points to the same method instance.

In your scenario:

• The Value parameter remains "Initial Value" throughout (no change)
• The ValueChanged callback continues pointing to the same OnValueChanged method instance (no semantic change)

Since neither parameter has meaningfully changed, Blazor correctly determines that the component does not need to re-render. This represents a performance optimization that avoids unnecessary rendering cycles when component parameters haven't actually changed.

It is discouraged that you set a component parameter directly from an event handler. You are mixing up state and parameters and that will interfere in the blazor rendering process. More details here