How to handle empty string textbox bound to an int property validation error in WPF? Value "" could be not converted MVVM

The conversion error occurs even before the Quantity property is assigned a value, so validation in the ViewModel won't even be called. The purpose of validation in the ViewModel is to determine the validity of an already received int value.

There are several approaches to solving your problem. The most important thing is to define the solution concept. There are two main ones:

1. The ViewModel is indifferent to user input. It only works with already received values ​​of the correct type.

In this case, determining the validity of a value for conversion to the required type should be handled at the View level.

One option is to limit the number of characters in user input, as suggested by "Gerry Schmitz." You can also use:

• handling the Validation.Error event. Replace the error message in the event;
• a custom converter with type casting;
• replacing the Validation.ErrorTemplate template;
• a custom ValidationRule, roughly implemented like this:

public class IntValidationRule : ValidationRule
{
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        if (value is string stringValue)
        {
            if (string.IsNullOrWhiteSpace(stringValue))
            {
                return new ValidationResult(false, "The field cannot be empty");
            }
            
            if (!int.TryParse(stringValue, out int result))
            {
                return new ValidationResult(false, "Enter an integer");
            }
            
            if (result < 0)
            {
                return new ValidationResult(false, "The value cannot be negative");
            }
        }
        
        return ValidationResult.ValidResult;
    }
}

And then this validator is used in the binding:

    <TextBox.Text>
        <Binding Path="Quantity" 
                 UpdateSourceTrigger="PropertyChanged"
                 ValidatesOnNotifyDataErrors="True">
            <Binding.ValidationRules>
                <local:IntValidationRule ValidationStep="RawProposedValue"/>
            </Binding.ValidationRules>
        </Binding>
    </TextBox.Text>

2. The ViewModel completely controls user input.

Since user input is always a string value, validating that string value and converting it to the required type becomes the responsibility of the ViewModel.

This requires creating a string property in the ViewModel. For example, the following implementation might be used:

using CommunityToolkit.Mvvm.ComponentModel;

public partial class YourViewModel : ObservableValidator
{
    private int quantity = 1;
    private string quantityString = "1";

    [Required]
    [Range(0, int.MaxValue, ErrorMessage = "The value must be in the range from 0 to 2147483647")]
    public int Quantity
    {
        get => quantity;
        set
        {
            if (SetProperty(ref quantity, value))
            {
                QuantityString = value.ToString();
                OnPropertyChanged(nameof(LineTotal));
                OnPropertyChanged(nameof(Price));
                SaleViewModel.CalculateTotal();
            }
        }
    }

    public string QuantityString
    {
        get => quantityString;
        set
        {
            if (SetProperty(ref quantityString, value))
            {
                ValidateProperty(value, nameof(QuantityString));
                
                if (int.TryParse(value, out int result))
                {
                    Quantity = result;
                    ClearErrors(nameof(QuantityString));
                }
                else if (!string.IsNullOrWhiteSpace(value))
                {
                    AddError(nameof(QuantityString), "Enter an integer");
                }
            }
        }
    }

    // Custom validation for QuantityString
    private static void ValidateQuantityString(string value, ValidationContext context)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            return; // The required attribute will handle empty values ​​automatically.
        }
        
        if (!int.TryParse(value, out _))
        {
            throw new ValidationException("Enter an integer");
        }
    }
}

Сan create many other options, but to do this you first need to decide what exactly you need and which conceptual option suits you.