best way to validate user input across multiple form fields in C#?

Best Way to Validate User Input Across Multiple Form Fields in C#

When you have multiple input controls (textboxes, dropdowns, checkboxes) and want a clean, scalable approach, there are a few standard patterns in C# and .NET:

1. Data Annotations (Recommended for Simplicity)

Use attributes on your model properties to define validation rules.
Works well for both ASP.NET MVC / Razor Pages and WinForms/WPF with binding.
Automatically integrates with validation helpers and client-side validation in MVC.

Example:

public class StudentForm
{
    [Required(ErrorMessage = "Name is required")]
    [StringLength(50, ErrorMessage = "Name cannot exceed 50 characters")]
    public string Name { get; set; }

    [Range(18, 100, ErrorMessage = "Age must be between 18 and 100")]
    public int Age { get; set; }

    [Required(ErrorMessage = "Please select a course")]
    public string Course { get; set; }

    [EmailAddress(ErrorMessage = "Invalid email format")]
    public string Email { get; set; }
}

Validate in code:

var student = new StudentForm { Name = "", Age = 17, Course = null };
var context = new ValidationContext(student, null, null);
var results = new List();

bool isValid = Validator.TryValidateObject(student, context, results, true);

foreach (var error in results)
{
    Console.WriteLine(error.ErrorMessage);
}

? Pros: Minimal code, declarative, easy to maintain.
? Cons: Less flexible for complex custom logic.

2. Custom Validation Classes

Useful if your rules are dynamic or involve multiple fields together.
Create a Validator class to centralize logic.

Example:

public class StudentValidator
{
    public List Validate(StudentForm student)
    {
        var errors = new List();

        if (string.IsNullOrWhiteSpace(student.Name))
            errors.Add("Name is required.");

        if (student.Age < 18 || student.Age > 100)
            errors.Add("Age must be between 18 and 100.");

        if (string.IsNullOrEmpty(student.Course))
            errors.Add("Course selection is required.");

        if (!string.IsNullOrEmpty(student.Email) && !student.Email.Contains("@"))
            errors.Add("Invalid email address.");

        return errors;
    }
}

Usage:

var validator = new StudentValidator();
var errors = validator.Validate(student);

if (errors.Any())
{
    foreach (var error in errors)
        Console.WriteLine(error);
}
else
{
    Console.WriteLine("All inputs valid!");
}

? Pros: Full control, easy to extend for multiple forms.
? Cons: More code than data annotations.

3. FluentValidation Library (Modern, Clean, Scalable)

Third-party library, widely used in .NET projects.
Supports complex rules, cross-field validation, and reusable validators.

Example:

using FluentValidation;

public class StudentValidator : AbstractValidator
{
    public StudentValidator()
    {
        RuleFor(x => x.Name).NotEmpty().WithMessage("Name is required")
                             .MaximumLength(50);
        RuleFor(x => x.Age).InclusiveBetween(18, 100);
        RuleFor(x => x.Course).NotEmpty();
        RuleFor(x => x.Email).EmailAddress().When(x => !string.IsNullOrEmpty(x.Email));
    }
}

// Usage
var validator = new StudentValidator();
var results = validator.Validate(student);

if (!results.IsValid)
{
    foreach (var failure in results.Errors)
        Console.WriteLine(failure.ErrorMessage);
}

? Pros: Clean, maintainable, reusable, supports complex scenarios.
? Cons: Requires NuGet package.

Recommendation

For simple forms: Use Data Annotations.
For complex forms with cross-field logic: Use Custom Validation Class or FluentValidation.
Always centralize validation logic to make it scalable and maintainable.