Apprendre Combining Validation and Parsing | Validating Input and Safe Parsing

Combining input validation and safe parsing is essential for building programs that can reliably handle user data. When you validate input before attempting to parse it, you greatly reduce the risk of runtime errors and ensure that your application only works with clean, well-formed data. This approach is especially important in scenarios where incorrect or unexpected input could lead to exceptions or corrupt your application's state.

Program.cs


              123456789101112131415161718192021222324252627282930
            
using System;

namespace ConsoleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Enter the number of seats you want to book:");
            string input = Console.ReadLine();

            // Step 1: Validate input - check if not empty and only contains digits
            if (string.IsNullOrWhiteSpace(input) || !int.TryParse(input, out int seats))
            {
                Console.WriteLine("Invalid input. Please enter a valid number.");
                return;
            }

            // Step 2: Additional validation - check if number is positive
            if (seats <= 0)
            {
                Console.WriteLine("Number of seats must be greater than zero.");
                return;
            }

            Console.WriteLine($"You have successfully booked {seats} seat(s).");
        }
    }
}

The typical flow for robust input handling is to first validate the input to check for basic requirements, such as non-empty values or correct format. Only after the input passes these checks do you attempt to parse it, using safe parsing methods like TryParse. This layered approach ensures that invalid data is filtered out early, so parsing is only attempted when it is likely to succeed.

BookingValidator.cs


              12345678910111213141516171819202122232425262728293031323334353637383940
            
using System;

namespace ConsoleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var validator = new BookingValidator();

            Console.Write("Enter number of seats: ");
            string input = Console.ReadLine();

            string error = validator.ValidateSeatsInput(input);

            if (error == null)
                Console.WriteLine("Input is valid.");
            else
                Console.WriteLine(error);
        }
    }

    public class BookingValidator
    {
        // Returns null if input is valid, otherwise returns an error message
        public string ValidateSeatsInput(string input)
        {
            if (string.IsNullOrWhiteSpace(input))
                return "Input cannot be empty.";

            if (!int.TryParse(input, out int seats))
                return "Input must be a number.";

            if (seats <= 0)
                return "Number of seats must be greater than zero.";

            return null;
        }
    }
}

This code validates user input for booking seats. It checks whether the input is empty, whether it can be converted to a number, and whether the number is greater than zero. If the input is valid, the method returns null; otherwise, it returns a specific error message describing what is wrong with the input.

1. Why should you validate before parsing?

2. What is the benefit of returning error messages for invalid input?

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 5

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you show me an example of how to implement this validation and parsing in code?

What are some common mistakes to avoid when validating and parsing user input?

Why is it important to return specific error messages for invalid input?

Glissez pour afficher le menu