WPF输入验证如何实现参考其他字段的逻辑？（附现有代码）

嘿，针对你在WPF里需要实现跨字段验证的需求，结合你已经基于DataErrorValidation完成基础验证的现状，我整理了几个实用的技术方案，你可以根据自己的场景选择：

既然你已经用了ValidatesOnDataErrors=true，最直接的方式就是在ViewModel的IDataErrorInfo实现里，针对目标字段（比如proxyUser）加入对其他关联字段（比如ownerType）的检查逻辑。

举个具体的代码示例：

public class ConferenceViewModel : IDataErrorInfo, INotifyPropertyChanged
{
    // 你的现有属性
    private string _ownerType;
    public string OwnerType
    {
        get => _ownerType;
        set
        {
            _ownerType = value;
            OnPropertyChanged(nameof(OwnerType));
            // 关键：当OwnerType变化时，触发ProxyUser的验证重新执行
            OnPropertyChanged(nameof(ProxyUser));
        }
    }

    private string _proxyUser;
    public string ProxyUser
    {
        get => _proxyUser;
        set
        {
            _proxyUser = value;
            OnPropertyChanged(nameof(ProxyUser));
            // 可选：当ProxyUser变化时，也触发OwnerType的验证
            OnPropertyChanged(nameof(OwnerType));
        }
    }

    // IDataErrorInfo 实现
    public string Error => string.Empty;

    public string this[string columnName]
    {
        get
        {
            string errorMsg = null;
            switch (columnName)
            {
                case nameof(ProxyUser):
                    // 跨字段逻辑：当OwnerType是特定值时，ProxyUser不能为空
                    if (OwnerType == "ProxyRequired" && string.IsNullOrWhiteSpace(ProxyUser))
                    {
                        errorMsg = "当会议所有者类型为「代理要求」时，代理用户不能为空";
                    }
                    break;
                case nameof(OwnerType):
                    // 反向验证：如果填写了ProxyUser，OwnerType必须是代理类型
                    if (!string.IsNullOrWhiteSpace(ProxyUser) && OwnerType != "ProxyRequired")
                    {
                        errorMsg = "当填写代理用户时，会议所有者类型必须选择「代理要求」";
                    }
                    break;
            }
            return errorMsg;
        }
    }

    // INotifyPropertyChanged 实现
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

这个方案的好处是完全基于WPF原生验证体系，不需要额外依赖，逻辑集中在ViewModel里，符合MVVM模式。

如果你希望把验证逻辑和ViewModel解耦，可以自定义ValidationRule，通过BindingGroup获取其他字段的值。

首先在XAML的控件容器（比如StackPanel或Grid）上设置BindingGroup：

<StackPanel BindingGroup="{Binding}">
    <Label x:Name="lbl_TMSownerType" Content="Conference Owner Type" />
    <mah:SplitButton x:Name="cBox_ownerType" SelectedItem="{Binding OwnerType}" />
    <Label x:Name="lbl_proxyUser" Content="Proxy User" />
    <TextBox x:Name="txtBox_proxyUser">
        <TextBox.Text>
            <Binding Path="ProxyUser" UpdateSourceTrigger="PropertyChanged" NotifyOnValidationError="true">
                <Binding.ValidationRules>
                    <local:ProxyUserCrossFieldRule ValidationStep="ConvertedProposedValue" />
                </Binding.ValidationRules>
            </Binding>
        </TextBox.Text>
    </TextBox>
</StackPanel>

然后实现自定义ValidationRule：

public class ProxyUserCrossFieldRule : ValidationRule
{
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        // 通过BindingGroup获取ViewModel中的其他字段值
        if (BindingGroup != null && BindingGroup.DataItem is ConferenceViewModel vm)
        {
            var proxyUser = value as string;
            if (vm.OwnerType == "ProxyRequired" && string.IsNullOrWhiteSpace(proxyUser))
            {
                return new ValidationResult(false, "当会议所有者类型为「代理要求」时，代理用户不能为空");
            }
        }
        return ValidationResult.ValidResult;
    }
}

这个方案适合简单的跨字段验证，逻辑放在视图层，ViewModel只负责数据。

如果你的验证规则很多、逻辑复杂，推荐用FluentValidation库，它提供了更优雅的链式语法和跨字段验证支持。

首先安装NuGet包：FluentValidation和FluentValidation.WPF，然后创建ViewModel的验证器：

public class ConferenceViewModelValidator : AbstractValidator<ConferenceViewModel>
{
    public ConferenceViewModelValidator()
    {
        // 跨字段规则：当OwnerType是ProxyRequired时，ProxyUser不能为空
        RuleFor(vm => vm.ProxyUser)
            .NotEmpty()
            .When(vm => vm.OwnerType == "ProxyRequired")
            .WithMessage("当会议所有者类型为「代理要求」时，代理用户不能为空");

        // 反向规则：当ProxyUser有值时，OwnerType必须是ProxyRequired
        RuleFor(vm => vm.OwnerType)
            .Equal("ProxyRequired")
            .When(vm => !string.IsNullOrWhiteSpace(vm.ProxyUser))
            .WithMessage("当填写代理用户时，会议所有者类型必须选择「代理要求」");
    }
}

最后在ViewModel中集成验证（或者在App启动时注册全局验证器）：

public class ConferenceViewModel : INotifyPropertyChanged
{
    private readonly ConferenceViewModelValidator _validator = new ConferenceViewModelValidator();
    private string _ownerType;
    private string _proxyUser;

    // 属性和INotifyPropertyChanged实现...

    // 实现验证逻辑
    public string this[string columnName]
    {
        get
        {
            var result = _validator.Validate(this, ruleSet: columnName);
            return result.IsValid ? null : result.Errors.FirstOrDefault()?.ErrorMessage;
        }
    }
}

这个方案的优势是代码可读性高，规则可复用，适合复杂的业务场景。

内容的提问来源于stack exchange，提问作者Salim