基于Behaviors的Xamarin Forms验证：验证失败阻止提交的最佳实践

Great question! I’ve tackled this exact scenario in multiple Xamarin.Forms projects, so let’s break down the most effective and maintainable approaches to prevent submitting invalid data to your web service—building on the attached numeric validation behavior you’re already using.

1. Bind Validation State to Disable the Submit Button (Immediate User Feedback) #

This is the most user-friendly approach: users see right away when they can’t submit, and it eliminates the need for post-submit error messages. Here’s how to extend your existing AttachedNumericValidationBehavior to support this:

First, add a bindable IsValid property to your behavior to expose the validation state:

public static readonly BindableProperty IsValidProperty =
    BindableProperty.CreateAttached(
        "IsValid", 
        typeof(bool), 
        typeof(AttachedNumericValidationBehavior), 
        true,
        BindingMode.OneWayToSource);

public static bool GetIsValid(BindableObject view)
{
    return (bool)view.GetValue(IsValidProperty);
}

public static void SetIsValid(BindableObject view, bool value)
{
    view.SetValue(IsValidProperty, value);
}

Then, update your validation logic to toggle this property when the entry’s text changes. For example, in the OnEntryTextChanged method:

private static void OnEntryTextChanged(object sender, TextChangedEventArgs args)
{
    var entry = sender as Entry;
    bool isValid = double.TryParse(args.NewTextValue, out _);
    
    // Update the entry's visual state (your existing red border logic)
    entry.TextColor = isValid ? Color.Default : Color.Red;
    
    // Update the IsValid attached property
    SetIsValid(entry, isValid);
}

Now, bind your submit button’s IsEnabled property directly to the entry’s validation state in XAML:

<Entry x:Name="NumericEntry">
    <Entry.Behaviors>
        <local:AttachedNumericValidationBehavior />
    </Entry.Behaviors>
</Entry>

<Button 
    Text="Submit to Web Service"
    IsEnabled="{Binding Source={x:Reference NumericEntry}, Path=(local:AttachedNumericValidationBehavior.IsValid)}"
    Command="{Binding SubmitCommand}" />

For multiple fields, use a MultiBinding or aggregate all validation states in your ViewModel to control the button’s enabled state.

2. Validate in the Submit Command (MVVM-First Approach) #

If you’re using MVVM, implementing the INotifyDataErrorInfo interface is the standard .NET way to handle validation—this keeps your validation logic in the ViewModel and makes it easy to check for errors before submitting.

Here’s a simplified ViewModel example:

public class NumericEntryViewModel : INotifyPropertyChanged, INotifyDataErrorInfo
{
    private string _numericValue;
    private readonly Dictionary<string, List<string>> _validationErrors = new Dictionary<string, List<string>>();

    public string NumericValue
    {
        get => _numericValue;
        set
        {
            _numericValue = value;
            ValidateNumericInput();
            OnPropertyChanged();
        }
    }

    public ICommand SubmitCommand => new Command(ExecuteSubmit, CanExecuteSubmit);

    private bool CanExecuteSubmit()
    {
        // Block execution if there are any validation errors
        return !HasErrors;
    }

    private void ExecuteSubmit()
    {
        // Double-check errors (in case of edge cases bypassing UI state)
        if (HasErrors) return;
        
        // Call your web service here safely
        // await _webService.SubmitData(NumericValue);
    }

    private void ValidateNumericInput()
    {
        var errors = new List<string>();
        if (string.IsNullOrWhiteSpace(NumericValue) || !double.TryParse(NumericValue, out _))
        {
            errors.Add("Please enter a valid number");
        }

        UpdateErrors("NumericValue", errors);
        ((Command)SubmitCommand).ChangeCanExecute();
    }

    private void UpdateErrors(string propertyName, List<string> errors)
    {
        if (errors.Any())
        {
            _validationErrors[propertyName] = errors;
        }
        else
        {
            _validationErrors.Remove(propertyName);
        }
        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }

    // Implement INotifyPropertyChanged and INotifyDataErrorInfo members
    public event PropertyChangedEventHandler PropertyChanged;
    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    public bool HasErrors => _validationErrors.Any();

    public IEnumerable GetErrors(string propertyName)
    {
        _validationErrors.TryGetValue(propertyName, out var errors);
        return errors ?? Enumerable.Empty<string>();
    }

    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

In your XAML, bind the entry to the ViewModel property and let the command handle the rest—no need to manually track UI state:

<Entry Text="{Binding NumericValue}" />
<Button Text="Submit" Command="{Binding SubmitCommand}" />

3. Perform a Final Validation Check Before Web Service Call #

Even if you disable the button or use command can-execute logic, it’s a good safety net to add a final validation check right before calling your web service. This prevents edge cases (like programmatic value changes that skip UI validation) from sending invalid data.

For example, in your submit method:

private async Task ExecuteSubmit()
{
    // Run validation one last time
    ValidateNumericInput();
    
    if (HasErrors)
    {
        // Show a user-friendly message if needed
        await Application.Current.MainPage.DisplayAlert("Error", "Please fix the invalid fields first", "OK");
        return;
    }

    // Proceed with web service call
    try
    {
        await _webService.SubmitData(NumericValue);
        await Application.Current.MainPage.DisplayAlert("Success", "Data submitted!", "OK");
    }
    catch (Exception ex)
    {
        await Application.Current.MainPage.DisplayAlert("Error", $"Failed to submit data: {ex.Message}", "OK");
    }
}

Key Takeaways #

• Prioritize user feedback: Disabling the submit button gives users immediate clarity on when their input is valid.
• Use MVVM standards: INotifyDataErrorInfo makes validation reusable and keeps your UI logic clean.
• Add a safety net: Always validate right before the web service call to catch any edge cases.

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