如果值更改，是否需要重新实例化 EditContext？

是的你是。因为你没有重置上下文。如果将上下文设置为新对象，整个EditForm[包括编辑控件]将重建。

但是，假设RateItemModel是一个类，即引用对象，您的问题会引发几个问题。

1. 如何检测是否Value发生变化？引用更改是可以的，但是如果您在编辑上下文之外更改对象会怎样。您是否覆盖了数据类的相等比较器，然后检查了相等性OnParametersSet？

2. 为什么会Value改变，父组件强制渲染级联事件？如果父渲染器那么您的编辑组件将因为Value是一个对象，所以它渲染它，因为它无法检测是否已Value更改。

假设您可以检测到更改，您需要考虑两种情况：

1. 当前的表单是干净的，如何告诉用户数据已更改且表单已重新加载？
2. 当前的表格很脏。你们如何解决分歧？

这是我根据您的描述构建的演示 MRE。我做了一些猜测来填补空白，并使用标准控件而不是昂贵的 DX 东西。

它使用字典来跟踪数据对象。

它可能为如何实现您想要做的事情提供了不同的见解。如果您编辑一个值然后转到其他地方，就会出现问题，但在我确定我的 MRE 非常接近您的用例之前，我不会展示如何解决该问题。

我的数据对象：

public class Country
{
    public int Id { get; init; }  //Normally I would use a Guid, but you're probably using an int
    public string? Name { get; set; }
    public int Likes { get; set; }
    public DateTime LastEdit { get; set; } = DateTime.Now;  //dirty but quick way of tracking equality
}

// Demo Data provider
public static class CountryProvider
{
    private static List<Country> _countries = new()
        {
            new() {Id = 1, Name = "France", Likes= 1 },
            new() {Id = 2, Name = "UK", Likes= 0 },
            new() {Id = 3, Name = "Spain", Likes= 4 },
            new() {Id = 4, Name = "Portugal", Likes= 5 },
        };

    public static async Task<IEnumerable<Country>> GetCountries()
    {
        await Task.Delay(100);
        return _countries.AsEnumerable();
    }

    public static async Task SaveAsync(Country country)
    {
        // Do the save
        await Task.Delay(50);
    }
}

public record LikesData(int Id);

卡片”

<div class="card">
    <div class="card-header">@Value.Name</div>
    <div class="card-body">
        <div class="alert alert-primary p-2 m-2"> Likes: @_model.Likes</div>
        <EditForm EditContext="_editContext" OnValidSubmit="Submit">
            <div class="input-group mb-3">
                <InputText class="form-control" @bind-Value="_model.Name" />
                <button class="btn btn-success" type="submit">Update</button>
            </div>
        </EditForm>
        <div class="m-2 text-end">
            <button class="btn btn-primary" @onclick="UpdateLikes">Like</button>
        </div>
    </div>
</div>

@code {
    [Parameter] public Country Value { get; set; } = new();
    [Parameter] public EventCallback<Country> ValueChanged { get; set; }
    [Parameter] public EventCallback<LikesData> LikesChanged { get; set; }

    private EditContext? _editContext;
    private Country _model = new();

    // This is here so we have all our data sorted before any first render
    public override Task SetParametersAsync(ParameterView parameters)
    {
        parameters.SetParameterProperties(this);

        ArgumentNullException.ThrowIfNull(this.Value);

        // Timestamp used to track edit state.  You can use what mechanism you like
        // I use value objects for all my data simplifying equality checking
        // Country would be public record Country{};
        // and here i would create a CountryEditContext object for editing
        if (this.Value.LastEdit != _model.LastEdit)
        {
            _model = new()
                {
                    Id = this.Value.Id,
                    Name = this.Value.Name,
                    Likes = this.Value.Likes,
                    LastEdit = this.Value.LastEdit,
                };
            _editContext = new(_model);
        }

        return base.SetParametersAsync(ParameterView.Empty);
    }

    //Your return object may be more complex so I've used a value object rather than just an int
    private async Task UpdateLikes()
    {
        await this.LikesChanged.InvokeAsync(new(this.Value.Id));
    }

    // Form submit on validation.
    private async Task Submit()
    {
        _model.LastEdit = DateTime.Now;
        await this.ValueChanged.InvokeAsync(_model);
    }
}

和页面：

<div class="row">
    @foreach(var country in _countries )
    {
        <div class="col-12 col-md-6 col-lg-4">
            <CountryCard @key="country.Value.Id"
            Value="country.Value" 
            ValueChanged="this.UpdateCountry" 
            LikesChanged="this.UpdateLikes" />
        </div>
    }
</div>

@code {

    // use a dictionary so we can separate out the index from the object and only replace the object on an update
    private Dictionary<int, Country> _countries = new();

    protected override async Task OnInitializedAsync()
    {
        var countries = await CountryProvider.GetCountries();
        // normally need to check here if you have a list here and do something if you don't
        foreach(var country in countries)
            _countries.Add(country.Id, country);
    }

    private async  Task UpdateCountry(Country country)
    {
        _countries[country.Id] = country;
        await CountryProvider.SaveAsync(country);
    }

    private void UpdateLikes(LikesData value)
    {
        _countries[value.Id].Likes++;
        _countries[value.Id].LastEdit = DateTime.Now;
    }
}